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


HRESULT IAgilent34980A_get_Alarm(Agilent34980A* pT, IAgilent34980AAlarm** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A"), _T("get_Alarm"));
	NTL_METHOD_START(IAgilent34980A, get_Alarm);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Alarm"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A"), _T("get_Alarm"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980A_get_Calibration(Agilent34980A* pT, IAgilent34980ACalibration** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A"), _T("get_Calibration"));
	NTL_METHOD_START(IAgilent34980A, get_Calibration);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Calibration"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A"), _T("get_Calibration"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980A_get_Current(Agilent34980A* pT, IAgilent34980ACurrent** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A"), _T("get_Current"));
	NTL_METHOD_START(IAgilent34980A, get_Current);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Current"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A"), _T("get_Current"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980A_get_Diagnostic(Agilent34980A* pT, IAgilent34980ADiagnostic** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A"), _T("get_Diagnostic"));
	NTL_METHOD_START(IAgilent34980A, get_Diagnostic);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Diagnostic"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A"), _T("get_Diagnostic"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980A_get_Display(Agilent34980A* pT, IAgilent34980ADisplay** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A"), _T("get_Display"));
	NTL_METHOD_START(IAgilent34980A, get_Display);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Display"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A"), _T("get_Display"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980A_get_Frequency(Agilent34980A* pT, IAgilent34980AFrequency** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A"), _T("get_Frequency"));
	NTL_METHOD_START(IAgilent34980A, get_Frequency);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Frequency"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A"), _T("get_Frequency"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980A_get_FResistance(Agilent34980A* pT, IAgilent34980AFResistance** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A"), _T("get_FResistance"));
	NTL_METHOD_START(IAgilent34980A, get_FResistance);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_FResistance"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A"), _T("get_FResistance"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980A_get_Measurement(Agilent34980A* pT, IAgilent34980AMeasurement** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A"), _T("get_Measurement"));
	NTL_METHOD_START(IAgilent34980A, get_Measurement);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Measurement"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A"), _T("get_Measurement"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980A_get_Memory(Agilent34980A* pT, IAgilent34980AMemory** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A"), _T("get_Memory"));
	NTL_METHOD_START(IAgilent34980A, get_Memory);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Memory"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A"), _T("get_Memory"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980A_get_Period(Agilent34980A* pT, IAgilent34980APeriod** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A"), _T("get_Period"));
	NTL_METHOD_START(IAgilent34980A, get_Period);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Period"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A"), _T("get_Period"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980A_get_Resistance(Agilent34980A* pT, IAgilent34980AResistance** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A"), _T("get_Resistance"));
	NTL_METHOD_START(IAgilent34980A, get_Resistance);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Resistance"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A"), _T("get_Resistance"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980A_get_Route(Agilent34980A* pT, IAgilent34980ARoute** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A"), _T("get_Route"));
	NTL_METHOD_START(IAgilent34980A, get_Route);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Route"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A"), _T("get_Route"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980A_get_Scale(Agilent34980A* pT, IAgilent34980AScale** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A"), _T("get_Scale"));
	NTL_METHOD_START(IAgilent34980A, get_Scale);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Scale"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A"), _T("get_Scale"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980A_get_Scan(Agilent34980A* pT, IAgilent34980AScan** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A"), _T("get_Scan"));
	NTL_METHOD_START(IAgilent34980A, get_Scan);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Scan"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A"), _T("get_Scan"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980A_get_Statistics(Agilent34980A* pT, IAgilent34980AStatistics** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A"), _T("get_Statistics"));
	NTL_METHOD_START(IAgilent34980A, get_Statistics);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Statistics"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A"), _T("get_Statistics"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980A_get_Status(Agilent34980A* pT, IAgilent34980AStatus** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A"), _T("get_Status"));
	NTL_METHOD_START(IAgilent34980A, get_Status);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Status"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A"), _T("get_Status"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980A_get_System(Agilent34980A* pT, IAgilent34980ASystem** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A"), _T("get_System"));
	NTL_METHOD_START(IAgilent34980A, get_System);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_System"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A"), _T("get_System"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980A_get_Temperature(Agilent34980A* pT, IAgilent34980ATemperature** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A"), _T("get_Temperature"));
	NTL_METHOD_START(IAgilent34980A, get_Temperature);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Temperature"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A"), _T("get_Temperature"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980A_get_Voltage(Agilent34980A* pT, IAgilent34980AVoltage** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A"), _T("get_Voltage"));
	NTL_METHOD_START(IAgilent34980A, get_Voltage);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Voltage"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A"), _T("get_Voltage"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980A_get_Personality(Agilent34980A* pT, IAgilent34980APersonality** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A"), _T("get_Personality"));
	NTL_METHOD_START(IAgilent34980A, get_Personality);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Personality"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A"), _T("get_Personality"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980A_get_Trigger(Agilent34980A* pT, IAgilent34980ATrigger** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A"), _T("get_Trigger"));
	NTL_METHOD_START(IAgilent34980A, get_Trigger);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Trigger"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A"), _T("get_Trigger"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980APersonality_Select(Agilent34980A* pT, BSTR personalityName, IUnknown** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980APersonality"), _T("Select"));
	NTL_METHOD_START(IAgilent34980APersonality, Select);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("Select"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980APersonality"), _T("Select"), IN_PARAM(personalityName), OUT_PARAM(val), NULL);

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

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980APersonality_Select(personalityName, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980APersonality_GetPersonalityNames(Agilent34980A* pT, SAFEARRAY** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980APersonality"), _T("GetPersonalityNames"));
	NTL_METHOD_START(IAgilent34980APersonality, GetPersonalityNames);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("GetPersonalityNames"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980APersonality"), _T("GetPersonalityNames"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDmmAC_ConfigureBandwidth(Agilent34980A* pT, double MinFreq, double MaxFreq)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmAC"), _T("ConfigureBandwidth"));
	NTL_METHOD_START(IIviDmmAC, ConfigureBandwidth);
	CMethodTrace mt(pT, _T("IIviDmmAC"), _T("ConfigureBandwidth"), IN_PARAM(MinFreq), IN_PARAM(MaxFreq), NULL);

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

	strCmd.Format(_T(":VOLT:AC:BAND %.15g; :CURR:AC:BAND %.15g"), MinFreq, MinFreq);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmAC_ConfigureBandwidth(MinFreq, MaxFreq);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmAC_get_FrequencyMax(Agilent34980A* pT, double* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmAC"), _T("get_FrequencyMax"));
	NTL_METHOD_START(IIviDmmAC, get_FrequencyMax);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_FrequencyMax"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IIviDmmAC"), _T("get_FrequencyMax"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDmmAC_put_FrequencyMax(Agilent34980A* pT, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmAC"), _T("put_FrequencyMax"));
	NTL_METHOD_START(IIviDmmAC, put_FrequencyMax);
	CMethodTrace mt(pT, _T("IIviDmmAC"), _T("put_FrequencyMax"), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDmmAC_get_FrequencyMin(Agilent34980A* pT, double* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmAC"), _T("get_FrequencyMin"));
	NTL_METHOD_START(IIviDmmAC, get_FrequencyMin);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_FrequencyMin"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IIviDmmAC"), _T("get_FrequencyMin"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDmmAC_put_FrequencyMin(Agilent34980A* pT, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmAC"), _T("put_FrequencyMin"));
	NTL_METHOD_START(IIviDmmAC, put_FrequencyMin);
	CMethodTrace mt(pT, _T("IIviDmmAC"), _T("put_FrequencyMin"), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDmmAdvanced_get_ActualRange(Agilent34980A* pT, double* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmAdvanced"), _T("get_ActualRange"));
	NTL_METHOD_START(IIviDmmAdvanced, get_ActualRange);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ActualRange"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IIviDmmAdvanced"), _T("get_ActualRange"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDmmAdvanced_get_ApertureTime(Agilent34980A* pT, double* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmAdvanced"), _T("get_ApertureTime"));
	NTL_METHOD_START(IIviDmmAdvanced, get_ApertureTime);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ApertureTime"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IIviDmmAdvanced"), _T("get_ApertureTime"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDmmAdvanced_get_ApertureTimeUnits(Agilent34980A* pT, IviDmmApertureTimeUnitsEnum* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmAdvanced"), _T("get_ApertureTimeUnits"));
	NTL_METHOD_START(IIviDmmAdvanced, get_ApertureTimeUnits);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ApertureTimeUnits"), _T("val"));
		*val = IviDmmApertureSeconds;
	CMethodTrace mt(pT, _T("IIviDmmAdvanced"), _T("get_ApertureTimeUnits"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDmmAdvanced_get_AutoZero(Agilent34980A* pT, IviDmmAutoZeroEnum* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmAdvanced"), _T("get_AutoZero"));
	NTL_METHOD_START(IIviDmmAdvanced, get_AutoZero);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_AutoZero"), _T("val"));
		*val = IviDmmAutoZeroOff;
	CMethodTrace mt(pT, _T("IIviDmmAdvanced"), _T("get_AutoZero"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDmmAdvanced_put_AutoZero(Agilent34980A* pT, IviDmmAutoZeroEnum val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmAdvanced"), _T("put_AutoZero"));
	NTL_METHOD_START(IIviDmmAdvanced, put_AutoZero);
	CMethodTrace mt(pT, _T("IIviDmmAdvanced"), _T("put_AutoZero"), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDmmAdvanced_get_PowerlineFrequency(Agilent34980A* pT, double* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmAdvanced"), _T("get_PowerlineFrequency"));
	NTL_METHOD_START(IIviDmmAdvanced, get_PowerlineFrequency);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_PowerlineFrequency"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IIviDmmAdvanced"), _T("get_PowerlineFrequency"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("CAL:LFR?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmAdvanced_get_PowerlineFrequency(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmAdvanced_put_PowerlineFrequency(Agilent34980A* pT, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmAdvanced"), _T("put_PowerlineFrequency"));
	NTL_METHOD_START(IIviDmmAdvanced, put_PowerlineFrequency);
	CMethodTrace mt(pT, _T("IIviDmmAdvanced"), _T("put_PowerlineFrequency"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("CAL:LFR %.15g"), val);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmAdvanced_put_PowerlineFrequency(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmFrequency_get_VoltageRange(Agilent34980A* pT, double* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmFrequency"), _T("get_VoltageRange"));
	NTL_METHOD_START(IIviDmmFrequency, get_VoltageRange);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_VoltageRange"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IIviDmmFrequency"), _T("get_VoltageRange"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("FREQ:VOLT:RANG?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmFrequency_get_VoltageRange(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmFrequency_put_VoltageRange(Agilent34980A* pT, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmFrequency"), _T("put_VoltageRange"));
	NTL_METHOD_START(IIviDmmFrequency, put_VoltageRange);
	CMethodTrace mt(pT, _T("IIviDmmFrequency"), _T("put_VoltageRange"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("FREQ:VOLT:RANG %.15g"), val);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmFrequency_put_VoltageRange(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmMeasurement_IsOverRange(Agilent34980A* pT, double MeasurementValue, VARIANT_BOOL* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmMeasurement"), _T("IsOverRange"));
	NTL_METHOD_START(IIviDmmMeasurement, IsOverRange);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("IsOverRange"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IIviDmmMeasurement"), _T("IsOverRange"), IN_PARAM(MeasurementValue), OUT_PARAM(val), NULL);

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

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmMeasurement_IsOverRange(MeasurementValue, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmMeasurement_SendSoftwareTrigger(Agilent34980A* pT)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmMeasurement"), _T("SendSoftwareTrigger"));
	NTL_METHOD_START(IIviDmmMeasurement, SendSoftwareTrigger);
	CMethodTrace mt(pT, _T("IIviDmmMeasurement"), _T("SendSoftwareTrigger"), NULL);

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

	strCmd.Format(_T("*TRG"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmMeasurement_SendSoftwareTrigger();
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmMeasurement_ReadMultiPoint(Agilent34980A* pT, long MaxTimeMilliseconds, SAFEARRAY** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmMeasurement"), _T("ReadMultiPoint"));
	NTL_METHOD_START(IIviDmmMeasurement, ReadMultiPoint);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("ReadMultiPoint"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviDmmMeasurement"), _T("ReadMultiPoint"), IN_PARAM(MaxTimeMilliseconds), OUT_PARAM(val), NULL);

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

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmMeasurement_ReadMultiPoint(MaxTimeMilliseconds, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmMeasurement_Read(Agilent34980A* pT, long MaxTimeMilliseconds, double* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmMeasurement"), _T("Read"));
	NTL_METHOD_START(IIviDmmMeasurement, Read);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("Read"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IIviDmmMeasurement"), _T("Read"), IN_PARAM(MaxTimeMilliseconds), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("READ?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmMeasurement_Read(MaxTimeMilliseconds, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmMeasurement_FetchMultiPoint(Agilent34980A* pT, long MaxTimeMilliseconds, SAFEARRAY** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmMeasurement"), _T("FetchMultiPoint"));
	NTL_METHOD_START(IIviDmmMeasurement, FetchMultiPoint);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("FetchMultiPoint"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviDmmMeasurement"), _T("FetchMultiPoint"), IN_PARAM(MaxTimeMilliseconds), OUT_PARAM(val), NULL);

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

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmMeasurement_FetchMultiPoint(MaxTimeMilliseconds, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmMeasurement_Fetch(Agilent34980A* pT, long MaxTimeMilliseconds, double* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmMeasurement"), _T("Fetch"));
	NTL_METHOD_START(IIviDmmMeasurement, Fetch);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("Fetch"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IIviDmmMeasurement"), _T("Fetch"), IN_PARAM(MaxTimeMilliseconds), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("FETC?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmMeasurement_Fetch(MaxTimeMilliseconds, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmMeasurement_Abort(Agilent34980A* pT)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmMeasurement"), _T("Abort"));
	NTL_METHOD_START(IIviDmmMeasurement, Abort);
	CMethodTrace mt(pT, _T("IIviDmmMeasurement"), _T("Abort"), NULL);

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

	strCmd.Format(_T("ABOR"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmMeasurement_Abort();
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmMeasurement_Initiate(Agilent34980A* pT)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmMeasurement"), _T("Initiate"));
	NTL_METHOD_START(IIviDmmMeasurement, Initiate);
	CMethodTrace mt(pT, _T("IIviDmmMeasurement"), _T("Initiate"), NULL);

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

	strCmd.Format(_T("INIT"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmMeasurement_Initiate();
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmRTD_Configure(Agilent34980A* pT, double Alpha, double Resistance)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmRTD"), _T("Configure"));
	NTL_METHOD_START(IIviDmmRTD, Configure);
	CMethodTrace mt(pT, _T("IIviDmmRTD"), _T("Configure"), IN_PARAM(Alpha), IN_PARAM(Resistance), NULL);

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

	strCmd.Format(_T(":CONF:TEMP RTD, %.15g, 1, %.15g"), Alpha, Resistance);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmRTD_Configure(Alpha, Resistance);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmRTD_get_Alpha(Agilent34980A* pT, double* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmRTD"), _T("get_Alpha"));
	NTL_METHOD_START(IIviDmmRTD, get_Alpha);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Alpha"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IIviDmmRTD"), _T("get_Alpha"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("TEMP:TRAN:RTD:TYPE?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmRTD_get_Alpha(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmRTD_put_Alpha(Agilent34980A* pT, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmRTD"), _T("put_Alpha"));
	NTL_METHOD_START(IIviDmmRTD, put_Alpha);
	CMethodTrace mt(pT, _T("IIviDmmRTD"), _T("put_Alpha"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("TEMP:TRAN:RTD:TYPE %.15g"), val);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmRTD_put_Alpha(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmRTD_get_Resistance(Agilent34980A* pT, double* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmRTD"), _T("get_Resistance"));
	NTL_METHOD_START(IIviDmmRTD, get_Resistance);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Resistance"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IIviDmmRTD"), _T("get_Resistance"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("TEMP:TRAN:RTD:RES?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmRTD_get_Resistance(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmRTD_put_Resistance(Agilent34980A* pT, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmRTD"), _T("put_Resistance"));
	NTL_METHOD_START(IIviDmmRTD, put_Resistance);
	CMethodTrace mt(pT, _T("IIviDmmRTD"), _T("put_Resistance"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("TEMP:TRAN:RTD:RES %.15g"), val);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmRTD_put_Resistance(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmThermocouple_Configure(Agilent34980A* pT, IviDmmThermocoupleTypeEnum Type, IviDmmRefJunctionTypeEnum RefJunctionType)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmThermocouple"), _T("Configure"));
	NTL_METHOD_START(IIviDmmThermocouple, Configure);
	CMethodTrace mt(pT, _T("IIviDmmThermocouple"), _T("Configure"), IN_PARAM(Type), IN_PARAM(RefJunctionType), NULL);

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

	strCmd.Format(_T(":CONF:TEMP TC, %s; :TEMP:TRAN:TC:RJUN:TYPE %s"), pT->EnumToString<IviDmmThermocoupleTypeEnum>(Type), pT->EnumToString<IviDmmRefJunctionTypeEnum>(RefJunctionType));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmThermocouple_Configure(Type, RefJunctionType);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmThermocouple_get_FixedRefJunction(Agilent34980A* pT, double* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmThermocouple"), _T("get_FixedRefJunction"));
	NTL_METHOD_START(IIviDmmThermocouple, get_FixedRefJunction);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_FixedRefJunction"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IIviDmmThermocouple"), _T("get_FixedRefJunction"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":TEMP:TRAN:TC:RJUN?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmThermocouple_get_FixedRefJunction(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmThermocouple_put_FixedRefJunction(Agilent34980A* pT, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmThermocouple"), _T("put_FixedRefJunction"));
	NTL_METHOD_START(IIviDmmThermocouple, put_FixedRefJunction);
	CMethodTrace mt(pT, _T("IIviDmmThermocouple"), _T("put_FixedRefJunction"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":TEMP:TRAN:TC:RJUN %.15g"), val);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmThermocouple_put_FixedRefJunction(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmThermocouple_get_RefJunctionType(Agilent34980A* pT, IviDmmRefJunctionTypeEnum* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmThermocouple"), _T("get_RefJunctionType"));
	NTL_METHOD_START(IIviDmmThermocouple, get_RefJunctionType);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_RefJunctionType"), _T("val"));
		*val = IviDmmRefJunctionTypeInternal;
	CMethodTrace mt(pT, _T("IIviDmmThermocouple"), _T("get_RefJunctionType"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("TEMP:TRAN:TC:RJUN:TYPE?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmThermocouple_get_RefJunctionType(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmThermocouple_put_RefJunctionType(Agilent34980A* pT, IviDmmRefJunctionTypeEnum val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmThermocouple"), _T("put_RefJunctionType"));
	NTL_METHOD_START(IIviDmmThermocouple, put_RefJunctionType);
	CMethodTrace mt(pT, _T("IIviDmmThermocouple"), _T("put_RefJunctionType"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("TEMP:TRAN:TC:RJUN:TYPE  %s"), pT->EnumToString<IviDmmRefJunctionTypeEnum>(val));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmThermocouple_put_RefJunctionType(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmThermocouple_get_Type(Agilent34980A* pT, IviDmmThermocoupleTypeEnum* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmThermocouple"), _T("get_Type"));
	NTL_METHOD_START(IIviDmmThermocouple, get_Type);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Type"), _T("val"));
		*val = IviDmmThermocoupleTypeB;
	CMethodTrace mt(pT, _T("IIviDmmThermocouple"), _T("get_Type"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("TEMP:TRAN:TC:TYPE?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmThermocouple_get_Type(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmThermocouple_put_Type(Agilent34980A* pT, IviDmmThermocoupleTypeEnum val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmThermocouple"), _T("put_Type"));
	NTL_METHOD_START(IIviDmmThermocouple, put_Type);
	CMethodTrace mt(pT, _T("IIviDmmThermocouple"), _T("put_Type"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("TEMP:TRAN:TC:TYPE %s"), pT->EnumToString<IviDmmThermocoupleTypeEnum>(val));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmThermocouple_put_Type(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmThermistor_get_Resistance(Agilent34980A* pT, double* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmThermistor"), _T("get_Resistance"));
	NTL_METHOD_START(IIviDmmThermistor, get_Resistance);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Resistance"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IIviDmmThermistor"), _T("get_Resistance"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("TEMP:TRAN:THER:TYPE?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmThermistor_get_Resistance(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmThermistor_put_Resistance(Agilent34980A* pT, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmThermistor"), _T("put_Resistance"));
	NTL_METHOD_START(IIviDmmThermistor, put_Resistance);
	CMethodTrace mt(pT, _T("IIviDmmThermistor"), _T("put_Resistance"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("TEMP:TRAN:THER:TYPE %.15g"), val);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmThermistor_put_Resistance(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmTemperature_get_TransducerType(Agilent34980A* pT, IviDmmTransducerTypeEnum* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmTemperature"), _T("get_TransducerType"));
	NTL_METHOD_START(IIviDmmTemperature, get_TransducerType);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_TransducerType"), _T("val"));
		*val = IviDmmTransducerTypeThermocouple;
	CMethodTrace mt(pT, _T("IIviDmmTemperature"), _T("get_TransducerType"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("TEMP:TRAN:TYPE? "));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmTemperature_get_TransducerType(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmTemperature_put_TransducerType(Agilent34980A* pT, IviDmmTransducerTypeEnum val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmTemperature"), _T("put_TransducerType"));
	NTL_METHOD_START(IIviDmmTemperature, put_TransducerType);
	CMethodTrace mt(pT, _T("IIviDmmTemperature"), _T("put_TransducerType"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("TEMP:TRAN:TYPE %s"), pT->EnumToString<IviDmmTransducerTypeEnum>(val));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmTemperature_put_TransducerType(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmTemperature_get_RTD(Agilent34980A* pT, IIviDmmRTD** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmTemperature"), _T("get_RTD"));
	NTL_METHOD_START(IIviDmmTemperature, get_RTD);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_RTD"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviDmmTemperature"), _T("get_RTD"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDmmTemperature_get_Thermocouple(Agilent34980A* pT, IIviDmmThermocouple** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmTemperature"), _T("get_Thermocouple"));
	NTL_METHOD_START(IIviDmmTemperature, get_Thermocouple);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Thermocouple"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviDmmTemperature"), _T("get_Thermocouple"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDmmTemperature_get_Thermistor(Agilent34980A* pT, IIviDmmThermistor** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmTemperature"), _T("get_Thermistor"));
	NTL_METHOD_START(IIviDmmTemperature, get_Thermistor);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Thermistor"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviDmmTemperature"), _T("get_Thermistor"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDmmMultiPoint_Configure(Agilent34980A* pT, long TriggerCount, long SampleCount, IviDmmSampleTriggerEnum SampleTrigger, double SampleInterval)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmMultiPoint"), _T("Configure"));
	NTL_METHOD_START(IIviDmmMultiPoint, Configure);
	CMethodTrace mt(pT, _T("IIviDmmMultiPoint"), _T("Configure"), IN_PARAM(TriggerCount), IN_PARAM(SampleCount), IN_PARAM(SampleTrigger), IN_PARAM(SampleInterval), NULL);

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

	strCmd.Format(_T(":TRIG:COUN %d; :SAMP:COUN %d;"), TriggerCount, SampleCount);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmMultiPoint_Configure(TriggerCount, SampleCount, SampleTrigger, SampleInterval);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmMultiPoint_get_MeasurementComplete(Agilent34980A* pT, IviDmmMeasCompleteDestEnum* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmMultiPoint"), _T("get_MeasurementComplete"));
	NTL_METHOD_START(IIviDmmMultiPoint, get_MeasurementComplete);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_MeasurementComplete"), _T("val"));
		*val = IviDmmMeasCompleteDestExternal;
	CMethodTrace mt(pT, _T("IIviDmmMultiPoint"), _T("get_MeasurementComplete"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDmmMultiPoint_put_MeasurementComplete(Agilent34980A* pT, IviDmmMeasCompleteDestEnum val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmMultiPoint"), _T("put_MeasurementComplete"));
	NTL_METHOD_START(IIviDmmMultiPoint, put_MeasurementComplete);
	CMethodTrace mt(pT, _T("IIviDmmMultiPoint"), _T("put_MeasurementComplete"), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDmmMultiPoint_get_Count(Agilent34980A* pT, long* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmMultiPoint"), _T("get_Count"));
	NTL_METHOD_START(IIviDmmMultiPoint, get_Count);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Count"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IIviDmmMultiPoint"), _T("get_Count"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("TRIG:COUN?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmMultiPoint_get_Count(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmMultiPoint_put_Count(Agilent34980A* pT, long val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmMultiPoint"), _T("put_Count"));
	NTL_METHOD_START(IIviDmmMultiPoint, put_Count);
	CMethodTrace mt(pT, _T("IIviDmmMultiPoint"), _T("put_Count"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("TRIG:COUN %d"), val);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmMultiPoint_put_Count(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmMultiPoint_get_SampleCount(Agilent34980A* pT, long* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmMultiPoint"), _T("get_SampleCount"));
	NTL_METHOD_START(IIviDmmMultiPoint, get_SampleCount);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_SampleCount"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IIviDmmMultiPoint"), _T("get_SampleCount"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("SAMP:COUN?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmMultiPoint_get_SampleCount(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmMultiPoint_put_SampleCount(Agilent34980A* pT, long val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmMultiPoint"), _T("put_SampleCount"));
	NTL_METHOD_START(IIviDmmMultiPoint, put_SampleCount);
	CMethodTrace mt(pT, _T("IIviDmmMultiPoint"), _T("put_SampleCount"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("SAMP:COUN %d"), val);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmMultiPoint_put_SampleCount(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmMultiPoint_get_SampleInterval(Agilent34980A* pT, double* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmMultiPoint"), _T("get_SampleInterval"));
	NTL_METHOD_START(IIviDmmMultiPoint, get_SampleInterval);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_SampleInterval"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IIviDmmMultiPoint"), _T("get_SampleInterval"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDmmMultiPoint_put_SampleInterval(Agilent34980A* pT, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmMultiPoint"), _T("put_SampleInterval"));
	NTL_METHOD_START(IIviDmmMultiPoint, put_SampleInterval);
	CMethodTrace mt(pT, _T("IIviDmmMultiPoint"), _T("put_SampleInterval"), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDmmMultiPoint_get_SampleTrigger(Agilent34980A* pT, IviDmmSampleTriggerEnum* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmMultiPoint"), _T("get_SampleTrigger"));
	NTL_METHOD_START(IIviDmmMultiPoint, get_SampleTrigger);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_SampleTrigger"), _T("val"));
		*val = IviDmmSampleTriggerImmediate;
	CMethodTrace mt(pT, _T("IIviDmmMultiPoint"), _T("get_SampleTrigger"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDmmMultiPoint_put_SampleTrigger(Agilent34980A* pT, IviDmmSampleTriggerEnum val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmMultiPoint"), _T("put_SampleTrigger"));
	NTL_METHOD_START(IIviDmmMultiPoint, put_SampleTrigger);
	CMethodTrace mt(pT, _T("IIviDmmMultiPoint"), _T("put_SampleTrigger"), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDmmTrigger_Configure(Agilent34980A* pT, IviDmmTriggerSourceEnum TriggerSource, double TriggerDelay)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmTrigger"), _T("Configure"));
	NTL_METHOD_START(IIviDmmTrigger, Configure);
	CMethodTrace mt(pT, _T("IIviDmmTrigger"), _T("Configure"), IN_PARAM(TriggerSource), IN_PARAM(TriggerDelay), NULL);

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

	strCmd.Format(_T(":TRIG:SOUR %s; :TRIG:DEL %.15g"), pT->EnumToString<IviDmmTriggerSourceEnum>(TriggerSource), TriggerDelay);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmTrigger_Configure(TriggerSource, TriggerDelay);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmTrigger_get_Slope(Agilent34980A* pT, IviDmmTriggerSlopeEnum* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmTrigger"), _T("get_Slope"));
	NTL_METHOD_START(IIviDmmTrigger, get_Slope);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Slope"), _T("val"));
		*val = IviDmmTriggerSlopePositive;
	CMethodTrace mt(pT, _T("IIviDmmTrigger"), _T("get_Slope"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDmmTrigger_put_Slope(Agilent34980A* pT, IviDmmTriggerSlopeEnum val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmTrigger"), _T("put_Slope"));
	NTL_METHOD_START(IIviDmmTrigger, put_Slope);
	CMethodTrace mt(pT, _T("IIviDmmTrigger"), _T("put_Slope"), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDmmTrigger_get_Delay(Agilent34980A* pT, double* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmTrigger"), _T("get_Delay"));
	NTL_METHOD_START(IIviDmmTrigger, get_Delay);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Delay"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IIviDmmTrigger"), _T("get_Delay"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("TRIG:DEL?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmTrigger_get_Delay(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmTrigger_put_Delay(Agilent34980A* pT, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmTrigger"), _T("put_Delay"));
	NTL_METHOD_START(IIviDmmTrigger, put_Delay);
	CMethodTrace mt(pT, _T("IIviDmmTrigger"), _T("put_Delay"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("TRIG:DEL %.15g"), val);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmTrigger_put_Delay(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmTrigger_get_Source(Agilent34980A* pT, IviDmmTriggerSourceEnum* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmTrigger"), _T("get_Source"));
	NTL_METHOD_START(IIviDmmTrigger, get_Source);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Source"), _T("val"));
		*val = IviDmmTriggerSourceImmediate;
	CMethodTrace mt(pT, _T("IIviDmmTrigger"), _T("get_Source"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("TRIG:SOUR?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmTrigger_get_Source(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmTrigger_put_Source(Agilent34980A* pT, IviDmmTriggerSourceEnum val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmTrigger"), _T("put_Source"));
	NTL_METHOD_START(IIviDmmTrigger, put_Source);
	CMethodTrace mt(pT, _T("IIviDmmTrigger"), _T("put_Source"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("TRIG:SOUR %s"), pT->EnumToString<IviDmmTriggerSourceEnum>(val));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmmTrigger_put_Source(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmmTrigger_get_MultiPoint(Agilent34980A* pT, IIviDmmMultiPoint** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmmTrigger"), _T("get_MultiPoint"));
	NTL_METHOD_START(IIviDmmTrigger, get_MultiPoint);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_MultiPoint"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviDmmTrigger"), _T("get_MultiPoint"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDmm_Configure(Agilent34980A* pT, IviDmmFunctionEnum Function, double Range, double Resolution)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmm"), _T("Configure"));
	NTL_METHOD_START(IIviDmm, Configure);
	CMethodTrace mt(pT, _T("IIviDmm"), _T("Configure"), IN_PARAM(Function), IN_PARAM(Range), IN_PARAM(Resolution), NULL);

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

	strCmd.Format(_T("CONF:%s %.15g,%.15g"), pT->EnumToString<IviDmmFunctionEnum>(Function), Range, Resolution);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmm_Configure(Function, Range, Resolution);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmm_get_Function(Agilent34980A* pT, IviDmmFunctionEnum* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmm"), _T("get_Function"));
	NTL_METHOD_START(IIviDmm, get_Function);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Function"), _T("val"));
		*val = IviDmmFunctionDCVolts;
	CMethodTrace mt(pT, _T("IIviDmm"), _T("get_Function"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":FUNC?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmm_get_Function(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmm_put_Function(Agilent34980A* pT, IviDmmFunctionEnum val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmm"), _T("put_Function"));
	NTL_METHOD_START(IIviDmm, put_Function);
	CMethodTrace mt(pT, _T("IIviDmm"), _T("put_Function"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":FUNC %s"), pT->EnumToString<IviDmmFunctionEnum>(val));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDmm_put_Function(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDmm_get_Range(Agilent34980A* pT, double* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmm"), _T("get_Range"));
	NTL_METHOD_START(IIviDmm, get_Range);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Range"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IIviDmm"), _T("get_Range"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDmm_put_Range(Agilent34980A* pT, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmm"), _T("put_Range"));
	NTL_METHOD_START(IIviDmm, put_Range);
	CMethodTrace mt(pT, _T("IIviDmm"), _T("put_Range"), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDmm_get_Resolution(Agilent34980A* pT, double* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmm"), _T("get_Resolution"));
	NTL_METHOD_START(IIviDmm, get_Resolution);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Resolution"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IIviDmm"), _T("get_Resolution"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDmm_put_Resolution(Agilent34980A* pT, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmm"), _T("put_Resolution"));
	NTL_METHOD_START(IIviDmm, put_Resolution);
	CMethodTrace mt(pT, _T("IIviDmm"), _T("put_Resolution"), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDmm_get_AC(Agilent34980A* pT, IIviDmmAC** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmm"), _T("get_AC"));
	NTL_METHOD_START(IIviDmm, get_AC);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_AC"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviDmm"), _T("get_AC"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDmm_get_Advanced(Agilent34980A* pT, IIviDmmAdvanced** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmm"), _T("get_Advanced"));
	NTL_METHOD_START(IIviDmm, get_Advanced);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Advanced"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviDmm"), _T("get_Advanced"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDmm_get_Frequency(Agilent34980A* pT, IIviDmmFrequency** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmm"), _T("get_Frequency"));
	NTL_METHOD_START(IIviDmm, get_Frequency);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Frequency"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviDmm"), _T("get_Frequency"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDmm_get_Measurement(Agilent34980A* pT, IIviDmmMeasurement** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmm"), _T("get_Measurement"));
	NTL_METHOD_START(IIviDmm, get_Measurement);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Measurement"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviDmm"), _T("get_Measurement"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDmm_get_Temperature(Agilent34980A* pT, IIviDmmTemperature** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmm"), _T("get_Temperature"));
	NTL_METHOD_START(IIviDmm, get_Temperature);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Temperature"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviDmm"), _T("get_Temperature"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDmm_get_Trigger(Agilent34980A* pT, IIviDmmTrigger** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDmm"), _T("get_Trigger"));
	NTL_METHOD_START(IIviDmm, get_Trigger);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Trigger"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviDmm"), _T("get_Trigger"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDriver_Close(Agilent34980A* pT)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriver"), _T("Close"));
	NTL_METHOD_START(IIviDriver, Close);
	CMethodTrace mt(pT, _T("IIviDriver"), _T("Close"), NULL);

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

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

	return hr;
}
HRESULT IIviDriver_Initialize(Agilent34980A* pT, BSTR ResourceName, VARIANT_BOOL IdQuery, VARIANT_BOOL Reset, BSTR OptionString)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriver"), _T("Initialize"));
	NTL_METHOD_START_INIT_NOT_REQUIRED(IIviDriver, Initialize);
	CMethodTrace mt(pT, _T("IIviDriver"), _T("Initialize"), IN_PARAM(ResourceName), IN_PARAM(IdQuery), IN_PARAM(Reset), IN_PARAM(OptionString), NULL);

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

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDriver_Initialize(ResourceName, IdQuery, Reset, OptionString);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDriver_get_DriverOperation(Agilent34980A* pT, IIviDriverOperation** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriver"), _T("get_DriverOperation"));
	NTL_METHOD_START_INIT_NOT_REQUIRED(IIviDriver, get_DriverOperation);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_DriverOperation"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviDriver"), _T("get_DriverOperation"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDriver_get_Identity(Agilent34980A* pT, IIviDriverIdentity** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriver"), _T("get_Identity"));
	NTL_METHOD_START_INIT_NOT_REQUIRED(IIviDriver, get_Identity);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Identity"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviDriver"), _T("get_Identity"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDriver_get_Utility(Agilent34980A* pT, IIviDriverUtility** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriver"), _T("get_Utility"));
	NTL_METHOD_START_INIT_NOT_REQUIRED(IIviDriver, get_Utility);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Utility"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviDriver"), _T("get_Utility"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDriver_get_Initialized(Agilent34980A* pT, VARIANT_BOOL* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriver"), _T("get_Initialized"));
	NTL_METHOD_START_INIT_NOT_REQUIRED(IIviDriver, get_Initialized);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Initialized"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IIviDriver"), _T("get_Initialized"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDriverOperation_GetNextCoercionRecord(Agilent34980A* pT, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverOperation"), _T("GetNextCoercionRecord"));
	NTL_METHOD_START(IIviDriverOperation, GetNextCoercionRecord);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("GetNextCoercionRecord"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviDriverOperation"), _T("GetNextCoercionRecord"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDriverOperation_ResetInterchangeCheck(Agilent34980A* pT)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverOperation"), _T("ResetInterchangeCheck"));
	NTL_METHOD_START(IIviDriverOperation, ResetInterchangeCheck);
	CMethodTrace mt(pT, _T("IIviDriverOperation"), _T("ResetInterchangeCheck"), NULL);

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

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

	return hr;
}
HRESULT IIviDriverOperation_GetNextInterchangeWarning(Agilent34980A* pT, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverOperation"), _T("GetNextInterchangeWarning"));
	NTL_METHOD_START(IIviDriverOperation, GetNextInterchangeWarning);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("GetNextInterchangeWarning"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviDriverOperation"), _T("GetNextInterchangeWarning"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDriverOperation_ClearInterchangeWarnings(Agilent34980A* pT)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverOperation"), _T("ClearInterchangeWarnings"));
	NTL_METHOD_START(IIviDriverOperation, ClearInterchangeWarnings);
	CMethodTrace mt(pT, _T("IIviDriverOperation"), _T("ClearInterchangeWarnings"), NULL);

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

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

	return hr;
}
HRESULT IIviDriverOperation_InvalidateAllAttributes(Agilent34980A* pT)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverOperation"), _T("InvalidateAllAttributes"));
	NTL_METHOD_START(IIviDriverOperation, InvalidateAllAttributes);
	CMethodTrace mt(pT, _T("IIviDriverOperation"), _T("InvalidateAllAttributes"), NULL);

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

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

	return hr;
}
HRESULT IIviDriverOperation_get_LogicalName(Agilent34980A* pT, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverOperation"), _T("get_LogicalName"));
	NTL_METHOD_START(IIviDriverOperation, get_LogicalName);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_LogicalName"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviDriverOperation"), _T("get_LogicalName"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDriverOperation_get_IoResourceDescriptor(Agilent34980A* pT, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverOperation"), _T("get_IoResourceDescriptor"));
	NTL_METHOD_START(IIviDriverOperation, get_IoResourceDescriptor);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_IoResourceDescriptor"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviDriverOperation"), _T("get_IoResourceDescriptor"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDriverOperation_get_Cache(Agilent34980A* pT, VARIANT_BOOL* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverOperation"), _T("get_Cache"));
	NTL_METHOD_START(IIviDriverOperation, get_Cache);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Cache"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IIviDriverOperation"), _T("get_Cache"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDriverOperation_put_Cache(Agilent34980A* pT, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverOperation"), _T("put_Cache"));
	NTL_METHOD_START(IIviDriverOperation, put_Cache);
	CMethodTrace mt(pT, _T("IIviDriverOperation"), _T("put_Cache"), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDriverOperation_get_InterchangeCheck(Agilent34980A* pT, VARIANT_BOOL* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverOperation"), _T("get_InterchangeCheck"));
	NTL_METHOD_START(IIviDriverOperation, get_InterchangeCheck);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_InterchangeCheck"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IIviDriverOperation"), _T("get_InterchangeCheck"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDriverOperation_put_InterchangeCheck(Agilent34980A* pT, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverOperation"), _T("put_InterchangeCheck"));
	NTL_METHOD_START(IIviDriverOperation, put_InterchangeCheck);
	CMethodTrace mt(pT, _T("IIviDriverOperation"), _T("put_InterchangeCheck"), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDriverOperation_get_QueryInstrumentStatus(Agilent34980A* pT, VARIANT_BOOL* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverOperation"), _T("get_QueryInstrumentStatus"));
	NTL_METHOD_START(IIviDriverOperation, get_QueryInstrumentStatus);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_QueryInstrumentStatus"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IIviDriverOperation"), _T("get_QueryInstrumentStatus"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDriverOperation_put_QueryInstrumentStatus(Agilent34980A* pT, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverOperation"), _T("put_QueryInstrumentStatus"));
	NTL_METHOD_START(IIviDriverOperation, put_QueryInstrumentStatus);
	CMethodTrace mt(pT, _T("IIviDriverOperation"), _T("put_QueryInstrumentStatus"), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDriverOperation_get_RangeCheck(Agilent34980A* pT, VARIANT_BOOL* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverOperation"), _T("get_RangeCheck"));
	NTL_METHOD_START(IIviDriverOperation, get_RangeCheck);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_RangeCheck"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IIviDriverOperation"), _T("get_RangeCheck"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDriverOperation_put_RangeCheck(Agilent34980A* pT, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverOperation"), _T("put_RangeCheck"));
	NTL_METHOD_START(IIviDriverOperation, put_RangeCheck);
	CMethodTrace mt(pT, _T("IIviDriverOperation"), _T("put_RangeCheck"), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDriverOperation_get_RecordCoercions(Agilent34980A* pT, VARIANT_BOOL* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverOperation"), _T("get_RecordCoercions"));
	NTL_METHOD_START(IIviDriverOperation, get_RecordCoercions);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_RecordCoercions"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IIviDriverOperation"), _T("get_RecordCoercions"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDriverOperation_put_RecordCoercions(Agilent34980A* pT, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverOperation"), _T("put_RecordCoercions"));
	NTL_METHOD_START(IIviDriverOperation, put_RecordCoercions);
	CMethodTrace mt(pT, _T("IIviDriverOperation"), _T("put_RecordCoercions"), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDriverOperation_get_Simulate(Agilent34980A* pT, VARIANT_BOOL* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverOperation"), _T("get_Simulate"));
	NTL_METHOD_START(IIviDriverOperation, get_Simulate);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Simulate"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IIviDriverOperation"), _T("get_Simulate"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDriverOperation_put_Simulate(Agilent34980A* pT, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverOperation"), _T("put_Simulate"));
	NTL_METHOD_START(IIviDriverOperation, put_Simulate);
	CMethodTrace mt(pT, _T("IIviDriverOperation"), _T("put_Simulate"), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDriverOperation_get_DriverSetup(Agilent34980A* pT, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverOperation"), _T("get_DriverSetup"));
	NTL_METHOD_START(IIviDriverOperation, get_DriverSetup);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_DriverSetup"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviDriverOperation"), _T("get_DriverSetup"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDriverIdentity_get_InstrumentManufacturer(Agilent34980A* pT, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverIdentity"), _T("get_InstrumentManufacturer"));
	NTL_METHOD_START(IIviDriverIdentity, get_InstrumentManufacturer);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_InstrumentManufacturer"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviDriverIdentity"), _T("get_InstrumentManufacturer"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDriverIdentity_get_InstrumentModel(Agilent34980A* pT, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverIdentity"), _T("get_InstrumentModel"));
	NTL_METHOD_START(IIviDriverIdentity, get_InstrumentModel);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_InstrumentModel"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviDriverIdentity"), _T("get_InstrumentModel"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDriverIdentity_get_InstrumentFirmwareRevision(Agilent34980A* pT, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverIdentity"), _T("get_InstrumentFirmwareRevision"));
	NTL_METHOD_START(IIviDriverIdentity, get_InstrumentFirmwareRevision);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_InstrumentFirmwareRevision"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviDriverIdentity"), _T("get_InstrumentFirmwareRevision"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDriverIdentity_get_Identifier(Agilent34980A* pT, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverIdentity"), _T("get_Identifier"));
	NTL_METHOD_START_INIT_NOT_REQUIRED(IIviDriverIdentity, get_Identifier);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Identifier"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviDriverIdentity"), _T("get_Identifier"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDriverIdentity_get_SupportedInstrumentModels(Agilent34980A* pT, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverIdentity"), _T("get_SupportedInstrumentModels"));
	NTL_METHOD_START_INIT_NOT_REQUIRED(IIviDriverIdentity, get_SupportedInstrumentModels);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_SupportedInstrumentModels"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviDriverIdentity"), _T("get_SupportedInstrumentModels"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDriverIdentity_get_SpecificationMajorVersion(Agilent34980A* pT, long* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverIdentity"), _T("get_SpecificationMajorVersion"));
	NTL_METHOD_START_INIT_NOT_REQUIRED(IIviDriverIdentity, get_SpecificationMajorVersion);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_SpecificationMajorVersion"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IIviDriverIdentity"), _T("get_SpecificationMajorVersion"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDriverIdentity_get_SpecificationMinorVersion(Agilent34980A* pT, long* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverIdentity"), _T("get_SpecificationMinorVersion"));
	NTL_METHOD_START_INIT_NOT_REQUIRED(IIviDriverIdentity, get_SpecificationMinorVersion);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_SpecificationMinorVersion"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IIviDriverIdentity"), _T("get_SpecificationMinorVersion"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDriverIdentity_get_GroupCapabilities(Agilent34980A* pT, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverIdentity"), _T("get_GroupCapabilities"));
	NTL_METHOD_START(IIviDriverIdentity, get_GroupCapabilities);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_GroupCapabilities"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviDriverIdentity"), _T("get_GroupCapabilities"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviComponentIdentity_get_Description(Agilent34980A* pT, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviComponentIdentity"), _T("get_Description"));
	NTL_METHOD_START_INIT_NOT_REQUIRED(IIviComponentIdentity, get_Description);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Description"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviComponentIdentity"), _T("get_Description"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviComponentIdentity_get_Revision(Agilent34980A* pT, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviComponentIdentity"), _T("get_Revision"));
	NTL_METHOD_START_INIT_NOT_REQUIRED(IIviComponentIdentity, get_Revision);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Revision"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviComponentIdentity"), _T("get_Revision"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviComponentIdentity_get_Vendor(Agilent34980A* pT, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviComponentIdentity"), _T("get_Vendor"));
	NTL_METHOD_START_INIT_NOT_REQUIRED(IIviComponentIdentity, get_Vendor);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Vendor"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviComponentIdentity"), _T("get_Vendor"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviDriverUtility_UnlockObject(Agilent34980A* pT)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverUtility"), _T("UnlockObject"));
	NTL_METHOD_START(IIviDriverUtility, UnlockObject);
	CMethodTrace mt(pT, _T("IIviDriverUtility"), _T("UnlockObject"), NULL);

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

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

	return hr;
}
HRESULT IIviDriverUtility_LockObject(Agilent34980A* pT)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverUtility"), _T("LockObject"));
	NTL_METHOD_START(IIviDriverUtility, LockObject);
	CMethodTrace mt(pT, _T("IIviDriverUtility"), _T("LockObject"), NULL);

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

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

	return hr;
}
HRESULT IIviDriverUtility_ErrorQuery(Agilent34980A* pT, long* ErrorCode, BSTR* ErrorMessage)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverUtility"), _T("ErrorQuery"));
	NTL_METHOD_START(IIviDriverUtility, ErrorQuery);
	if (ErrorCode == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("ErrorQuery"), _T("ErrorCode"));
	if (ErrorMessage == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("ErrorQuery"), _T("ErrorMessage"));
	CMethodTrace mt(pT, _T("IIviDriverUtility"), _T("ErrorQuery"), INOUT_PARAM(ErrorCode), INOUT_PARAM(ErrorMessage), NULL);

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

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDriverUtility_ErrorQuery(ErrorCode, ErrorMessage);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDriverUtility_SelfTest(Agilent34980A* pT, long* TestResult, BSTR* TestMessage)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverUtility"), _T("SelfTest"));
	NTL_METHOD_START(IIviDriverUtility, SelfTest);
	if (TestResult == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("SelfTest"), _T("TestResult"));
	if (TestMessage == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("SelfTest"), _T("TestMessage"));
	CMethodTrace mt(pT, _T("IIviDriverUtility"), _T("SelfTest"), INOUT_PARAM(TestResult), INOUT_PARAM(TestMessage), NULL);

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

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviDriverUtility_SelfTest(TestResult, TestMessage);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviDriverUtility_Disable(Agilent34980A* pT)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverUtility"), _T("Disable"));
	NTL_METHOD_START(IIviDriverUtility, Disable);
	CMethodTrace mt(pT, _T("IIviDriverUtility"), _T("Disable"), NULL);

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

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

	return hr;
}
HRESULT IIviDriverUtility_ResetWithDefaults(Agilent34980A* pT)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverUtility"), _T("ResetWithDefaults"));
	NTL_METHOD_START(IIviDriverUtility, ResetWithDefaults);
	CMethodTrace mt(pT, _T("IIviDriverUtility"), _T("ResetWithDefaults"), NULL);

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

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

	return hr;
}
HRESULT IIviDriverUtility_Reset(Agilent34980A* pT)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviDriverUtility"), _T("Reset"));
	NTL_METHOD_START(IIviDriverUtility, Reset);
	CMethodTrace mt(pT, _T("IIviDriverUtility"), _T("Reset"), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980AAlarm_Clear(Agilent34980A* pT, VARIANT_BOOL ClearAll, long Index)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AAlarm"), _T("Clear"));
	NTL_METHOD_START(IAgilent34980AAlarm, Clear);
	CMethodTrace mt(pT, _T("IAgilent34980AAlarm"), _T("Clear"), IN_PARAM(ClearAll), IN_PARAM(Index), NULL);

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

	strCmd.Format(_T(":OUTP:ALAR%d:CLE"), Index);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AAlarm_Clear(ClearAll, Index);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AAlarm_AlarmScanSetup(Agilent34980A* pT, BSTR ChannelList, long Channel, long AlarmIndex, long NumSweeps, double UpperLimit)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AAlarm"), _T("AlarmScanSetup"));
	NTL_METHOD_START(IAgilent34980AAlarm, AlarmScanSetup);
	CMethodTrace mt(pT, _T("IAgilent34980AAlarm"), _T("AlarmScanSetup"), IN_PARAM(ChannelList), IN_PARAM(Channel), IN_PARAM(AlarmIndex), IN_PARAM(NumSweeps), IN_PARAM(UpperLimit), NULL);

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

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AAlarm_AlarmScanSetup(ChannelList, Channel, AlarmIndex, NumSweeps, UpperLimit);
	pT->PopInstrCommand();

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

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

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

	return hr;
}
HRESULT IAgilent34980AAlarm_put_LowerLimit(Agilent34980A* pT, BSTR ChannelList, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AAlarm"), _T("put_LowerLimit"));
	NTL_METHOD_START(IAgilent34980AAlarm, put_LowerLimit);
	CMethodTrace mt(pT, _T("IAgilent34980AAlarm"), _T("put_LowerLimit"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

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

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

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

	return hr;
}
HRESULT IAgilent34980AAlarm_put_LowerLimitEnable(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AAlarm"), _T("put_LowerLimitEnable"));
	NTL_METHOD_START(IAgilent34980AAlarm, put_LowerLimitEnable);
	CMethodTrace mt(pT, _T("IAgilent34980AAlarm"), _T("put_LowerLimitEnable"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980AAlarm_get_Mode(Agilent34980A* pT, Agilent34980AAlarmModeEnum* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AAlarm"), _T("get_Mode"));
	NTL_METHOD_START(IAgilent34980AAlarm, get_Mode);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Mode"), _T("val"));
		*val = Agilent34980AAlarmModeLatch;
	CMethodTrace mt(pT, _T("IAgilent34980AAlarm"), _T("get_Mode"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":OUTP:ALAR:MODE?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AAlarm_get_Mode(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AAlarm_put_Mode(Agilent34980A* pT, Agilent34980AAlarmModeEnum val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AAlarm"), _T("put_Mode"));
	NTL_METHOD_START(IAgilent34980AAlarm, put_Mode);
	CMethodTrace mt(pT, _T("IAgilent34980AAlarm"), _T("put_Mode"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":OUTP:ALAR:MODE %s"), pT->EnumToString<Agilent34980AAlarmModeEnum>(val));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AAlarm_put_Mode(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AAlarm_get_QueryAlarmQueue(Agilent34980A* pT, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AAlarm"), _T("get_QueryAlarmQueue"));
	NTL_METHOD_START(IAgilent34980AAlarm, get_QueryAlarmQueue);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_QueryAlarmQueue"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980AAlarm"), _T("get_QueryAlarmQueue"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("SYST:ALAR? "));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AAlarm_get_QueryAlarmQueue(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AAlarm_get_Slope(Agilent34980A* pT, Agilent34980ASlopeEnum* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AAlarm"), _T("get_Slope"));
	NTL_METHOD_START(IAgilent34980AAlarm, get_Slope);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Slope"), _T("val"));
		*val = Agilent34980ASlopeNegative;
	CMethodTrace mt(pT, _T("IAgilent34980AAlarm"), _T("get_Slope"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":OUTP:ALAR:SLOP?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AAlarm_get_Slope(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AAlarm_put_Slope(Agilent34980A* pT, Agilent34980ASlopeEnum val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AAlarm"), _T("put_Slope"));
	NTL_METHOD_START(IAgilent34980AAlarm, put_Slope);
	CMethodTrace mt(pT, _T("IAgilent34980AAlarm"), _T("put_Slope"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":OUTP:ALAR:SLOP %s"), pT->EnumToString<Agilent34980ASlopeEnum>(val));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AAlarm_put_Slope(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AAlarm_get_Source(Agilent34980A* pT, long Index, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AAlarm"), _T("get_Source"));
	NTL_METHOD_START(IAgilent34980AAlarm, get_Source);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Source"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980AAlarm"), _T("get_Source"), IN_PARAM(Index), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":OUTP:ALAR%d:SOUR?"), Index);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AAlarm_get_Source(Index, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AAlarm_put_Source(Agilent34980A* pT, long Index, BSTR val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AAlarm"), _T("put_Source"));
	NTL_METHOD_START(IAgilent34980AAlarm, put_Source);
	CMethodTrace mt(pT, _T("IAgilent34980AAlarm"), _T("put_Source"), IN_PARAM(Index), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":OUTP:ALAR%d:SOUR (@%s)"), Index, LPCTSTR(COLE2T(val)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AAlarm_put_Source(Index, val);
	pT->PopInstrCommand();

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

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

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

	return hr;
}
HRESULT IAgilent34980AAlarm_put_UpperLimit(Agilent34980A* pT, BSTR ChannelList, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AAlarm"), _T("put_UpperLimit"));
	NTL_METHOD_START(IAgilent34980AAlarm, put_UpperLimit);
	CMethodTrace mt(pT, _T("IAgilent34980AAlarm"), _T("put_UpperLimit"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

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

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

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

	return hr;
}
HRESULT IAgilent34980AAlarm_put_UpperLimitEnable(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AAlarm"), _T("put_UpperLimitEnable"));
	NTL_METHOD_START(IAgilent34980AAlarm, put_UpperLimitEnable);
	CMethodTrace mt(pT, _T("IAgilent34980AAlarm"), _T("put_UpperLimitEnable"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980AACVoltage_Configure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AACVoltage"), _T("Configure"));
	NTL_METHOD_START(IAgilent34980AACVoltage, Configure);
	CMethodTrace mt(pT, _T("IAgilent34980AACVoltage"), _T("Configure"), IN_PARAM(ChannelList), IN_PARAM(Range), IN_PARAM(Resolution), NULL);

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

	strCmd.Format(_T(":CONF:AC %.15g, %s, (@%s)"), Range, pT->EnumToString<Agilent34980AResolutionEnum>(Resolution), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AACVoltage_Configure(ChannelList, Range, Resolution);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AACVoltage_Measure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AACVoltage"), _T("Measure"));
	NTL_METHOD_START(IAgilent34980AACVoltage, Measure);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("Measure"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980AACVoltage"), _T("Measure"), IN_PARAM(ChannelList), IN_PARAM(Range), IN_PARAM(Resolution), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":MEAS:AC? %.15g, %s, (@%s)"), Range, pT->EnumToString<Agilent34980AResolutionEnum>(Resolution), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AACVoltage_Measure(ChannelList, Range, Resolution, val);
	pT->PopInstrCommand();

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

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

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

	return hr;
}
HRESULT IAgilent34980AACVoltage_put_AutoRange(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AACVoltage"), _T("put_AutoRange"));
	NTL_METHOD_START(IAgilent34980AACVoltage, put_AutoRange);
	CMethodTrace mt(pT, _T("IAgilent34980AACVoltage"), _T("put_AutoRange"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":VOLT:AC:RANG:AUTO %s, (@%s)"), val == VARIANT_FALSE ? "0" : "1", LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AACVoltage_put_AutoRange(ChannelList, val);
	pT->PopInstrCommand();

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

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

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

	return hr;
}
HRESULT IAgilent34980AACVoltage_put_Bandwidth(Agilent34980A* pT, BSTR ChannelList, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AACVoltage"), _T("put_Bandwidth"));
	NTL_METHOD_START(IAgilent34980AACVoltage, put_Bandwidth);
	CMethodTrace mt(pT, _T("IAgilent34980AACVoltage"), _T("put_Bandwidth"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

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

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

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

	return hr;
}
HRESULT IAgilent34980AACVoltage_put_Range(Agilent34980A* pT, BSTR ChannelList, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AACVoltage"), _T("put_Range"));
	NTL_METHOD_START(IAgilent34980AACVoltage, put_Range);
	CMethodTrace mt(pT, _T("IAgilent34980AACVoltage"), _T("put_Range"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980AACCurrent_Configure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AACCurrent"), _T("Configure"));
	NTL_METHOD_START(IAgilent34980AACCurrent, Configure);
	CMethodTrace mt(pT, _T("IAgilent34980AACCurrent"), _T("Configure"), IN_PARAM(ChannelList), IN_PARAM(Range), IN_PARAM(Resolution), NULL);

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

	strCmd.Format(_T(":CONF:CURR:AC %.15g, %s, (@%s)"), Range, pT->EnumToString<Agilent34980AResolutionEnum>(Resolution), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AACCurrent_Configure(ChannelList, Range, Resolution);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AACCurrent_Measure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AACCurrent"), _T("Measure"));
	NTL_METHOD_START(IAgilent34980AACCurrent, Measure);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("Measure"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980AACCurrent"), _T("Measure"), IN_PARAM(ChannelList), IN_PARAM(Range), IN_PARAM(Resolution), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":MEAS:CURR:AC? %.15g, %s, (@%s)"), Range, pT->EnumToString<Agilent34980AResolutionEnum>(Resolution), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AACCurrent_Measure(ChannelList, Range, Resolution, val);
	pT->PopInstrCommand();

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

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

	strCmd.Format(_T(":CURR:AC:RANG:AUTO? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AACCurrent_get_AutoRange(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AACCurrent_put_AutoRange(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AACCurrent"), _T("put_AutoRange"));
	NTL_METHOD_START(IAgilent34980AACCurrent, put_AutoRange);
	CMethodTrace mt(pT, _T("IAgilent34980AACCurrent"), _T("put_AutoRange"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":CURR:AC:RANG:AUTO %s, (@%s)"), val == VARIANT_FALSE ? "0" : "1", LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AACCurrent_put_AutoRange(ChannelList, val);
	pT->PopInstrCommand();

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

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

	strCmd.Format(_T(":CURR:AC:BAND? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AACCurrent_get_Bandwidth(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AACCurrent_put_Bandwidth(Agilent34980A* pT, BSTR ChannelList, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AACCurrent"), _T("put_Bandwidth"));
	NTL_METHOD_START(IAgilent34980AACCurrent, put_Bandwidth);
	CMethodTrace mt(pT, _T("IAgilent34980AACCurrent"), _T("put_Bandwidth"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

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

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

	strCmd.Format(_T(":CURR:AC:RANG? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AACCurrent_get_Range(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AACCurrent_put_Range(Agilent34980A* pT, BSTR ChannelList, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AACCurrent"), _T("put_Range"));
	NTL_METHOD_START(IAgilent34980AACCurrent, put_Range);
	CMethodTrace mt(pT, _T("IAgilent34980AACCurrent"), _T("put_Range"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980ACalibration_SecurityEnable(Agilent34980A* pT, VARIANT_BOOL Enable, BSTR Code)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ACalibration"), _T("SecurityEnable"));
	NTL_METHOD_START(IAgilent34980ACalibration, SecurityEnable);
	CMethodTrace mt(pT, _T("IAgilent34980ACalibration"), _T("SecurityEnable"), IN_PARAM(Enable), IN_PARAM(Code), NULL);

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

	strCmd.Format(_T(":CAL:SEC:STAT %s, %s"), Enable == VARIANT_FALSE ? "0" : "1", LPCTSTR(COLE2T(Code)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ACalibration_SecurityEnable(Enable, Code);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ACalibration_put_Code(Agilent34980A* pT, BSTR val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ACalibration"), _T("put_Code"));
	NTL_METHOD_START(IAgilent34980ACalibration, put_Code);
	CMethodTrace mt(pT, _T("IAgilent34980ACalibration"), _T("put_Code"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":CAL:SEC:CODE %s"), LPCTSTR(COLE2T(val)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ACalibration_put_Code(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ACalibration_get_String(Agilent34980A* pT, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ACalibration"), _T("get_String"));
	NTL_METHOD_START(IAgilent34980ACalibration, get_String);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_String"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980ACalibration"), _T("get_String"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("CAL:STR? MAIN"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ACalibration_get_String(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ACalibration_put_String(Agilent34980A* pT, BSTR val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ACalibration"), _T("put_String"));
	NTL_METHOD_START(IAgilent34980ACalibration, put_String);
	CMethodTrace mt(pT, _T("IAgilent34980ACalibration"), _T("put_String"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("CAL:STR \"%s\", MAIN"), LPCTSTR(COLE2T(val)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ACalibration_put_String(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ACalibration_get_Count(Agilent34980A* pT, long* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ACalibration"), _T("get_Count"));
	NTL_METHOD_START(IAgilent34980ACalibration, get_Count);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Count"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34980ACalibration"), _T("get_Count"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":CAL:COUN? MAIN"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ACalibration_get_Count(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ACalibration_get_LineFrequency(Agilent34980A* pT, double* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ACalibration"), _T("get_LineFrequency"));
	NTL_METHOD_START(IAgilent34980ACalibration, get_LineFrequency);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_LineFrequency"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IAgilent34980ACalibration"), _T("get_LineFrequency"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":CAL:LFR?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ACalibration_get_LineFrequency(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ACalibration_put_LineFrequency(Agilent34980A* pT, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ACalibration"), _T("put_LineFrequency"));
	NTL_METHOD_START(IAgilent34980ACalibration, put_LineFrequency);
	CMethodTrace mt(pT, _T("IAgilent34980ACalibration"), _T("put_LineFrequency"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":CAL:LFR %.15g"), val);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ACalibration_put_LineFrequency(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ACalibration_get_SecurityState(Agilent34980A* pT, VARIANT_BOOL* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ACalibration"), _T("get_SecurityState"));
	NTL_METHOD_START(IAgilent34980ACalibration, get_SecurityState);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_SecurityState"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IAgilent34980ACalibration"), _T("get_SecurityState"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":CAL:SEC:STAT?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ACalibration_get_SecurityState(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ACalibration_get_DAC(Agilent34980A* pT, IAgilent34980ADAC** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ACalibration"), _T("get_DAC"));
	NTL_METHOD_START(IAgilent34980ACalibration, get_DAC);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_DAC"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980ACalibration"), _T("get_DAC"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980ACalibration_get_DMM(Agilent34980A* pT, IAgilent34980ADMM** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ACalibration"), _T("get_DMM"));
	NTL_METHOD_START(IAgilent34980ACalibration, get_DMM);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_DMM"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980ACalibration"), _T("get_DMM"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980ACurrent_get_ACCurrent(Agilent34980A* pT, IAgilent34980AACCurrent** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ACurrent"), _T("get_ACCurrent"));
	NTL_METHOD_START(IAgilent34980ACurrent, get_ACCurrent);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ACCurrent"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980ACurrent"), _T("get_ACCurrent"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980ACurrent_get_DCCurrent(Agilent34980A* pT, IAgilent34980ADCCurrent** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ACurrent"), _T("get_DCCurrent"));
	NTL_METHOD_START(IAgilent34980ACurrent, get_DCCurrent);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_DCCurrent"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980ACurrent"), _T("get_DCCurrent"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980ADCCurrent_Configure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADCCurrent"), _T("Configure"));
	NTL_METHOD_START(IAgilent34980ADCCurrent, Configure);
	CMethodTrace mt(pT, _T("IAgilent34980ADCCurrent"), _T("Configure"), IN_PARAM(ChannelList), IN_PARAM(Range), IN_PARAM(Resolution), NULL);

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

	strCmd.Format(_T(":CONF:CURR %.15g, %s, (@%s)"), Range, pT->EnumToString<Agilent34980AResolutionEnum>(Resolution), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADCCurrent_Configure(ChannelList, Range, Resolution);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADCCurrent_Measure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADCCurrent"), _T("Measure"));
	NTL_METHOD_START(IAgilent34980ADCCurrent, Measure);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("Measure"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980ADCCurrent"), _T("Measure"), IN_PARAM(ChannelList), IN_PARAM(Range), IN_PARAM(Resolution), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":MEAS:CURR? %.15g, %s, (@%s)"), Range, pT->EnumToString<Agilent34980AResolutionEnum>(Resolution), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADCCurrent_Measure(ChannelList, Range, Resolution, val);
	pT->PopInstrCommand();

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

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

	strCmd.Format(_T(":CURR:DC:APER? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADCCurrent_get_Aperture(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADCCurrent_put_Aperture(Agilent34980A* pT, BSTR ChannelList, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADCCurrent"), _T("put_Aperture"));
	NTL_METHOD_START(IAgilent34980ADCCurrent, put_Aperture);
	CMethodTrace mt(pT, _T("IAgilent34980ADCCurrent"), _T("put_Aperture"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

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

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

	strCmd.Format(_T(":CURR:DC:RANG:AUTO? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADCCurrent_get_AutoRange(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADCCurrent_put_AutoRange(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADCCurrent"), _T("put_AutoRange"));
	NTL_METHOD_START(IAgilent34980ADCCurrent, put_AutoRange);
	CMethodTrace mt(pT, _T("IAgilent34980ADCCurrent"), _T("put_AutoRange"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":CURR:DC:RANG:AUTO %s, (@%s)"), val == VARIANT_FALSE ? "0" : "1", LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADCCurrent_put_AutoRange(ChannelList, val);
	pT->PopInstrCommand();

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

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

	strCmd.Format(_T(":CURR:DC:NPLC? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADCCurrent_get_NPLC(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADCCurrent_put_NPLC(Agilent34980A* pT, BSTR ChannelList, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADCCurrent"), _T("put_NPLC"));
	NTL_METHOD_START(IAgilent34980ADCCurrent, put_NPLC);
	CMethodTrace mt(pT, _T("IAgilent34980ADCCurrent"), _T("put_NPLC"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

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

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

	strCmd.Format(_T(":CURR:DC:RANG? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADCCurrent_get_Range(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADCCurrent_put_Range(Agilent34980A* pT, BSTR ChannelList, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADCCurrent"), _T("put_Range"));
	NTL_METHOD_START(IAgilent34980ADCCurrent, put_Range);
	CMethodTrace mt(pT, _T("IAgilent34980ADCCurrent"), _T("put_Range"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

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

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

	strCmd.Format(_T(":CURR:DC:RES? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADCCurrent_get_Resolution(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADCCurrent_get_AutoZero(Agilent34980A* pT, BSTR ChannelList, Agilent34980AAutoZeroEnum* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADCCurrent"), _T("get_AutoZero"));
	NTL_METHOD_START(IAgilent34980ADCCurrent, get_AutoZero);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_AutoZero"), _T("val"));
		*val = Agilent34980AAutoZeroOFF;
	CMethodTrace mt(pT, _T("IAgilent34980ADCCurrent"), _T("get_AutoZero"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("CURR:ZERO:AUTO? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADCCurrent_get_AutoZero(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADCCurrent_put_AutoZero(Agilent34980A* pT, BSTR ChannelList, Agilent34980AAutoZeroEnum val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADCCurrent"), _T("put_AutoZero"));
	NTL_METHOD_START(IAgilent34980ADCCurrent, put_AutoZero);
	CMethodTrace mt(pT, _T("IAgilent34980ADCCurrent"), _T("put_AutoZero"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("CURR:ZERO:AUTO %s, (@%s)"), pT->EnumToString<Agilent34980AAutoZeroEnum>(val), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADCCurrent_put_AutoZero(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADCVoltage_Configure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADCVoltage"), _T("Configure"));
	NTL_METHOD_START(IAgilent34980ADCVoltage, Configure);
	CMethodTrace mt(pT, _T("IAgilent34980ADCVoltage"), _T("Configure"), IN_PARAM(ChannelList), IN_PARAM(Range), IN_PARAM(Resolution), NULL);

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

	strCmd.Format(_T(":CONF %.15g, %s, (@%s)"), Range, pT->EnumToString<Agilent34980AResolutionEnum>(Resolution), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADCVoltage_Configure(ChannelList, Range, Resolution);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADCVoltage_Measure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADCVoltage"), _T("Measure"));
	NTL_METHOD_START(IAgilent34980ADCVoltage, Measure);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("Measure"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980ADCVoltage"), _T("Measure"), IN_PARAM(ChannelList), IN_PARAM(Range), IN_PARAM(Resolution), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("MEAS? %.15g, %s, (@%s)"), Range, pT->EnumToString<Agilent34980AResolutionEnum>(Resolution), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADCVoltage_Measure(ChannelList, Range, Resolution, val);
	pT->PopInstrCommand();

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

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

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

	return hr;
}
HRESULT IAgilent34980ADCVoltage_put_Aperture(Agilent34980A* pT, BSTR ChannelList, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADCVoltage"), _T("put_Aperture"));
	NTL_METHOD_START(IAgilent34980ADCVoltage, put_Aperture);
	CMethodTrace mt(pT, _T("IAgilent34980ADCVoltage"), _T("put_Aperture"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

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

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

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

	return hr;
}
HRESULT IAgilent34980ADCVoltage_put_AutoRange(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADCVoltage"), _T("put_AutoRange"));
	NTL_METHOD_START(IAgilent34980ADCVoltage, put_AutoRange);
	CMethodTrace mt(pT, _T("IAgilent34980ADCVoltage"), _T("put_AutoRange"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":VOLT:DC:RANG:AUTO %s, (@%s)"), val == VARIANT_FALSE ? "0" : "1", LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADCVoltage_put_AutoRange(ChannelList, val);
	pT->PopInstrCommand();

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

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

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

	return hr;
}
HRESULT IAgilent34980ADCVoltage_put_NPLC(Agilent34980A* pT, BSTR ChannelList, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADCVoltage"), _T("put_NPLC"));
	NTL_METHOD_START(IAgilent34980ADCVoltage, put_NPLC);
	CMethodTrace mt(pT, _T("IAgilent34980ADCVoltage"), _T("put_NPLC"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

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

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

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

	return hr;
}
HRESULT IAgilent34980ADCVoltage_put_Range(Agilent34980A* pT, BSTR ChannelList, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADCVoltage"), _T("put_Range"));
	NTL_METHOD_START(IAgilent34980ADCVoltage, put_Range);
	CMethodTrace mt(pT, _T("IAgilent34980ADCVoltage"), _T("put_Range"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

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

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

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

	return hr;
}
HRESULT IAgilent34980ADCVoltage_get_AutoZero(Agilent34980A* pT, BSTR ChannelList, Agilent34980AAutoZeroEnum* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADCVoltage"), _T("get_AutoZero"));
	NTL_METHOD_START(IAgilent34980ADCVoltage, get_AutoZero);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_AutoZero"), _T("val"));
		*val = Agilent34980AAutoZeroOFF;
	CMethodTrace mt(pT, _T("IAgilent34980ADCVoltage"), _T("get_AutoZero"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980ADCVoltage_put_AutoZero(Agilent34980A* pT, BSTR ChannelList, Agilent34980AAutoZeroEnum val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADCVoltage"), _T("put_AutoZero"));
	NTL_METHOD_START(IAgilent34980ADCVoltage, put_AutoZero);
	CMethodTrace mt(pT, _T("IAgilent34980ADCVoltage"), _T("put_AutoZero"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":VOLT:ZERO:AUTO %s, (@%s)"), pT->EnumToString<Agilent34980AAutoZeroEnum>(val), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADCVoltage_put_AutoZero(ChannelList, val);
	pT->PopInstrCommand();

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

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

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

	return hr;
}
HRESULT IAgilent34980ADCVoltage_put_AutoImpedance(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADCVoltage"), _T("put_AutoImpedance"));
	NTL_METHOD_START(IAgilent34980ADCVoltage, put_AutoImpedance);
	CMethodTrace mt(pT, _T("IAgilent34980ADCVoltage"), _T("put_AutoImpedance"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980ADiagnostic_RelayCyclesClear(Agilent34980A* pT, BSTR ChannelList)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADiagnostic"), _T("RelayCyclesClear"));
	NTL_METHOD_START(IAgilent34980ADiagnostic, RelayCyclesClear);
	CMethodTrace mt(pT, _T("IAgilent34980ADiagnostic"), _T("RelayCyclesClear"), IN_PARAM(ChannelList), NULL);

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

	strCmd.Format(_T(":DIAG:REL:CYCL:CLE (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADiagnostic_RelayCyclesClear(ChannelList);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADiagnostic_DMMCyclesClear(Agilent34980A* pT, long Index)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADiagnostic"), _T("DMMCyclesClear"));
	NTL_METHOD_START(IAgilent34980ADiagnostic, DMMCyclesClear);
	CMethodTrace mt(pT, _T("IAgilent34980ADiagnostic"), _T("DMMCyclesClear"), IN_PARAM(Index), NULL);

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

	strCmd.Format(_T(":DIAG:DMM:CYCL:CLE %d"), Index);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADiagnostic_DMMCyclesClear(Index);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADiagnostic_get_DMMCycles(Agilent34980A* pT, long Index, long* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADiagnostic"), _T("get_DMMCycles"));
	NTL_METHOD_START(IAgilent34980ADiagnostic, get_DMMCycles);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_DMMCycles"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34980ADiagnostic"), _T("get_DMMCycles"), IN_PARAM(Index), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":DIAG:DMM:CYCL? %d"), Index);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADiagnostic_get_DMMCycles(Index, val);
	pT->PopInstrCommand();

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

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

	strCmd.Format(_T(":DIAG:REL:CYCL? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADiagnostic_get_RelayCycles(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADisplay_ClearDisplay(Agilent34980A* pT)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADisplay"), _T("ClearDisplay"));
	NTL_METHOD_START(IAgilent34980ADisplay, ClearDisplay);
	CMethodTrace mt(pT, _T("IAgilent34980ADisplay"), _T("ClearDisplay"), NULL);

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

	strCmd.Format(_T(":DISP:TEXT:CLE"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADisplay_ClearDisplay();
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADisplay_MonitorDMM(Agilent34980A* pT)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADisplay"), _T("MonitorDMM"));
	NTL_METHOD_START(IAgilent34980ADisplay, MonitorDMM);
	CMethodTrace mt(pT, _T("IAgilent34980ADisplay"), _T("MonitorDMM"), NULL);

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

	strCmd.Format(_T(":ROUT:MON:MODE DMM;  :ROUT:MON:STAT ON"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADisplay_MonitorDMM();
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADisplay_MonitorChannel(Agilent34980A* pT, BSTR Channel)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADisplay"), _T("MonitorChannel"));
	NTL_METHOD_START(IAgilent34980ADisplay, MonitorChannel);
	CMethodTrace mt(pT, _T("IAgilent34980ADisplay"), _T("MonitorChannel"), IN_PARAM(Channel), NULL);

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

	strCmd.Format(_T(":ROUT:MON:ENAB ON, (@%s); :ROUT:MON:CHAN (@%s); :ROUT:MON:MODE CHAN; :ROUT:MON:STAT ON"), LPCTSTR(COLE2T(Channel)), LPCTSTR(COLE2T(Channel)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADisplay_MonitorChannel(Channel);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADisplay_get_DisplayEnabled(Agilent34980A* pT, VARIANT_BOOL* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADisplay"), _T("get_DisplayEnabled"));
	NTL_METHOD_START(IAgilent34980ADisplay, get_DisplayEnabled);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_DisplayEnabled"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IAgilent34980ADisplay"), _T("get_DisplayEnabled"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":DISP?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADisplay_get_DisplayEnabled(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADisplay_put_DisplayEnabled(Agilent34980A* pT, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADisplay"), _T("put_DisplayEnabled"));
	NTL_METHOD_START(IAgilent34980ADisplay, put_DisplayEnabled);
	CMethodTrace mt(pT, _T("IAgilent34980ADisplay"), _T("put_DisplayEnabled"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":DISP %s"), val == VARIANT_FALSE ? "0" : "1");
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADisplay_put_DisplayEnabled(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADisplay_get_DisplayText(Agilent34980A* pT, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADisplay"), _T("get_DisplayText"));
	NTL_METHOD_START(IAgilent34980ADisplay, get_DisplayText);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_DisplayText"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980ADisplay"), _T("get_DisplayText"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":DISP:TEXT?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADisplay_get_DisplayText(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADisplay_put_DisplayText(Agilent34980A* pT, BSTR val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADisplay"), _T("put_DisplayText"));
	NTL_METHOD_START(IAgilent34980ADisplay, put_DisplayText);
	CMethodTrace mt(pT, _T("IAgilent34980ADisplay"), _T("put_DisplayText"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":DISP:TEXT \"%s\""), LPCTSTR(COLE2T(val)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADisplay_put_DisplayText(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADisplay_get_MonitorData(Agilent34980A* pT, double* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADisplay"), _T("get_MonitorData"));
	NTL_METHOD_START(IAgilent34980ADisplay, get_MonitorData);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_MonitorData"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IAgilent34980ADisplay"), _T("get_MonitorData"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":ROUT:MON:DATA?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADisplay_get_MonitorData(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADisplay_get_MonitorEnable(Agilent34980A* pT, VARIANT_BOOL* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADisplay"), _T("get_MonitorEnable"));
	NTL_METHOD_START(IAgilent34980ADisplay, get_MonitorEnable);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_MonitorEnable"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IAgilent34980ADisplay"), _T("get_MonitorEnable"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":ROUT:MON:STAT?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADisplay_get_MonitorEnable(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADisplay_put_MonitorEnable(Agilent34980A* pT, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADisplay"), _T("put_MonitorEnable"));
	NTL_METHOD_START(IAgilent34980ADisplay, put_MonitorEnable);
	CMethodTrace mt(pT, _T("IAgilent34980ADisplay"), _T("put_MonitorEnable"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":ROUT:MON:STAT %s"), val == VARIANT_FALSE ? "0" : "1");
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADisplay_put_MonitorEnable(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADisplay_get_MonitorMode(Agilent34980A* pT, Agilent34980AMonitorModeEnum* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADisplay"), _T("get_MonitorMode"));
	NTL_METHOD_START(IAgilent34980ADisplay, get_MonitorMode);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_MonitorMode"), _T("val"));
		*val = Agilent34980AMonitorModeChannel;
	CMethodTrace mt(pT, _T("IAgilent34980ADisplay"), _T("get_MonitorMode"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":ROUT:MON:MODE?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADisplay_get_MonitorMode(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADisplay_put_MonitorMode(Agilent34980A* pT, Agilent34980AMonitorModeEnum val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADisplay"), _T("put_MonitorMode"));
	NTL_METHOD_START(IAgilent34980ADisplay, put_MonitorMode);
	CMethodTrace mt(pT, _T("IAgilent34980ADisplay"), _T("put_MonitorMode"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":ROUT:MON:MODE %s"), pT->EnumToString<Agilent34980AMonitorModeEnum>(val));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADisplay_put_MonitorMode(val);
	pT->PopInstrCommand();

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

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

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

	return hr;
}
HRESULT IAgilent34980ADisplay_put_EnableMonitorChan(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADisplay"), _T("put_EnableMonitorChan"));
	NTL_METHOD_START(IAgilent34980ADisplay, put_EnableMonitorChan);
	CMethodTrace mt(pT, _T("IAgilent34980ADisplay"), _T("put_EnableMonitorChan"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980ADisplay_get_SelectMonitorChan(Agilent34980A* pT, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADisplay"), _T("get_SelectMonitorChan"));
	NTL_METHOD_START(IAgilent34980ADisplay, get_SelectMonitorChan);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_SelectMonitorChan"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980ADisplay"), _T("get_SelectMonitorChan"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("ROUT:MON?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADisplay_get_SelectMonitorChan(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADisplay_put_SelectMonitorChan(Agilent34980A* pT, BSTR val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADisplay"), _T("put_SelectMonitorChan"));
	NTL_METHOD_START(IAgilent34980ADisplay, put_SelectMonitorChan);
	CMethodTrace mt(pT, _T("IAgilent34980ADisplay"), _T("put_SelectMonitorChan"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":ROUT:MON  (@%s)"), LPCTSTR(COLE2T(val)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADisplay_put_SelectMonitorChan(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AFrequency_Measure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AFrequency"), _T("Measure"));
	NTL_METHOD_START(IAgilent34980AFrequency, Measure);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("Measure"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980AFrequency"), _T("Measure"), IN_PARAM(ChannelList), IN_PARAM(Range), IN_PARAM(Resolution), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":MEAS:FREQ? DEF, %s, (@%s)"), pT->EnumToString<Agilent34980AResolutionEnum>(Resolution), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AFrequency_Measure(ChannelList, Range, Resolution, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AFrequency_Configure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AFrequency"), _T("Configure"));
	NTL_METHOD_START(IAgilent34980AFrequency, Configure);
	CMethodTrace mt(pT, _T("IAgilent34980AFrequency"), _T("Configure"), IN_PARAM(ChannelList), IN_PARAM(Range), IN_PARAM(Resolution), NULL);

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

	strCmd.Format(_T(":CONF:FREQ DEF, %s, (@%s)"), pT->EnumToString<Agilent34980AResolutionEnum>(Resolution), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AFrequency_Configure(ChannelList, Range, Resolution);
	pT->PopInstrCommand();

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

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

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

	return hr;
}
HRESULT IAgilent34980AFrequency_put_Aperture(Agilent34980A* pT, BSTR ChannelList, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AFrequency"), _T("put_Aperture"));
	NTL_METHOD_START(IAgilent34980AFrequency, put_Aperture);
	CMethodTrace mt(pT, _T("IAgilent34980AFrequency"), _T("put_Aperture"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

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

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

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

	return hr;
}
HRESULT IAgilent34980AFrequency_put_AutoRange(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AFrequency"), _T("put_AutoRange"));
	NTL_METHOD_START(IAgilent34980AFrequency, put_AutoRange);
	CMethodTrace mt(pT, _T("IAgilent34980AFrequency"), _T("put_AutoRange"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":FREQ:VOLT:RANG:AUTO %s, (@%s)"), val == VARIANT_FALSE ? "0" : "1", LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AFrequency_put_AutoRange(ChannelList, val);
	pT->PopInstrCommand();

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

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

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

	return hr;
}
HRESULT IAgilent34980AFrequency_put_LowRange(Agilent34980A* pT, BSTR ChannelList, long val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AFrequency"), _T("put_LowRange"));
	NTL_METHOD_START(IAgilent34980AFrequency, put_LowRange);
	CMethodTrace mt(pT, _T("IAgilent34980AFrequency"), _T("put_LowRange"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":FREQ:RANG:LOW %d, (@%s)"), val, LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AFrequency_put_LowRange(ChannelList, val);
	pT->PopInstrCommand();

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

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

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

	return hr;
}
HRESULT IAgilent34980AFResistance_Configure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AFResistance"), _T("Configure"));
	NTL_METHOD_START(IAgilent34980AFResistance, Configure);
	CMethodTrace mt(pT, _T("IAgilent34980AFResistance"), _T("Configure"), IN_PARAM(ChannelList), IN_PARAM(Range), IN_PARAM(Resolution), NULL);

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

	strCmd.Format(_T(":CONF:FRES %.15g, %s, (@%s)"), Range, pT->EnumToString<Agilent34980AResolutionEnum>(Resolution), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AFResistance_Configure(ChannelList, Range, Resolution);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AFResistance_Measure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AFResistance"), _T("Measure"));
	NTL_METHOD_START(IAgilent34980AFResistance, Measure);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("Measure"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980AFResistance"), _T("Measure"), IN_PARAM(ChannelList), IN_PARAM(Range), IN_PARAM(Resolution), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":MEAS:FRES? %.15g, %s, (@%s)"), Range, pT->EnumToString<Agilent34980AResolutionEnum>(Resolution), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AFResistance_Measure(ChannelList, Range, Resolution, val);
	pT->PopInstrCommand();

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

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

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

	return hr;
}
HRESULT IAgilent34980AFResistance_put_Aperture(Agilent34980A* pT, BSTR ChannelList, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AFResistance"), _T("put_Aperture"));
	NTL_METHOD_START(IAgilent34980AFResistance, put_Aperture);
	CMethodTrace mt(pT, _T("IAgilent34980AFResistance"), _T("put_Aperture"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

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

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

	strCmd.Format(_T(":FRES:RANG:AUTO? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AFResistance_get_AutoRange(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AFResistance_put_AutoRange(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AFResistance"), _T("put_AutoRange"));
	NTL_METHOD_START(IAgilent34980AFResistance, put_AutoRange);
	CMethodTrace mt(pT, _T("IAgilent34980AFResistance"), _T("put_AutoRange"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

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

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

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

	return hr;
}
HRESULT IAgilent34980AFResistance_put_NPLC(Agilent34980A* pT, BSTR ChannelList, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AFResistance"), _T("put_NPLC"));
	NTL_METHOD_START(IAgilent34980AFResistance, put_NPLC);
	CMethodTrace mt(pT, _T("IAgilent34980AFResistance"), _T("put_NPLC"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

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

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

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

	return hr;
}
HRESULT IAgilent34980AFResistance_put_OCompensated(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AFResistance"), _T("put_OCompensated"));
	NTL_METHOD_START(IAgilent34980AFResistance, put_OCompensated);
	CMethodTrace mt(pT, _T("IAgilent34980AFResistance"), _T("put_OCompensated"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

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

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

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

	return hr;
}
HRESULT IAgilent34980AFResistance_put_Range(Agilent34980A* pT, BSTR ChannelList, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AFResistance"), _T("put_Range"));
	NTL_METHOD_START(IAgilent34980AFResistance, put_Range);
	CMethodTrace mt(pT, _T("IAgilent34980AFResistance"), _T("put_Range"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

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

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

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

	return hr;
}
HRESULT IAgilent34980AMeasurement_Initiate(Agilent34980A* pT)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AMeasurement"), _T("Initiate"));
	NTL_METHOD_START(IAgilent34980AMeasurement, Initiate);
	CMethodTrace mt(pT, _T("IAgilent34980AMeasurement"), _T("Initiate"), NULL);

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

	strCmd.Format(_T("INIT"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AMeasurement_Initiate();
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AMeasurement_Abort(Agilent34980A* pT)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AMeasurement"), _T("Abort"));
	NTL_METHOD_START(IAgilent34980AMeasurement, Abort);
	CMethodTrace mt(pT, _T("IAgilent34980AMeasurement"), _T("Abort"), NULL);

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

	strCmd.Format(_T("ABOR"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AMeasurement_Abort();
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AMeasurement_DestructiveRead(Agilent34980A* pT, long MaxCount, SAFEARRAY** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AMeasurement"), _T("DestructiveRead"));
	NTL_METHOD_START(IAgilent34980AMeasurement, DestructiveRead);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("DestructiveRead"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980AMeasurement"), _T("DestructiveRead"), IN_PARAM(MaxCount), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("R? %d"), MaxCount);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AMeasurement_DestructiveRead(MaxCount, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AMeasurement_Fetch(Agilent34980A* pT, SAFEARRAY** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AMeasurement"), _T("Fetch"));
	NTL_METHOD_START(IAgilent34980AMeasurement, Fetch);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("Fetch"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980AMeasurement"), _T("Fetch"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("FETC?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AMeasurement_Fetch(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AMeasurement_FetchNumbersOnly(Agilent34980A* pT, SAFEARRAY** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AMeasurement"), _T("FetchNumbersOnly"));
	NTL_METHOD_START(IAgilent34980AMeasurement, FetchNumbersOnly);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("FetchNumbersOnly"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980AMeasurement"), _T("FetchNumbersOnly"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":FETCH?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AMeasurement_FetchNumbersOnly(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AMeasurement_QueryLast(Agilent34980A* pT, BSTR Channel, double* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AMeasurement"), _T("QueryLast"));
	NTL_METHOD_START(IAgilent34980AMeasurement, QueryLast);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("QueryLast"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IAgilent34980AMeasurement"), _T("QueryLast"), IN_PARAM(Channel), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":DATA:LAST? 1, (@%s)"), LPCTSTR(COLE2T(Channel)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AMeasurement_QueryLast(Channel, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AMeasurement_Read(Agilent34980A* pT, BSTR ChannelList, SAFEARRAY** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AMeasurement"), _T("Read"));
	NTL_METHOD_START(IAgilent34980AMeasurement, Read);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("Read"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980AMeasurement"), _T("Read"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980AMeasurement_ReadNumbersOnly(Agilent34980A* pT, BSTR ChannelList, SAFEARRAY** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AMeasurement"), _T("ReadNumbersOnly"));
	NTL_METHOD_START(IAgilent34980AMeasurement, ReadNumbersOnly);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("ReadNumbersOnly"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980AMeasurement"), _T("ReadNumbersOnly"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980AMeasurement_RemoveReadings(Agilent34980A* pT, long NumReadings, SAFEARRAY** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AMeasurement"), _T("RemoveReadings"));
	NTL_METHOD_START(IAgilent34980AMeasurement, RemoveReadings);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("RemoveReadings"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980AMeasurement"), _T("RemoveReadings"), IN_PARAM(NumReadings), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":DATA:REM? %d"), NumReadings);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AMeasurement_RemoveReadings(NumReadings, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AMeasurement_SendSoftwareTrigger(Agilent34980A* pT)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AMeasurement"), _T("SendSoftwareTrigger"));
	NTL_METHOD_START(IAgilent34980AMeasurement, SendSoftwareTrigger);
	CMethodTrace mt(pT, _T("IAgilent34980AMeasurement"), _T("SendSoftwareTrigger"), NULL);

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

	strCmd.Format(_T("*TRG"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AMeasurement_SendSoftwareTrigger();
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AMeasurement_get_DataFormat(Agilent34980A* pT, IAgilent34980ADataFormat** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AMeasurement"), _T("get_DataFormat"));
	NTL_METHOD_START(IAgilent34980AMeasurement, get_DataFormat);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_DataFormat"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980AMeasurement"), _T("get_DataFormat"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980AMeasurement_get_ReadingCount(Agilent34980A* pT, long* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AMeasurement"), _T("get_ReadingCount"));
	NTL_METHOD_START(IAgilent34980AMeasurement, get_ReadingCount);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ReadingCount"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34980AMeasurement"), _T("get_ReadingCount"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("DATA:POIN?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AMeasurement_get_ReadingCount(val);
	pT->PopInstrCommand();

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

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

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

	return hr;
}
HRESULT IAgilent34980AMeasurement_put_MeasurementFunction(Agilent34980A* pT, BSTR Channel, BSTR val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AMeasurement"), _T("put_MeasurementFunction"));
	NTL_METHOD_START(IAgilent34980AMeasurement, put_MeasurementFunction);
	CMethodTrace mt(pT, _T("IAgilent34980AMeasurement"), _T("put_MeasurementFunction"), IN_PARAM(Channel), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("FUNC \"%s\", (@%s)"), LPCTSTR(COLE2T(val)), LPCTSTR(COLE2T(Channel)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AMeasurement_put_MeasurementFunction(Channel, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AMemory_SaveState(Agilent34980A* pT, BSTR Identifier)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AMemory"), _T("SaveState"));
	NTL_METHOD_START(IAgilent34980AMemory, SaveState);
	CMethodTrace mt(pT, _T("IAgilent34980AMemory"), _T("SaveState"), IN_PARAM(Identifier), NULL);

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

	strCmd.Format(_T("*SAV %s"), LPCTSTR(COLE2T(Identifier)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AMemory_SaveState(Identifier);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AMemory_RecallState(Agilent34980A* pT, BSTR Identifier)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AMemory"), _T("RecallState"));
	NTL_METHOD_START(IAgilent34980AMemory, RecallState);
	CMethodTrace mt(pT, _T("IAgilent34980AMemory"), _T("RecallState"), IN_PARAM(Identifier), NULL);

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

	strCmd.Format(_T("*RCL %s"), LPCTSTR(COLE2T(Identifier)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AMemory_RecallState(Identifier);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AMemory_DeleteLocation(Agilent34980A* pT, long LocationNum, VARIANT_BOOL DeleteAll)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AMemory"), _T("DeleteLocation"));
	NTL_METHOD_START(IAgilent34980AMemory, DeleteLocation);
	CMethodTrace mt(pT, _T("IAgilent34980AMemory"), _T("DeleteLocation"), IN_PARAM(LocationNum), IN_PARAM(DeleteAll), NULL);

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

	strCmd.Format(_T(":MEM:STAT:DEL %d"), LocationNum);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AMemory_DeleteLocation(LocationNum, DeleteAll);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AMemory_get_AutoRecall(Agilent34980A* pT, VARIANT_BOOL* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AMemory"), _T("get_AutoRecall"));
	NTL_METHOD_START(IAgilent34980AMemory, get_AutoRecall);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_AutoRecall"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IAgilent34980AMemory"), _T("get_AutoRecall"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":MEM:STAT:REC:AUTO?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AMemory_get_AutoRecall(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AMemory_put_AutoRecall(Agilent34980A* pT, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AMemory"), _T("put_AutoRecall"));
	NTL_METHOD_START(IAgilent34980AMemory, put_AutoRecall);
	CMethodTrace mt(pT, _T("IAgilent34980AMemory"), _T("put_AutoRecall"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":MEM:STAT:REC:AUTO %s"), val == VARIANT_FALSE ? "0" : "1");
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AMemory_put_AutoRecall(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AMemory_get_NumStates(Agilent34980A* pT, long* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AMemory"), _T("get_NumStates"));
	NTL_METHOD_START(IAgilent34980AMemory, get_NumStates);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_NumStates"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34980AMemory"), _T("get_NumStates"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":MEM:NST?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AMemory_get_NumStates(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AMemory_get_StateName(Agilent34980A* pT, long LocationNum, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AMemory"), _T("get_StateName"));
	NTL_METHOD_START(IAgilent34980AMemory, get_StateName);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_StateName"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980AMemory"), _T("get_StateName"), IN_PARAM(LocationNum), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":MEM:STAT:NAME? %d"), LocationNum);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AMemory_get_StateName(LocationNum, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AMemory_put_StateName(Agilent34980A* pT, long LocationNum, BSTR val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AMemory"), _T("put_StateName"));
	NTL_METHOD_START(IAgilent34980AMemory, put_StateName);
	CMethodTrace mt(pT, _T("IAgilent34980AMemory"), _T("put_StateName"), IN_PARAM(LocationNum), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":MEM:STAT:NAME %d, %s"), LocationNum, LPCTSTR(COLE2T(val)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AMemory_put_StateName(LocationNum, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AMemory_get_ValidState(Agilent34980A* pT, long LocationNum, VARIANT_BOOL* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AMemory"), _T("get_ValidState"));
	NTL_METHOD_START(IAgilent34980AMemory, get_ValidState);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ValidState"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IAgilent34980AMemory"), _T("get_ValidState"), IN_PARAM(LocationNum), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":MEM:STAT:VAL? %d"), LocationNum);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AMemory_get_ValidState(LocationNum, val);
	pT->PopInstrCommand();

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

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

	strCmd.Format(_T("MEM:STAT:CAT?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AMemory_get_Catalog(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980APeriod_Configure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980APeriod"), _T("Configure"));
	NTL_METHOD_START(IAgilent34980APeriod, Configure);
	CMethodTrace mt(pT, _T("IAgilent34980APeriod"), _T("Configure"), IN_PARAM(ChannelList), IN_PARAM(Range), IN_PARAM(Resolution), NULL);

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

	strCmd.Format(_T(":CONF:PER DEF, %s, (@%s)"), pT->EnumToString<Agilent34980AResolutionEnum>(Resolution), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980APeriod_Configure(ChannelList, Range, Resolution);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980APeriod_Measure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980APeriod"), _T("Measure"));
	NTL_METHOD_START(IAgilent34980APeriod, Measure);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("Measure"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980APeriod"), _T("Measure"), IN_PARAM(ChannelList), IN_PARAM(Range), IN_PARAM(Resolution), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":MEAS:PER? DEF, %s, (@%s)"), pT->EnumToString<Agilent34980AResolutionEnum>(Resolution), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980APeriod_Measure(ChannelList, Range, Resolution, val);
	pT->PopInstrCommand();

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

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

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

	return hr;
}
HRESULT IAgilent34980APeriod_put_Aperture(Agilent34980A* pT, BSTR ChannelList, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980APeriod"), _T("put_Aperture"));
	NTL_METHOD_START(IAgilent34980APeriod, put_Aperture);
	CMethodTrace mt(pT, _T("IAgilent34980APeriod"), _T("put_Aperture"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

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

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

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

	return hr;
}
HRESULT IAgilent34980APeriod_put_AutoRange(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980APeriod"), _T("put_AutoRange"));
	NTL_METHOD_START(IAgilent34980APeriod, put_AutoRange);
	CMethodTrace mt(pT, _T("IAgilent34980APeriod"), _T("put_AutoRange"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":PER:VOLT:RANG:AUTO %s, (@%s)"), val == VARIANT_FALSE ? "0" : "1", LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980APeriod_put_AutoRange(ChannelList, val);
	pT->PopInstrCommand();

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

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

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

	return hr;
}
HRESULT IAgilent34980AResistance_Configure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AResistance"), _T("Configure"));
	NTL_METHOD_START(IAgilent34980AResistance, Configure);
	CMethodTrace mt(pT, _T("IAgilent34980AResistance"), _T("Configure"), IN_PARAM(ChannelList), IN_PARAM(Range), IN_PARAM(Resolution), NULL);

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

	strCmd.Format(_T(":CONF:RES %.15g, %s, (@%s)"), Range, pT->EnumToString<Agilent34980AResolutionEnum>(Resolution), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AResistance_Configure(ChannelList, Range, Resolution);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AResistance_Measure(Agilent34980A* pT, BSTR ChannelList, double Range, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AResistance"), _T("Measure"));
	NTL_METHOD_START(IAgilent34980AResistance, Measure);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("Measure"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980AResistance"), _T("Measure"), IN_PARAM(ChannelList), IN_PARAM(Range), IN_PARAM(Resolution), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":MEAS:RES? %.15g, %s, (@%s)"), Range, pT->EnumToString<Agilent34980AResolutionEnum>(Resolution), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AResistance_Measure(ChannelList, Range, Resolution, val);
	pT->PopInstrCommand();

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

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

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

	return hr;
}
HRESULT IAgilent34980AResistance_put_Aperture(Agilent34980A* pT, BSTR ChannelList, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AResistance"), _T("put_Aperture"));
	NTL_METHOD_START(IAgilent34980AResistance, put_Aperture);
	CMethodTrace mt(pT, _T("IAgilent34980AResistance"), _T("put_Aperture"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

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

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

	strCmd.Format(_T(":RES:RANG:AUTO? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AResistance_get_AutoRange(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AResistance_put_AutoRange(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AResistance"), _T("put_AutoRange"));
	NTL_METHOD_START(IAgilent34980AResistance, put_AutoRange);
	CMethodTrace mt(pT, _T("IAgilent34980AResistance"), _T("put_AutoRange"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

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

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

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

	return hr;
}
HRESULT IAgilent34980AResistance_put_NPLC(Agilent34980A* pT, BSTR ChannelList, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AResistance"), _T("put_NPLC"));
	NTL_METHOD_START(IAgilent34980AResistance, put_NPLC);
	CMethodTrace mt(pT, _T("IAgilent34980AResistance"), _T("put_NPLC"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

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

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

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

	return hr;
}
HRESULT IAgilent34980AResistance_put_OCompensated(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AResistance"), _T("put_OCompensated"));
	NTL_METHOD_START(IAgilent34980AResistance, put_OCompensated);
	CMethodTrace mt(pT, _T("IAgilent34980AResistance"), _T("put_OCompensated"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

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

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

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

	return hr;
}
HRESULT IAgilent34980AResistance_put_Range(Agilent34980A* pT, BSTR ChannelList, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AResistance"), _T("put_Range"));
	NTL_METHOD_START(IAgilent34980AResistance, put_Range);
	CMethodTrace mt(pT, _T("IAgilent34980AResistance"), _T("put_Range"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

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

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

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

	return hr;
}
HRESULT IAgilent34980AResistance_get_AutoZero(Agilent34980A* pT, BSTR ChannelList, Agilent34980AAutoZeroEnum* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AResistance"), _T("get_AutoZero"));
	NTL_METHOD_START(IAgilent34980AResistance, get_AutoZero);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_AutoZero"), _T("val"));
		*val = Agilent34980AAutoZeroOFF;
	CMethodTrace mt(pT, _T("IAgilent34980AResistance"), _T("get_AutoZero"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":RES:ZERO:AUTO? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AResistance_get_AutoZero(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AResistance_put_AutoZero(Agilent34980A* pT, BSTR ChannelList, Agilent34980AAutoZeroEnum val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AResistance"), _T("put_AutoZero"));
	NTL_METHOD_START(IAgilent34980AResistance, put_AutoZero);
	CMethodTrace mt(pT, _T("IAgilent34980AResistance"), _T("put_AutoZero"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":RES:ZERO:AUTO %s, (@%s)"), pT->EnumToString<Agilent34980AAutoZeroEnum>(val), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AResistance_put_AutoZero(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AScale_OffsetNull(Agilent34980A* pT, BSTR ChannelList)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AScale"), _T("OffsetNull"));
	NTL_METHOD_START(IAgilent34980AScale, OffsetNull);
	CMethodTrace mt(pT, _T("IAgilent34980AScale"), _T("OffsetNull"), IN_PARAM(ChannelList), NULL);

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

	strCmd.Format(_T("CALC:SCAL:OFFS:NULL (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AScale_OffsetNull(ChannelList);
	pT->PopInstrCommand();

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

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

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

	return hr;
}
HRESULT IAgilent34980AScale_put_Gain(Agilent34980A* pT, BSTR ChannelList, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AScale"), _T("put_Gain"));
	NTL_METHOD_START(IAgilent34980AScale, put_Gain);
	CMethodTrace mt(pT, _T("IAgilent34980AScale"), _T("put_Gain"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

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

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

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

	return hr;
}
HRESULT IAgilent34980AScale_put_Offset(Agilent34980A* pT, BSTR ChannelList, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AScale"), _T("put_Offset"));
	NTL_METHOD_START(IAgilent34980AScale, put_Offset);
	CMethodTrace mt(pT, _T("IAgilent34980AScale"), _T("put_Offset"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980AScale_get_State(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AScale"), _T("get_State"));
	NTL_METHOD_START(IAgilent34980AScale, 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("IAgilent34980AScale"), _T("get_State"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980AScale_put_State(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AScale"), _T("put_State"));
	NTL_METHOD_START(IAgilent34980AScale, put_State);
	CMethodTrace mt(pT, _T("IAgilent34980AScale"), _T("put_State"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980AScale_get_Unit(Agilent34980A* pT, BSTR ChannelList, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AScale"), _T("get_Unit"));
	NTL_METHOD_START(IAgilent34980AScale, get_Unit);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Unit"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980AScale"), _T("get_Unit"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980AScale_put_Unit(Agilent34980A* pT, BSTR ChannelList, BSTR val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AScale"), _T("put_Unit"));
	NTL_METHOD_START(IAgilent34980AScale, put_Unit);
	CMethodTrace mt(pT, _T("IAgilent34980AScale"), _T("put_Unit"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("CALC:SCAL:UNIT \"%s\", (@%s)"), LPCTSTR(COLE2T(val)), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AScale_put_Unit(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ARoute_CloseExclusive(Agilent34980A* pT, BSTR ChannelList)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ARoute"), _T("CloseExclusive"));
	NTL_METHOD_START(IAgilent34980ARoute, CloseExclusive);
	CMethodTrace mt(pT, _T("IAgilent34980ARoute"), _T("CloseExclusive"), IN_PARAM(ChannelList), NULL);

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

	strCmd.Format(_T("ROUT:CLOS:EXCL (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ARoute_CloseExclusive(ChannelList);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ARoute_Close(Agilent34980A* pT, BSTR ChannelList)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ARoute"), _T("Close"));
	NTL_METHOD_START(IAgilent34980ARoute, Close);
	CMethodTrace mt(pT, _T("IAgilent34980ARoute"), _T("Close"), IN_PARAM(ChannelList), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980ARoute_Open(Agilent34980A* pT, BSTR ChannelList)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ARoute"), _T("Open"));
	NTL_METHOD_START(IAgilent34980ARoute, Open);
	CMethodTrace mt(pT, _T("IAgilent34980ARoute"), _T("Open"), IN_PARAM(ChannelList), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980ARoute_OpenAll(Agilent34980A* pT, long Slot)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ARoute"), _T("OpenAll"));
	NTL_METHOD_START(IAgilent34980ARoute, OpenAll);
	CMethodTrace mt(pT, _T("IAgilent34980ARoute"), _T("OpenAll"), IN_PARAM(Slot), NULL);

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

	strCmd.Format(_T("ROUT:OPEN:ALL %d"), Slot);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ARoute_OpenAll(Slot);
	pT->PopInstrCommand();

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

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

	strCmd.Format(_T(":ROUT:CHAN:DEL:AUTO?  (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ARoute_get_AutoDelay(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ARoute_put_AutoDelay(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ARoute"), _T("put_AutoDelay"));
	NTL_METHOD_START(IAgilent34980ARoute, put_AutoDelay);
	CMethodTrace mt(pT, _T("IAgilent34980ARoute"), _T("put_AutoDelay"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":ROUT:CHAN:DEL:AUTO %s, (@%s)"), val == VARIANT_FALSE ? "0" : "1", LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ARoute_put_AutoDelay(ChannelList, val);
	pT->PopInstrCommand();

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

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

	strCmd.Format(_T(":ROUT:CHAN:DEL? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ARoute_get_Delay(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ARoute_put_Delay(Agilent34980A* pT, BSTR ChannelList, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ARoute"), _T("put_Delay"));
	NTL_METHOD_START(IAgilent34980ARoute, put_Delay);
	CMethodTrace mt(pT, _T("IAgilent34980ARoute"), _T("put_Delay"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

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

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

	strCmd.Format(_T(":ROUT:CHAN:FWIR? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ARoute_get_FWire(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ARoute_put_FWire(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ARoute"), _T("put_FWire"));
	NTL_METHOD_START(IAgilent34980ARoute, put_FWire);
	CMethodTrace mt(pT, _T("IAgilent34980ARoute"), _T("put_FWire"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980ARoute_get_Done(Agilent34980A* pT, VARIANT_BOOL* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ARoute"), _T("get_Done"));
	NTL_METHOD_START(IAgilent34980ARoute, get_Done);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Done"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IAgilent34980ARoute"), _T("get_Done"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("ROUT:DONE?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ARoute_get_Done(val);
	pT->PopInstrCommand();

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

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

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

	return hr;
}
HRESULT IAgilent34980AScan_ConfigureScan(Agilent34980A* pT, BSTR ChannelList, long SweepCount, VARIANT_BOOL Ordered)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AScan"), _T("ConfigureScan"));
	NTL_METHOD_START(IAgilent34980AScan, ConfigureScan);
	CMethodTrace mt(pT, _T("IAgilent34980AScan"), _T("ConfigureScan"), IN_PARAM(ChannelList), IN_PARAM(SweepCount), IN_PARAM(Ordered), NULL);

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

	strCmd.Format(_T(":ROUT:SCAN (@%s); :SWE:COUN %d; :ROUT:SCAN:ORD %s;"), LPCTSTR(COLE2T(ChannelList)), SweepCount, Ordered == VARIANT_FALSE ? "0" : "1");
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AScan_ConfigureScan(ChannelList, SweepCount, Ordered);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AScan_get_ScanSize(Agilent34980A* pT, long* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AScan"), _T("get_ScanSize"));
	NTL_METHOD_START(IAgilent34980AScan, get_ScanSize);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ScanSize"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34980AScan"), _T("get_ScanSize"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":ROUT:SCAN:SIZE?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AScan_get_ScanSize(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AScan_get_ScanList(Agilent34980A* pT, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AScan"), _T("get_ScanList"));
	NTL_METHOD_START(IAgilent34980AScan, get_ScanList);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ScanList"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980AScan"), _T("get_ScanList"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":ROUT:SCAN?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AScan_get_ScanList(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AScan_put_ScanList(Agilent34980A* pT, BSTR val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AScan"), _T("put_ScanList"));
	NTL_METHOD_START(IAgilent34980AScan, put_ScanList);
	CMethodTrace mt(pT, _T("IAgilent34980AScan"), _T("put_ScanList"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":ROUT:SCAN (@%s)"), LPCTSTR(COLE2T(val)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AScan_put_ScanList(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AScan_get_ScanTime(Agilent34980A* pT, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AScan"), _T("get_ScanTime"));
	NTL_METHOD_START(IAgilent34980AScan, get_ScanTime);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ScanTime"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980AScan"), _T("get_ScanTime"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("SYST:TIME:SCAN?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AScan_get_ScanTime(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AScan_get_SweepCount(Agilent34980A* pT, long* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AScan"), _T("get_SweepCount"));
	NTL_METHOD_START(IAgilent34980AScan, get_SweepCount);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_SweepCount"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34980AScan"), _T("get_SweepCount"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":SWE:COUN?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AScan_get_SweepCount(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AScan_put_SweepCount(Agilent34980A* pT, long val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AScan"), _T("put_SweepCount"));
	NTL_METHOD_START(IAgilent34980AScan, put_SweepCount);
	CMethodTrace mt(pT, _T("IAgilent34980AScan"), _T("put_SweepCount"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":SWE:COUN %d"), val);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AScan_put_SweepCount(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AScan_get_OrderedScan(Agilent34980A* pT, VARIANT_BOOL* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AScan"), _T("get_OrderedScan"));
	NTL_METHOD_START(IAgilent34980AScan, get_OrderedScan);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_OrderedScan"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IAgilent34980AScan"), _T("get_OrderedScan"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("ROUT:SCAN:ORD?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AScan_get_OrderedScan(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AScan_put_OrderedScan(Agilent34980A* pT, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AScan"), _T("put_OrderedScan"));
	NTL_METHOD_START(IAgilent34980AScan, put_OrderedScan);
	CMethodTrace mt(pT, _T("IAgilent34980AScan"), _T("put_OrderedScan"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("ROUT:SCAN:ORD %s"), val == VARIANT_FALSE ? "0" : "1");
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AScan_put_OrderedScan(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AStatistics_ClearStatistics(Agilent34980A* pT, BSTR ChannelList)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AStatistics"), _T("ClearStatistics"));
	NTL_METHOD_START(IAgilent34980AStatistics, ClearStatistics);
	CMethodTrace mt(pT, _T("IAgilent34980AStatistics"), _T("ClearStatistics"), IN_PARAM(ChannelList), NULL);

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

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

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

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

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

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

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

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

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

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

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

	return hr;
}
HRESULT IAgilent34980AStatistics_get_MaxValueTime(Agilent34980A* pT, BSTR ChannelList, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AStatistics"), _T("get_MaxValueTime"));
	NTL_METHOD_START(IAgilent34980AStatistics, get_MaxValueTime);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_MaxValueTime"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980AStatistics"), _T("get_MaxValueTime"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

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

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

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

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

	return hr;
}
HRESULT IAgilent34980AStatistics_get_MinValueTime(Agilent34980A* pT, BSTR ChannelList, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AStatistics"), _T("get_MinValueTime"));
	NTL_METHOD_START(IAgilent34980AStatistics, get_MinValueTime);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_MinValueTime"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980AStatistics"), _T("get_MinValueTime"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

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

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

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

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

	return hr;
}
HRESULT IAgilent34980AStatus_Preset(Agilent34980A* pT)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AStatus"), _T("Preset"));
	NTL_METHOD_START(IAgilent34980AStatus, Preset);
	CMethodTrace mt(pT, _T("IAgilent34980AStatus"), _T("Preset"), NULL);

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

	strCmd.Format(_T(":STAT:PRES"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AStatus_Preset();
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AStatus_ConfigureServiceRequest(Agilent34980A* pT, Agilent34980ASRQReasonEnum Reason)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AStatus"), _T("ConfigureServiceRequest"));
	NTL_METHOD_START(IAgilent34980AStatus, ConfigureServiceRequest);
	CMethodTrace mt(pT, _T("IAgilent34980AStatus"), _T("ConfigureServiceRequest"), IN_PARAM(Reason), NULL);

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

	strCmd.Format(_T("*SRE %s"), pT->EnumToString<Agilent34980ASRQReasonEnum>(Reason));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AStatus_ConfigureServiceRequest(Reason);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AStatus_Clear(Agilent34980A* pT)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AStatus"), _T("Clear"));
	NTL_METHOD_START(IAgilent34980AStatus, Clear);
	CMethodTrace mt(pT, _T("IAgilent34980AStatus"), _T("Clear"), NULL);

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

	strCmd.Format(_T("*CLS"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AStatus_Clear();
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AStatus_get_Register(Agilent34980A* pT, Agilent34980AStatusRegisterEnum Register, Agilent34980AStatusSubRegisterEnum SubRegister, long* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AStatus"), _T("get_Register"));
	NTL_METHOD_START(IAgilent34980AStatus, get_Register);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Register"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34980AStatus"), _T("get_Register"), IN_PARAM(Register), IN_PARAM(SubRegister), OUT_PARAM(val), NULL);

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

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AStatus_get_Register(Register, SubRegister, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AStatus_put_Register(Agilent34980A* pT, Agilent34980AStatusRegisterEnum Register, Agilent34980AStatusSubRegisterEnum SubRegister, long val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AStatus"), _T("put_Register"));
	NTL_METHOD_START(IAgilent34980AStatus, put_Register);
	CMethodTrace mt(pT, _T("IAgilent34980AStatus"), _T("put_Register"), IN_PARAM(Register), IN_PARAM(SubRegister), IN_PARAM(val), NULL);

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

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AStatus_put_Register(Register, SubRegister, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AStatus_get_SerialPoll(Agilent34980A* pT, long* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AStatus"), _T("get_SerialPoll"));
	NTL_METHOD_START(IAgilent34980AStatus, get_SerialPoll);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_SerialPoll"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34980AStatus"), _T("get_SerialPoll"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980ASystem_WaitForOperationComplete(Agilent34980A* pT, long MaxTimeMilliseconds)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("WaitForOperationComplete"));
	NTL_METHOD_START(IAgilent34980ASystem, WaitForOperationComplete);
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("WaitForOperationComplete"), IN_PARAM(MaxTimeMilliseconds), NULL);

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

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ASystem_WaitForOperationComplete(MaxTimeMilliseconds);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ASystem_SetSystemTime(Agilent34980A* pT, long Hours, long Mins, double Seconds)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("SetSystemTime"));
	NTL_METHOD_START(IAgilent34980ASystem, SetSystemTime);
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("SetSystemTime"), IN_PARAM(Hours), IN_PARAM(Mins), IN_PARAM(Seconds), NULL);

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

	strCmd.Format(_T(":SYST:TIME  %d,%d,%.15g"), Hours, Mins, Seconds);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ASystem_SetSystemTime(Hours, Mins, Seconds);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ASystem_SetSystemDate(Agilent34980A* pT, long Year, long Month, long Day)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("SetSystemDate"));
	NTL_METHOD_START(IAgilent34980ASystem, SetSystemDate);
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("SetSystemDate"), IN_PARAM(Year), IN_PARAM(Month), IN_PARAM(Day), NULL);

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

	strCmd.Format(_T(":SYST:DATE %d,%d,%d"), Year, Month, Day);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ASystem_SetSystemDate(Year, Month, Day);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ASystem_Preset(Agilent34980A* pT)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("Preset"));
	NTL_METHOD_START(IAgilent34980ASystem, Preset);
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("Preset"), NULL);

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

	strCmd.Format(_T(":SYST:PRES"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ASystem_Preset();
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ASystem_GetSystemTime(Agilent34980A* pT, long* Hours, long* Mins, double* Seconds)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("GetSystemTime"));
	NTL_METHOD_START(IAgilent34980ASystem, GetSystemTime);
	if (Hours == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("GetSystemTime"), _T("Hours"));
	if (Mins == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("GetSystemTime"), _T("Mins"));
	if (Seconds == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("GetSystemTime"), _T("Seconds"));
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("GetSystemTime"), INOUT_PARAM(Hours), INOUT_PARAM(Mins), INOUT_PARAM(Seconds), NULL);

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

	strCmd.Format(_T("SYST:TIME?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ASystem_GetSystemTime(Hours, Mins, Seconds);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ASystem_GetSystemDate(Agilent34980A* pT, long* Year, long* Month, long* Day)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("GetSystemDate"));
	NTL_METHOD_START(IAgilent34980ASystem, GetSystemDate);
	if (Year == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("GetSystemDate"), _T("Year"));
	if (Month == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("GetSystemDate"), _T("Month"));
	if (Day == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("GetSystemDate"), _T("Day"));
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("GetSystemDate"), INOUT_PARAM(Year), INOUT_PARAM(Month), INOUT_PARAM(Day), NULL);

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

	strCmd.Format(_T(":SYST:DATE?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ASystem_GetSystemDate(Year, Month, Day);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ASystem_CardReset(Agilent34980A* pT, long SlotNum)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("CardReset"));
	NTL_METHOD_START(IAgilent34980ASystem, CardReset);
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("CardReset"), IN_PARAM(SlotNum), NULL);

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

	strCmd.Format(_T(":SYST:CPON %d"), SlotNum);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ASystem_CardReset(SlotNum);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ASystem_LockRequest(Agilent34980A* pT, VARIANT_BOOL* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("LockRequest"));
	NTL_METHOD_START(IAgilent34980ASystem, LockRequest);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("LockRequest"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("LockRequest"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("SYST:LOCK:REQ?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ASystem_LockRequest(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ASystem_LockRelease(Agilent34980A* pT)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("LockRelease"));
	NTL_METHOD_START(IAgilent34980ASystem, LockRelease);
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("LockRelease"), NULL);

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

	strCmd.Format(_T("SYST:LOCK:REL"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ASystem_LockRelease();
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ASystem_SecureImmediate(Agilent34980A* pT)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("SecureImmediate"));
	NTL_METHOD_START(IAgilent34980ASystem, SecureImmediate);
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("SecureImmediate"), NULL);

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

	strCmd.Format(_T("SYST:SEC:IMM"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ASystem_SecureImmediate();
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ASystem_GetModuleTemperature(Agilent34980A* pT, Agilent34980AModuleTemperatureEnum Mode, long Slot, double* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("GetModuleTemperature"));
	NTL_METHOD_START(IAgilent34980ASystem, GetModuleTemperature);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("GetModuleTemperature"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("GetModuleTemperature"), IN_PARAM(Mode), IN_PARAM(Slot), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("SYST:MOD:TEMP? %s, %d"), pT->EnumToString<Agilent34980AModuleTemperatureEnum>(Mode), Slot);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ASystem_GetModuleTemperature(Mode, Slot, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ASystem_get_AsyncEventsEnabled(Agilent34980A* pT, VARIANT_BOOL* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("get_AsyncEventsEnabled"));
	NTL_METHOD_START(IAgilent34980ASystem, get_AsyncEventsEnabled);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_AsyncEventsEnabled"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("get_AsyncEventsEnabled"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980ASystem_put_AsyncEventsEnabled(Agilent34980A* pT, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("put_AsyncEventsEnabled"));
	NTL_METHOD_START(IAgilent34980ASystem, put_AsyncEventsEnabled);
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("put_AsyncEventsEnabled"), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980ASystem_get_CardType(Agilent34980A* pT, long SlotNum, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("get_CardType"));
	NTL_METHOD_START(IAgilent34980ASystem, get_CardType);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_CardType"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("get_CardType"), IN_PARAM(SlotNum), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":SYST:CTYP? %d"), SlotNum);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ASystem_get_CardType(SlotNum, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ASystem_get_Date(Agilent34980A* pT, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("get_Date"));
	NTL_METHOD_START(IAgilent34980ASystem, get_Date);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Date"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("get_Date"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":SYST:DATE?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ASystem_get_Date(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ASystem_put_Date(Agilent34980A* pT, BSTR val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("put_Date"));
	NTL_METHOD_START(IAgilent34980ASystem, put_Date);
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("put_Date"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":SYST:DATE %s"), LPCTSTR(COLE2T(val)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ASystem_put_Date(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ASystem_get_DMMEnabled(Agilent34980A* pT, VARIANT_BOOL* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("get_DMMEnabled"));
	NTL_METHOD_START(IAgilent34980ASystem, get_DMMEnabled);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_DMMEnabled"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("get_DMMEnabled"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":INST:DMM?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ASystem_get_DMMEnabled(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ASystem_put_DMMEnabled(Agilent34980A* pT, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("put_DMMEnabled"));
	NTL_METHOD_START(IAgilent34980ASystem, put_DMMEnabled);
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("put_DMMEnabled"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":INST:DMM %s"), val == VARIANT_FALSE ? "0" : "1");
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ASystem_put_DMMEnabled(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ASystem_get_DMMInstalled(Agilent34980A* pT, VARIANT_BOOL* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("get_DMMInstalled"));
	NTL_METHOD_START(IAgilent34980ASystem, get_DMMInstalled);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_DMMInstalled"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("get_DMMInstalled"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":INST:DMM:INST?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ASystem_get_DMMInstalled(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ASystem_get_ReadingThreshold(Agilent34980A* pT, long* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("get_ReadingThreshold"));
	NTL_METHOD_START(IAgilent34980ASystem, get_ReadingThreshold);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ReadingThreshold"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("get_ReadingThreshold"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":DATA:POIN:EVEN:THR?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ASystem_get_ReadingThreshold(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ASystem_put_ReadingThreshold(Agilent34980A* pT, long val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("put_ReadingThreshold"));
	NTL_METHOD_START(IAgilent34980ASystem, put_ReadingThreshold);
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("put_ReadingThreshold"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":DATA:POIN:EVEN:THR %d"), val);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ASystem_put_ReadingThreshold(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ASystem_get_SerialNumber(Agilent34980A* pT, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("get_SerialNumber"));
	NTL_METHOD_START(IAgilent34980ASystem, get_SerialNumber);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_SerialNumber"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("get_SerialNumber"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980ASystem_get_Time(Agilent34980A* pT, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("get_Time"));
	NTL_METHOD_START(IAgilent34980ASystem, get_Time);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Time"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("get_Time"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":SYST:TIME?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ASystem_get_Time(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ASystem_put_Time(Agilent34980A* pT, BSTR val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("put_Time"));
	NTL_METHOD_START(IAgilent34980ASystem, put_Time);
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("put_Time"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":SYST:TIME %s"), LPCTSTR(COLE2T(val)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ASystem_put_Time(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ASystem_get_TimeoutMilliseconds(Agilent34980A* pT, long* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("get_TimeoutMilliseconds"));
	NTL_METHOD_START(IAgilent34980ASystem, get_TimeoutMilliseconds);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_TimeoutMilliseconds"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("get_TimeoutMilliseconds"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980ASystem_put_TimeoutMilliseconds(Agilent34980A* pT, long val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("put_TimeoutMilliseconds"));
	NTL_METHOD_START(IAgilent34980ASystem, put_TimeoutMilliseconds);
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("put_TimeoutMilliseconds"), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980ASystem_get_IO(Agilent34980A* pT, IFormattedIO488** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("get_IO"));
	NTL_METHOD_START(IAgilent34980ASystem, get_IO);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_IO"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("get_IO"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980ASystem_get_EnableInterface(Agilent34980A* pT, Agilent34980AHWInterfaceEnum HWInterface, VARIANT_BOOL* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("get_EnableInterface"));
	NTL_METHOD_START(IAgilent34980ASystem, get_EnableInterface);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_EnableInterface"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("get_EnableInterface"), IN_PARAM(HWInterface), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("SYST:COMM:ENAB? %s"), pT->EnumToString<Agilent34980AHWInterfaceEnum>(HWInterface));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ASystem_get_EnableInterface(HWInterface, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ASystem_put_EnableInterface(Agilent34980A* pT, Agilent34980AHWInterfaceEnum HWInterface, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("put_EnableInterface"));
	NTL_METHOD_START(IAgilent34980ASystem, put_EnableInterface);
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("put_EnableInterface"), IN_PARAM(HWInterface), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("SYST:COMM:ENAB %s, %s"), val == VARIANT_FALSE ? "0" : "1", pT->EnumToString<Agilent34980AHWInterfaceEnum>(HWInterface));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ASystem_put_EnableInterface(HWInterface, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ASystem_get_LockOwner(Agilent34980A* pT, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("get_LockOwner"));
	NTL_METHOD_START(IAgilent34980ASystem, get_LockOwner);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_LockOwner"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("get_LockOwner"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("SYST:LOCK:OWN?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ASystem_get_LockOwner(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ASystem_put_ModuleWireMode(Agilent34980A* pT, long SlotNumber, Agilent34980AWireModeEnum val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("put_ModuleWireMode"));
	NTL_METHOD_START(IAgilent34980ASystem, put_ModuleWireMode);
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("put_ModuleWireMode"), IN_PARAM(SlotNumber), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("SYST:MOD:WIRE:MODE %s, %d"), pT->EnumToString<Agilent34980AWireModeEnum>(val), SlotNumber);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ASystem_put_ModuleWireMode(SlotNumber, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ASystem_get_ModuleEvents(Agilent34980A* pT, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ASystem"), _T("get_ModuleEvents"));
	NTL_METHOD_START(IAgilent34980ASystem, get_ModuleEvents);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ModuleEvents"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980ASystem"), _T("get_ModuleEvents"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("SYST:MOD?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ASystem_get_ModuleEvents(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ATemperature_get_ReadingUnits(Agilent34980A* pT, BSTR ChannelList, Agilent34980ATemperatureUnitsEnum* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ATemperature"), _T("get_ReadingUnits"));
	NTL_METHOD_START(IAgilent34980ATemperature, get_ReadingUnits);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ReadingUnits"), _T("val"));
		*val = Agilent34980ATemperatureUnitsCelcius;
	CMethodTrace mt(pT, _T("IAgilent34980ATemperature"), _T("get_ReadingUnits"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980ATemperature_put_ReadingUnits(Agilent34980A* pT, BSTR ChannelList, Agilent34980ATemperatureUnitsEnum val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ATemperature"), _T("put_ReadingUnits"));
	NTL_METHOD_START(IAgilent34980ATemperature, put_ReadingUnits);
	CMethodTrace mt(pT, _T("IAgilent34980ATemperature"), _T("put_ReadingUnits"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":UNIT:TEMP %s, (@%s)"), pT->EnumToString<Agilent34980ATemperatureUnitsEnum>(val), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ATemperature_put_ReadingUnits(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ATemperature_get_FRTD(Agilent34980A* pT, IAgilent34980AFRTD** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ATemperature"), _T("get_FRTD"));
	NTL_METHOD_START(IAgilent34980ATemperature, get_FRTD);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_FRTD"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980ATemperature"), _T("get_FRTD"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980ATemperature_get_RTD(Agilent34980A* pT, IAgilent34980ARTD** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ATemperature"), _T("get_RTD"));
	NTL_METHOD_START(IAgilent34980ATemperature, get_RTD);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_RTD"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980ATemperature"), _T("get_RTD"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980ATemperature_get_Thermocouple(Agilent34980A* pT, IAgilent34980AThermocouple** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ATemperature"), _T("get_Thermocouple"));
	NTL_METHOD_START(IAgilent34980ATemperature, get_Thermocouple);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Thermocouple"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980ATemperature"), _T("get_Thermocouple"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980ATemperature_get_Thermistor(Agilent34980A* pT, IAgilent34980AThermistor** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ATemperature"), _T("get_Thermistor"));
	NTL_METHOD_START(IAgilent34980ATemperature, get_Thermistor);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Thermistor"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980ATemperature"), _T("get_Thermistor"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980ATemperature_get_AutoZero(Agilent34980A* pT, BSTR ChannelList, Agilent34980AAutoZeroEnum* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ATemperature"), _T("get_AutoZero"));
	NTL_METHOD_START(IAgilent34980ATemperature, get_AutoZero);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_AutoZero"), _T("val"));
		*val = Agilent34980AAutoZeroOFF;
	CMethodTrace mt(pT, _T("IAgilent34980ATemperature"), _T("get_AutoZero"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("TEMP:ZERO:AUTO?  (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ATemperature_get_AutoZero(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ATemperature_put_AutoZero(Agilent34980A* pT, BSTR ChannelList, Agilent34980AAutoZeroEnum val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ATemperature"), _T("put_AutoZero"));
	NTL_METHOD_START(IAgilent34980ATemperature, put_AutoZero);
	CMethodTrace mt(pT, _T("IAgilent34980ATemperature"), _T("put_AutoZero"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("TEMP:ZERO:AUTO %s, (@%s)"), pT->EnumToString<Agilent34980AAutoZeroEnum>(val), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ATemperature_put_AutoZero(ChannelList, val);
	pT->PopInstrCommand();

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

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

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

	return hr;
}
HRESULT IAgilent34980ATemperature_put_NPLC(Agilent34980A* pT, BSTR ChannelList, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ATemperature"), _T("put_NPLC"));
	NTL_METHOD_START(IAgilent34980ATemperature, put_NPLC);
	CMethodTrace mt(pT, _T("IAgilent34980ATemperature"), _T("put_NPLC"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980ATemperature_get_TransducerType(Agilent34980A* pT, BSTR ChannelList, Agilent34980ATransducerEnum* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ATemperature"), _T("get_TransducerType"));
	NTL_METHOD_START(IAgilent34980ATemperature, get_TransducerType);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_TransducerType"), _T("val"));
		*val = Agilent34980ATransducerTcouple;
	CMethodTrace mt(pT, _T("IAgilent34980ATemperature"), _T("get_TransducerType"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980ATemperature_put_TransducerType(Agilent34980A* pT, BSTR ChannelList, Agilent34980ATransducerEnum val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ATemperature"), _T("put_TransducerType"));
	NTL_METHOD_START(IAgilent34980ATemperature, put_TransducerType);
	CMethodTrace mt(pT, _T("IAgilent34980ATemperature"), _T("put_TransducerType"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980AVoltage_get_ACVoltage(Agilent34980A* pT, IAgilent34980AACVoltage** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AVoltage"), _T("get_ACVoltage"));
	NTL_METHOD_START(IAgilent34980AVoltage, get_ACVoltage);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ACVoltage"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980AVoltage"), _T("get_ACVoltage"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980AVoltage_get_DCVoltage(Agilent34980A* pT, IAgilent34980ADCVoltage** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AVoltage"), _T("get_DCVoltage"));
	NTL_METHOD_START(IAgilent34980AVoltage, get_DCVoltage);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_DCVoltage"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980AVoltage"), _T("get_DCVoltage"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980AFRTD_Configure(Agilent34980A* pT, BSTR ChannelList, Agilent34980AResolutionEnum Resolution, Agilent34980AFRTDAlphaEnum Type)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AFRTD"), _T("Configure"));
	NTL_METHOD_START(IAgilent34980AFRTD, Configure);
	CMethodTrace mt(pT, _T("IAgilent34980AFRTD"), _T("Configure"), IN_PARAM(ChannelList), IN_PARAM(Resolution), IN_PARAM(Type), NULL);

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

	strCmd.Format(_T("CONF:TEMP FRTD, %s, 1, %s, (@%s)"), pT->EnumToString<Agilent34980AFRTDAlphaEnum>(Type), pT->EnumToString<Agilent34980AResolutionEnum>(Resolution), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AFRTD_Configure(ChannelList, Resolution, Type);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AFRTD_Measure(Agilent34980A* pT, BSTR ChannelList, Agilent34980ARTDAlphaEnum Type, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AFRTD"), _T("Measure"));
	NTL_METHOD_START(IAgilent34980AFRTD, Measure);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("Measure"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980AFRTD"), _T("Measure"), IN_PARAM(ChannelList), IN_PARAM(Type), IN_PARAM(Resolution), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":MEAS:TEMP? FRTD, %s, 1, %s, (@%s)"), pT->EnumToString<Agilent34980ARTDAlphaEnum>(Type), pT->EnumToString<Agilent34980AResolutionEnum>(Resolution), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AFRTD_Measure(ChannelList, Type, Resolution, val);
	pT->PopInstrCommand();

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

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

	strCmd.Format(_T("TEMP:TRAN:FRTD:RES? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AFRTD_get_Resistance(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AFRTD_put_Resistance(Agilent34980A* pT, BSTR ChannelList, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AFRTD"), _T("put_Resistance"));
	NTL_METHOD_START(IAgilent34980AFRTD, put_Resistance);
	CMethodTrace mt(pT, _T("IAgilent34980AFRTD"), _T("put_Resistance"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("TEMP:TRAN:FRTD:RES %.15g, (@%s)"), val, LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AFRTD_put_Resistance(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AFRTD_get_Alpha(Agilent34980A* pT, BSTR ChannelList, Agilent34980AFRTDAlphaEnum* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AFRTD"), _T("get_Alpha"));
	NTL_METHOD_START(IAgilent34980AFRTD, get_Alpha);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Alpha"), _T("val"));
		*val = Agilent34980AFRTDAlpha85;
	CMethodTrace mt(pT, _T("IAgilent34980AFRTD"), _T("get_Alpha"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980AFRTD_put_Alpha(Agilent34980A* pT, BSTR ChannelList, Agilent34980AFRTDAlphaEnum val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AFRTD"), _T("put_Alpha"));
	NTL_METHOD_START(IAgilent34980AFRTD, put_Alpha);
	CMethodTrace mt(pT, _T("IAgilent34980AFRTD"), _T("put_Alpha"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("TEMP:TRAN:FRTD:TYPE %s, (@%s)"), pT->EnumToString<Agilent34980AFRTDAlphaEnum>(val), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AFRTD_put_Alpha(ChannelList, val);
	pT->PopInstrCommand();

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

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

	strCmd.Format(_T("TEMP:TRAN:FRTD:REF? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AFRTD_get_IsExternalReference(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AFRTD_put_IsExternalReference(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AFRTD"), _T("put_IsExternalReference"));
	NTL_METHOD_START(IAgilent34980AFRTD, put_IsExternalReference);
	CMethodTrace mt(pT, _T("IAgilent34980AFRTD"), _T("put_IsExternalReference"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("TEMP:TRAN:FRTD:REF %s, (@%s)"), val == VARIANT_FALSE ? "0" : "1", LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AFRTD_put_IsExternalReference(ChannelList, val);
	pT->PopInstrCommand();

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

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

	strCmd.Format(_T("TEMP:TRAN:FRTD:OCOM? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AFRTD_get_OCompensated(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AFRTD_put_OCompensated(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AFRTD"), _T("put_OCompensated"));
	NTL_METHOD_START(IAgilent34980AFRTD, put_OCompensated);
	CMethodTrace mt(pT, _T("IAgilent34980AFRTD"), _T("put_OCompensated"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("TEMP:TRAN:FRTD:OCOM %s, (@%s)"), val == VARIANT_FALSE ? "0" : "1", LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AFRTD_put_OCompensated(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADataFormat_Configure(Agilent34980A* pT, VARIANT_BOOL EnableAlarm, VARIANT_BOOL EnableChannel, VARIANT_BOOL EnableTime, Agilent34980ATimeOffsetEnum TimeType, VARIANT_BOOL EnableUnit)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADataFormat"), _T("Configure"));
	NTL_METHOD_START(IAgilent34980ADataFormat, Configure);
	CMethodTrace mt(pT, _T("IAgilent34980ADataFormat"), _T("Configure"), IN_PARAM(EnableAlarm), IN_PARAM(EnableChannel), IN_PARAM(EnableTime), IN_PARAM(TimeType), IN_PARAM(EnableUnit), NULL);

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

	strCmd.Format(_T(":FORM:READ:ALAR %s; :FORM:READ:CHAN %s; :FORM:READ:TIME %s; :FORM:READ:TIME:TYPE %s; :FORM:READ:UNIT %s"), EnableAlarm == VARIANT_FALSE ? "0" : "1", EnableChannel == VARIANT_FALSE ? "0" : "1", EnableTime == VARIANT_FALSE ? "0" : "1", pT->EnumToString<Agilent34980ATimeOffsetEnum>(TimeType), EnableUnit == VARIANT_FALSE ? "0" : "1");
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADataFormat_Configure(EnableAlarm, EnableChannel, EnableTime, TimeType, EnableUnit);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADataFormat_get_AlarmEnable(Agilent34980A* pT, VARIANT_BOOL* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADataFormat"), _T("get_AlarmEnable"));
	NTL_METHOD_START(IAgilent34980ADataFormat, get_AlarmEnable);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_AlarmEnable"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IAgilent34980ADataFormat"), _T("get_AlarmEnable"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":FORM:READ:ALAR?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADataFormat_get_AlarmEnable(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADataFormat_put_AlarmEnable(Agilent34980A* pT, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADataFormat"), _T("put_AlarmEnable"));
	NTL_METHOD_START(IAgilent34980ADataFormat, put_AlarmEnable);
	CMethodTrace mt(pT, _T("IAgilent34980ADataFormat"), _T("put_AlarmEnable"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":FORM:READ:ALAR %s"), val == VARIANT_FALSE ? "0" : "1");
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADataFormat_put_AlarmEnable(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADataFormat_get_ChannelEnable(Agilent34980A* pT, VARIANT_BOOL* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADataFormat"), _T("get_ChannelEnable"));
	NTL_METHOD_START(IAgilent34980ADataFormat, get_ChannelEnable);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ChannelEnable"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IAgilent34980ADataFormat"), _T("get_ChannelEnable"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":FORM:READ:CHAN?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADataFormat_get_ChannelEnable(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADataFormat_put_ChannelEnable(Agilent34980A* pT, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADataFormat"), _T("put_ChannelEnable"));
	NTL_METHOD_START(IAgilent34980ADataFormat, put_ChannelEnable);
	CMethodTrace mt(pT, _T("IAgilent34980ADataFormat"), _T("put_ChannelEnable"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":FORM:READ:CHAN %s"), val == VARIANT_FALSE ? "0" : "1");
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADataFormat_put_ChannelEnable(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADataFormat_get_TimeEnable(Agilent34980A* pT, VARIANT_BOOL* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADataFormat"), _T("get_TimeEnable"));
	NTL_METHOD_START(IAgilent34980ADataFormat, get_TimeEnable);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_TimeEnable"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IAgilent34980ADataFormat"), _T("get_TimeEnable"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":FORM:READ:TIME?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADataFormat_get_TimeEnable(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADataFormat_put_TimeEnable(Agilent34980A* pT, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADataFormat"), _T("put_TimeEnable"));
	NTL_METHOD_START(IAgilent34980ADataFormat, put_TimeEnable);
	CMethodTrace mt(pT, _T("IAgilent34980ADataFormat"), _T("put_TimeEnable"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":FORM:READ:TIME %s"), val == VARIANT_FALSE ? "0" : "1");
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADataFormat_put_TimeEnable(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADataFormat_get_TimeType(Agilent34980A* pT, Agilent34980ATimeOffsetEnum* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADataFormat"), _T("get_TimeType"));
	NTL_METHOD_START(IAgilent34980ADataFormat, get_TimeType);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_TimeType"), _T("val"));
		*val = Agilent34980ATimeOffsetAbsolute;
	CMethodTrace mt(pT, _T("IAgilent34980ADataFormat"), _T("get_TimeType"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":FORM:READ:TIME:TYPE?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADataFormat_get_TimeType(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADataFormat_put_TimeType(Agilent34980A* pT, Agilent34980ATimeOffsetEnum val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADataFormat"), _T("put_TimeType"));
	NTL_METHOD_START(IAgilent34980ADataFormat, put_TimeType);
	CMethodTrace mt(pT, _T("IAgilent34980ADataFormat"), _T("put_TimeType"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":FORM:READ:TIME:TYPE %s"), pT->EnumToString<Agilent34980ATimeOffsetEnum>(val));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADataFormat_put_TimeType(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADataFormat_get_UnitEnable(Agilent34980A* pT, VARIANT_BOOL* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADataFormat"), _T("get_UnitEnable"));
	NTL_METHOD_START(IAgilent34980ADataFormat, get_UnitEnable);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_UnitEnable"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IAgilent34980ADataFormat"), _T("get_UnitEnable"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":FORM:READ:UNIT?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADataFormat_get_UnitEnable(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADataFormat_put_UnitEnable(Agilent34980A* pT, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADataFormat"), _T("put_UnitEnable"));
	NTL_METHOD_START(IAgilent34980ADataFormat, put_UnitEnable);
	CMethodTrace mt(pT, _T("IAgilent34980ADataFormat"), _T("put_UnitEnable"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":FORM:READ:UNIT %s"), val == VARIANT_FALSE ? "0" : "1");
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADataFormat_put_UnitEnable(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ARTD_Configure(Agilent34980A* pT, BSTR ChannelList, Agilent34980AResolutionEnum Resolution, Agilent34980ARTDAlphaEnum Type)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ARTD"), _T("Configure"));
	NTL_METHOD_START(IAgilent34980ARTD, Configure);
	CMethodTrace mt(pT, _T("IAgilent34980ARTD"), _T("Configure"), IN_PARAM(ChannelList), IN_PARAM(Resolution), IN_PARAM(Type), NULL);

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

	strCmd.Format(_T("CONF:TEMP RTD, %s, 1, %s, (@%s)"), pT->EnumToString<Agilent34980ARTDAlphaEnum>(Type), pT->EnumToString<Agilent34980AResolutionEnum>(Resolution), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ARTD_Configure(ChannelList, Resolution, Type);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ARTD_Measure(Agilent34980A* pT, BSTR ChannelList, Agilent34980ARTDAlphaEnum Type, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ARTD"), _T("Measure"));
	NTL_METHOD_START(IAgilent34980ARTD, Measure);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("Measure"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980ARTD"), _T("Measure"), IN_PARAM(ChannelList), IN_PARAM(Type), IN_PARAM(Resolution), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":MEAS:TEMP? RTD, %s, 1, %s, (@%s)"), pT->EnumToString<Agilent34980ARTDAlphaEnum>(Type), pT->EnumToString<Agilent34980AResolutionEnum>(Resolution), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ARTD_Measure(ChannelList, Type, Resolution, val);
	pT->PopInstrCommand();

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

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

	strCmd.Format(_T("TEMP:TRAN:RTD:RES? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ARTD_get_Resistance(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ARTD_put_Resistance(Agilent34980A* pT, BSTR ChannelList, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ARTD"), _T("put_Resistance"));
	NTL_METHOD_START(IAgilent34980ARTD, put_Resistance);
	CMethodTrace mt(pT, _T("IAgilent34980ARTD"), _T("put_Resistance"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("TEMP:TRAN:RTD:RES %.15g, (@%s)"), val, LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ARTD_put_Resistance(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ARTD_get_Alpha(Agilent34980A* pT, BSTR ChannelList, Agilent34980ARTDAlphaEnum* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ARTD"), _T("get_Alpha"));
	NTL_METHOD_START(IAgilent34980ARTD, get_Alpha);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Alpha"), _T("val"));
		*val = Agilent34980ARTDAlpha85;
	CMethodTrace mt(pT, _T("IAgilent34980ARTD"), _T("get_Alpha"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980ARTD_put_Alpha(Agilent34980A* pT, BSTR ChannelList, Agilent34980ARTDAlphaEnum val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ARTD"), _T("put_Alpha"));
	NTL_METHOD_START(IAgilent34980ARTD, put_Alpha);
	CMethodTrace mt(pT, _T("IAgilent34980ARTD"), _T("put_Alpha"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("TEMP:TRAN:RTD:TYPE %s, (@%s)"), pT->EnumToString<Agilent34980ARTDAlphaEnum>(val), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ARTD_put_Alpha(ChannelList, val);
	pT->PopInstrCommand();

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

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

	strCmd.Format(_T("TEMP:TRAN:RTD:REF? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ARTD_get_IsExternalReference(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ARTD_put_IsExternalReference(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ARTD"), _T("put_IsExternalReference"));
	NTL_METHOD_START(IAgilent34980ARTD, put_IsExternalReference);
	CMethodTrace mt(pT, _T("IAgilent34980ARTD"), _T("put_IsExternalReference"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("TEMP:TRAN:RTD:REF %s, (@%s)"), val == VARIANT_FALSE ? "0" : "1", LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ARTD_put_IsExternalReference(ChannelList, val);
	pT->PopInstrCommand();

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

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

	strCmd.Format(_T("TEMP:TRAN:RTD:OCOM? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ARTD_get_OCompensated(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ARTD_put_OCompensated(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ARTD"), _T("put_OCompensated"));
	NTL_METHOD_START(IAgilent34980ARTD, put_OCompensated);
	CMethodTrace mt(pT, _T("IAgilent34980ARTD"), _T("put_OCompensated"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("TEMP:TRAN:RTD:OCOM %s, (@%s)"), val == VARIANT_FALSE ? "0" : "1", LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ARTD_put_OCompensated(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AThermistor_Configure(Agilent34980A* pT, BSTR ChannelList, Agilent34980AResolutionEnum Resolution, Agilent34980AThermistorEnum Type)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AThermistor"), _T("Configure"));
	NTL_METHOD_START(IAgilent34980AThermistor, Configure);
	CMethodTrace mt(pT, _T("IAgilent34980AThermistor"), _T("Configure"), IN_PARAM(ChannelList), IN_PARAM(Resolution), IN_PARAM(Type), NULL);

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

	strCmd.Format(_T("CONF:TEMP THER, %s, 1, %s, (@%s)"), pT->EnumToString<Agilent34980AThermistorEnum>(Type), pT->EnumToString<Agilent34980AResolutionEnum>(Resolution), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AThermistor_Configure(ChannelList, Resolution, Type);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AThermistor_Measure(Agilent34980A* pT, BSTR ChannelList, Agilent34980AThermistorEnum Type, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AThermistor"), _T("Measure"));
	NTL_METHOD_START(IAgilent34980AThermistor, Measure);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("Measure"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980AThermistor"), _T("Measure"), IN_PARAM(ChannelList), IN_PARAM(Type), IN_PARAM(Resolution), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":MEAS:TEMP? THER, %s, 1, %s, (@%s)"), pT->EnumToString<Agilent34980AThermistorEnum>(Type), pT->EnumToString<Agilent34980AResolutionEnum>(Resolution), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AThermistor_Measure(ChannelList, Type, Resolution, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AThermistor_get_Resistance(Agilent34980A* pT, BSTR ChannelList, Agilent34980AThermistorEnum* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AThermistor"), _T("get_Resistance"));
	NTL_METHOD_START(IAgilent34980AThermistor, get_Resistance);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Resistance"), _T("val"));
		*val = Agilent34980AThermistor2252;
	CMethodTrace mt(pT, _T("IAgilent34980AThermistor"), _T("get_Resistance"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980AThermistor_put_Resistance(Agilent34980A* pT, BSTR ChannelList, Agilent34980AThermistorEnum val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AThermistor"), _T("put_Resistance"));
	NTL_METHOD_START(IAgilent34980AThermistor, put_Resistance);
	CMethodTrace mt(pT, _T("IAgilent34980AThermistor"), _T("put_Resistance"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("TEMP:TRAN:THER:TYPE %s, (@%s)"), pT->EnumToString<Agilent34980AThermistorEnum>(val), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AThermistor_put_Resistance(ChannelList, val);
	pT->PopInstrCommand();

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

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

	strCmd.Format(_T("TEMP:TRAN:THER:REF? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AThermistor_get_IsExternalReference(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AThermistor_put_IsExternalReference(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AThermistor"), _T("put_IsExternalReference"));
	NTL_METHOD_START(IAgilent34980AThermistor, put_IsExternalReference);
	CMethodTrace mt(pT, _T("IAgilent34980AThermistor"), _T("put_IsExternalReference"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("TEMP:TRAN:THER:REF %s, (@%s)"), val == VARIANT_FALSE ? "0" : "1", LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AThermistor_put_IsExternalReference(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AThermocouple_Configure(Agilent34980A* pT, BSTR ChannelList, Agilent34980AResolutionEnum Resolution, Agilent34980AThermocoupleEnum Type)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AThermocouple"), _T("Configure"));
	NTL_METHOD_START(IAgilent34980AThermocouple, Configure);
	CMethodTrace mt(pT, _T("IAgilent34980AThermocouple"), _T("Configure"), IN_PARAM(ChannelList), IN_PARAM(Resolution), IN_PARAM(Type), NULL);

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

	strCmd.Format(_T("CONF:TEMP TC, %s, 1, %s, (@%s)"), pT->EnumToString<Agilent34980AThermocoupleEnum>(Type), pT->EnumToString<Agilent34980AResolutionEnum>(Resolution), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AThermocouple_Configure(ChannelList, Resolution, Type);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AThermocouple_Measure(Agilent34980A* pT, BSTR ChannelList, Agilent34980AThermocoupleEnum Type, Agilent34980AResolutionEnum Resolution, SAFEARRAY** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AThermocouple"), _T("Measure"));
	NTL_METHOD_START(IAgilent34980AThermocouple, Measure);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("Measure"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980AThermocouple"), _T("Measure"), IN_PARAM(ChannelList), IN_PARAM(Type), IN_PARAM(Resolution), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":MEAS:TEMP? TC, %s, 1, %s, (@%s)"), pT->EnumToString<Agilent34980AThermocoupleEnum>(Type), pT->EnumToString<Agilent34980AResolutionEnum>(Resolution), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AThermocouple_Measure(ChannelList, Type, Resolution, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AThermocouple_get_ThermocoupleType(Agilent34980A* pT, BSTR ChannelList, Agilent34980AThermocoupleEnum* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AThermocouple"), _T("get_ThermocoupleType"));
	NTL_METHOD_START(IAgilent34980AThermocouple, get_ThermocoupleType);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ThermocoupleType"), _T("val"));
		*val = Agilent34980AThermocoupleBType;
	CMethodTrace mt(pT, _T("IAgilent34980AThermocouple"), _T("get_ThermocoupleType"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980AThermocouple_put_ThermocoupleType(Agilent34980A* pT, BSTR ChannelList, Agilent34980AThermocoupleEnum val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AThermocouple"), _T("put_ThermocoupleType"));
	NTL_METHOD_START(IAgilent34980AThermocouple, put_ThermocoupleType);
	CMethodTrace mt(pT, _T("IAgilent34980AThermocouple"), _T("put_ThermocoupleType"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("TEMP:TRAN:TC:TYPE %s, (@%s)"), pT->EnumToString<Agilent34980AThermocoupleEnum>(val), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AThermocouple_put_ThermocoupleType(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AThermocouple_get_ReferenceJunctionType(Agilent34980A* pT, BSTR ChannelList, Agilent34980ARJunctionEnum* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AThermocouple"), _T("get_ReferenceJunctionType"));
	NTL_METHOD_START(IAgilent34980AThermocouple, get_ReferenceJunctionType);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ReferenceJunctionType"), _T("val"));
		*val = Agilent34980ARJunctionInternal;
	CMethodTrace mt(pT, _T("IAgilent34980AThermocouple"), _T("get_ReferenceJunctionType"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980AThermocouple_put_ReferenceJunctionType(Agilent34980A* pT, BSTR ChannelList, Agilent34980ARJunctionEnum val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AThermocouple"), _T("put_ReferenceJunctionType"));
	NTL_METHOD_START(IAgilent34980AThermocouple, put_ReferenceJunctionType);
	CMethodTrace mt(pT, _T("IAgilent34980AThermocouple"), _T("put_ReferenceJunctionType"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("TEMP:TRAN:TC:RJUN:TYPE %s, (@%s)"), pT->EnumToString<Agilent34980ARJunctionEnum>(val), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AThermocouple_put_ReferenceJunctionType(ChannelList, val);
	pT->PopInstrCommand();

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

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

	strCmd.Format(_T(":TEMP:TRAN:TC:RJUN? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AThermocouple_get_FixedReferenceJunction(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AThermocouple_put_FixedReferenceJunction(Agilent34980A* pT, BSTR ChannelList, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AThermocouple"), _T("put_FixedReferenceJunction"));
	NTL_METHOD_START(IAgilent34980AThermocouple, put_FixedReferenceJunction);
	CMethodTrace mt(pT, _T("IAgilent34980AThermocouple"), _T("put_FixedReferenceJunction"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":TEMP:TRAN:TC:RJUN %.15g, (@%s)"), val, LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AThermocouple_put_FixedReferenceJunction(ChannelList, val);
	pT->PopInstrCommand();

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

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

	strCmd.Format(_T(":TEMP:TRAN:TC:CHEC? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AThermocouple_get_Check(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AThermocouple_put_Check(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AThermocouple"), _T("put_Check"));
	NTL_METHOD_START(IAgilent34980AThermocouple, put_Check);
	CMethodTrace mt(pT, _T("IAgilent34980AThermocouple"), _T("put_Check"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":TEMP:TRAN:TC:CHEC %s, (@%s)"), val == VARIANT_FALSE ? "0" : "1", LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AThermocouple_put_Check(ChannelList, val);
	pT->PopInstrCommand();

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

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

	strCmd.Format(_T(":TEMP:TRAN:TC:IMP:AUTO? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AThermocouple_get_AutoImpedance(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AThermocouple_put_AutoImpedance(Agilent34980A* pT, BSTR ChannelList, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AThermocouple"), _T("put_AutoImpedance"));
	NTL_METHOD_START(IAgilent34980AThermocouple, put_AutoImpedance);
	CMethodTrace mt(pT, _T("IAgilent34980AThermocouple"), _T("put_AutoImpedance"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":TEMP:TRAN:TC:IMP:AUTO %s, (@%s)"), val == VARIANT_FALSE ? "0" : "1", LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AThermocouple_put_AutoImpedance(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AThermocouple_get_ExternalReferenceJunction(Agilent34980A* pT, double* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AThermocouple"), _T("get_ExternalReferenceJunction"));
	NTL_METHOD_START(IAgilent34980AThermocouple, get_ExternalReferenceJunction);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ExternalReferenceJunction"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IAgilent34980AThermocouple"), _T("get_ExternalReferenceJunction"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("TEMP:TRAN:TC:RJUN:EXT?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AThermocouple_get_ExternalReferenceJunction(val);
	pT->PopInstrCommand();

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

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

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

	return hr;
}
HRESULT IAgilent34980ATrigger_Configure(Agilent34980A* pT, Agilent34980ATriggerSourceEnum Source, long TriggerCount, double Timer, long SampleCount)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ATrigger"), _T("Configure"));
	NTL_METHOD_START(IAgilent34980ATrigger, Configure);
	CMethodTrace mt(pT, _T("IAgilent34980ATrigger"), _T("Configure"), IN_PARAM(Source), IN_PARAM(TriggerCount), IN_PARAM(Timer), IN_PARAM(SampleCount), NULL);

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

	strCmd.Format(_T(":TRIG:SOUR %s; COUN %d;TIM %.15g; :SAMP:COUN %d"), pT->EnumToString<Agilent34980ATriggerSourceEnum>(Source), TriggerCount, Timer, SampleCount);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ATrigger_Configure(Source, TriggerCount, Timer, SampleCount);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ATrigger_get_SampleCount(Agilent34980A* pT, long* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ATrigger"), _T("get_SampleCount"));
	NTL_METHOD_START(IAgilent34980ATrigger, get_SampleCount);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_SampleCount"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34980ATrigger"), _T("get_SampleCount"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":SAMP:COUN?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ATrigger_get_SampleCount(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ATrigger_put_SampleCount(Agilent34980A* pT, long val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ATrigger"), _T("put_SampleCount"));
	NTL_METHOD_START(IAgilent34980ATrigger, put_SampleCount);
	CMethodTrace mt(pT, _T("IAgilent34980ATrigger"), _T("put_SampleCount"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":SAMP:COUN %d"), val);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ATrigger_put_SampleCount(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ATrigger_get_Count(Agilent34980A* pT, long* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ATrigger"), _T("get_Count"));
	NTL_METHOD_START(IAgilent34980ATrigger, get_Count);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Count"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34980ATrigger"), _T("get_Count"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":TRIG:COUN?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ATrigger_get_Count(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ATrigger_put_Count(Agilent34980A* pT, long val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ATrigger"), _T("put_Count"));
	NTL_METHOD_START(IAgilent34980ATrigger, put_Count);
	CMethodTrace mt(pT, _T("IAgilent34980ATrigger"), _T("put_Count"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":TRIG:COUN %d"), val);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ATrigger_put_Count(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ATrigger_get_Source(Agilent34980A* pT, Agilent34980ATriggerSourceEnum* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ATrigger"), _T("get_Source"));
	NTL_METHOD_START(IAgilent34980ATrigger, get_Source);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Source"), _T("val"));
		*val = Agilent34980ATriggerSourceBus;
	CMethodTrace mt(pT, _T("IAgilent34980ATrigger"), _T("get_Source"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":TRIG:SOUR?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ATrigger_get_Source(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ATrigger_put_Source(Agilent34980A* pT, Agilent34980ATriggerSourceEnum val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ATrigger"), _T("put_Source"));
	NTL_METHOD_START(IAgilent34980ATrigger, put_Source);
	CMethodTrace mt(pT, _T("IAgilent34980ATrigger"), _T("put_Source"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":TRIG:SOUR %s"), pT->EnumToString<Agilent34980ATriggerSourceEnum>(val));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ATrigger_put_Source(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ATrigger_get_Timer(Agilent34980A* pT, double* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ATrigger"), _T("get_Timer"));
	NTL_METHOD_START(IAgilent34980ATrigger, get_Timer);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Timer"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IAgilent34980ATrigger"), _T("get_Timer"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":TRIG:TIM?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ATrigger_get_Timer(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ATrigger_put_Timer(Agilent34980A* pT, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ATrigger"), _T("put_Timer"));
	NTL_METHOD_START(IAgilent34980ATrigger, put_Timer);
	CMethodTrace mt(pT, _T("IAgilent34980ATrigger"), _T("put_Timer"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":TRIG:TIM %.15g"), val);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ATrigger_put_Timer(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ATrigger_get_Delay(Agilent34980A* pT, double* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ATrigger"), _T("get_Delay"));
	NTL_METHOD_START(IAgilent34980ATrigger, get_Delay);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Delay"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IAgilent34980ATrigger"), _T("get_Delay"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("TRIG:DEL?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ATrigger_get_Delay(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ATrigger_put_Delay(Agilent34980A* pT, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ATrigger"), _T("put_Delay"));
	NTL_METHOD_START(IAgilent34980ATrigger, put_Delay);
	CMethodTrace mt(pT, _T("IAgilent34980ATrigger"), _T("put_Delay"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("TRIG:DEL %.15g"), val);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ATrigger_put_Delay(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ATrigger_get_DelayAuto(Agilent34980A* pT, VARIANT_BOOL* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ATrigger"), _T("get_DelayAuto"));
	NTL_METHOD_START(IAgilent34980ATrigger, get_DelayAuto);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_DelayAuto"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IAgilent34980ATrigger"), _T("get_DelayAuto"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T("TRIG:DEL:AUTO?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ATrigger_get_DelayAuto(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ATrigger_put_DelayAuto(Agilent34980A* pT, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ATrigger"), _T("put_DelayAuto"));
	NTL_METHOD_START(IAgilent34980ATrigger, put_DelayAuto);
	CMethodTrace mt(pT, _T("IAgilent34980ATrigger"), _T("put_DelayAuto"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T("TRIG:DEL:AUTO %s"), val == VARIANT_FALSE ? "0" : "1");
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ATrigger_put_DelayAuto(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviSwtch_get_Channels(Agilent34980A* pT, IIviSwtchChannels** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtch"), _T("get_Channels"));
	NTL_METHOD_START(IIviSwtch, get_Channels);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Channels"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviSwtch"), _T("get_Channels"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviSwtch_get_Path(Agilent34980A* pT, IIviSwtchPath** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtch"), _T("get_Path"));
	NTL_METHOD_START(IIviSwtch, get_Path);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Path"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviSwtch"), _T("get_Path"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviSwtch_get_Scan(Agilent34980A* pT, IIviSwtchScan** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtch"), _T("get_Scan"));
	NTL_METHOD_START(IIviSwtch, get_Scan);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Scan"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviSwtch"), _T("get_Scan"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviSwtchChannels_get_Item(Agilent34980A* pT, BSTR Name, IIviSwtchChannel** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchChannels"), _T("get_Item"));
	NTL_METHOD_START(IIviSwtchChannels, get_Item);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Item"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviSwtchChannels"), _T("get_Item"), IN_PARAM(Name), OUT_PARAM(val), NULL);

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

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviSwtchChannels_get_Item(Name, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviSwtchChannels_get_Count(Agilent34980A* pT, long* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchChannels"), _T("get_Count"));
	NTL_METHOD_START(IIviSwtchChannels, get_Count);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Count"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IIviSwtchChannels"), _T("get_Count"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviSwtchChannels_get_Name(Agilent34980A* pT, long Index, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchChannels"), _T("get_Name"));
	NTL_METHOD_START(IIviSwtchChannels, get_Name);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Name"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviSwtchChannels"), _T("get_Name"), IN_PARAM(Index), OUT_PARAM(val), NULL);

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

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviSwtchChannels_get_Name(Index, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviSwtchPath_WaitForDebounce(Agilent34980A* pT, long MaxTimeMilliseconds)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchPath"), _T("WaitForDebounce"));
	NTL_METHOD_START(IIviSwtchPath, WaitForDebounce);
	CMethodTrace mt(pT, _T("IIviSwtchPath"), _T("WaitForDebounce"), IN_PARAM(MaxTimeMilliseconds), NULL);

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

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviSwtchPath_WaitForDebounce(MaxTimeMilliseconds);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviSwtchPath_SetPath(Agilent34980A* pT, BSTR PathList)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchPath"), _T("SetPath"));
	NTL_METHOD_START(IIviSwtchPath, SetPath);
	CMethodTrace mt(pT, _T("IIviSwtchPath"), _T("SetPath"), IN_PARAM(PathList), NULL);

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

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviSwtchPath_SetPath(PathList);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviSwtchPath_GetPath(Agilent34980A* pT, BSTR Channel1, BSTR Channel2, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchPath"), _T("GetPath"));
	NTL_METHOD_START(IIviSwtchPath, GetPath);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("GetPath"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviSwtchPath"), _T("GetPath"), IN_PARAM(Channel1), IN_PARAM(Channel2), OUT_PARAM(val), NULL);

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

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviSwtchPath_GetPath(Channel1, Channel2, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviSwtchPath_DisconnectAll(Agilent34980A* pT)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchPath"), _T("DisconnectAll"));
	NTL_METHOD_START(IIviSwtchPath, DisconnectAll);
	CMethodTrace mt(pT, _T("IIviSwtchPath"), _T("DisconnectAll"), NULL);

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

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

	return hr;
}
HRESULT IIviSwtchPath_Disconnect(Agilent34980A* pT, BSTR Channel1, BSTR Channel2)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchPath"), _T("Disconnect"));
	NTL_METHOD_START(IIviSwtchPath, Disconnect);
	CMethodTrace mt(pT, _T("IIviSwtchPath"), _T("Disconnect"), IN_PARAM(Channel1), IN_PARAM(Channel2), NULL);

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

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviSwtchPath_Disconnect(Channel1, Channel2);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviSwtchPath_Connect(Agilent34980A* pT, BSTR Channel1, BSTR Channel2)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchPath"), _T("Connect"));
	NTL_METHOD_START(IIviSwtchPath, Connect);
	CMethodTrace mt(pT, _T("IIviSwtchPath"), _T("Connect"), IN_PARAM(Channel1), IN_PARAM(Channel2), NULL);

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

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviSwtchPath_Connect(Channel1, Channel2);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviSwtchPath_CanConnect(Agilent34980A* pT, BSTR Channel1, BSTR Channel2, IviSwtchPathCapabilityEnum* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchPath"), _T("CanConnect"));
	NTL_METHOD_START(IIviSwtchPath, CanConnect);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("CanConnect"), _T("val"));
		*val = IviSwtchPathAvailable;
	CMethodTrace mt(pT, _T("IIviSwtchPath"), _T("CanConnect"), IN_PARAM(Channel1), IN_PARAM(Channel2), OUT_PARAM(val), NULL);

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

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviSwtchPath_CanConnect(Channel1, Channel2, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviSwtchPath_get_IsDebounced(Agilent34980A* pT, VARIANT_BOOL* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchPath"), _T("get_IsDebounced"));
	NTL_METHOD_START(IIviSwtchPath, get_IsDebounced);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_IsDebounced"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IIviSwtchPath"), _T("get_IsDebounced"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviSwtchScan_WaitForScanComplete(Agilent34980A* pT, long MaxTimeMilliseconds)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchScan"), _T("WaitForScanComplete"));
	NTL_METHOD_START(IIviSwtchScan, WaitForScanComplete);
	CMethodTrace mt(pT, _T("IIviSwtchScan"), _T("WaitForScanComplete"), IN_PARAM(MaxTimeMilliseconds), NULL);

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

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviSwtchScan_WaitForScanComplete(MaxTimeMilliseconds);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviSwtchScan_SendSoftwareTrigger(Agilent34980A* pT)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchScan"), _T("SendSoftwareTrigger"));
	NTL_METHOD_START(IIviSwtchScan, SendSoftwareTrigger);
	CMethodTrace mt(pT, _T("IIviSwtchScan"), _T("SendSoftwareTrigger"), NULL);

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

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

	return hr;
}
HRESULT IIviSwtchScan_Abort(Agilent34980A* pT)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchScan"), _T("Abort"));
	NTL_METHOD_START(IIviSwtchScan, Abort);
	CMethodTrace mt(pT, _T("IIviSwtchScan"), _T("Abort"), NULL);

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

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

	return hr;
}
HRESULT IIviSwtchScan_Initiate(Agilent34980A* pT)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchScan"), _T("Initiate"));
	NTL_METHOD_START(IIviSwtchScan, Initiate);
	CMethodTrace mt(pT, _T("IIviSwtchScan"), _T("Initiate"), NULL);

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

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

	return hr;
}
HRESULT IIviSwtchScan_ConfigureTrigger(Agilent34980A* pT, double ScanDelay, IviSwtchTriggerInputEnum TriggerInput, IviSwtchAdvancedOutputEnum AdvancedOutput)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchScan"), _T("ConfigureTrigger"));
	NTL_METHOD_START(IIviSwtchScan, ConfigureTrigger);
	CMethodTrace mt(pT, _T("IIviSwtchScan"), _T("ConfigureTrigger"), IN_PARAM(ScanDelay), IN_PARAM(TriggerInput), IN_PARAM(AdvancedOutput), NULL);

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

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviSwtchScan_ConfigureTrigger(ScanDelay, TriggerInput, AdvancedOutput);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviSwtchScan_ConfigureList(Agilent34980A* pT, BSTR List, IviSwtchScanModeEnum Mode)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchScan"), _T("ConfigureList"));
	NTL_METHOD_START(IIviSwtchScan, ConfigureList);
	CMethodTrace mt(pT, _T("IIviSwtchScan"), _T("ConfigureList"), IN_PARAM(List), IN_PARAM(Mode), NULL);

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

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviSwtchScan_ConfigureList(List, Mode);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviSwtchScan_get_IsScanning(Agilent34980A* pT, VARIANT_BOOL* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchScan"), _T("get_IsScanning"));
	NTL_METHOD_START(IIviSwtchScan, get_IsScanning);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_IsScanning"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IIviSwtchScan"), _T("get_IsScanning"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviSwtchScan_get_Continuous(Agilent34980A* pT, VARIANT_BOOL* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchScan"), _T("get_Continuous"));
	NTL_METHOD_START(IIviSwtchScan, get_Continuous);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Continuous"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IIviSwtchScan"), _T("get_Continuous"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviSwtchScan_put_Continuous(Agilent34980A* pT, VARIANT_BOOL val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchScan"), _T("put_Continuous"));
	NTL_METHOD_START(IIviSwtchScan, put_Continuous);
	CMethodTrace mt(pT, _T("IIviSwtchScan"), _T("put_Continuous"), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviSwtchScan_get_NumberOfColumns(Agilent34980A* pT, long* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchScan"), _T("get_NumberOfColumns"));
	NTL_METHOD_START(IIviSwtchScan, get_NumberOfColumns);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_NumberOfColumns"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IIviSwtchScan"), _T("get_NumberOfColumns"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviSwtchScan_get_NumberOfRows(Agilent34980A* pT, long* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchScan"), _T("get_NumberOfRows"));
	NTL_METHOD_START(IIviSwtchScan, get_NumberOfRows);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_NumberOfRows"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IIviSwtchScan"), _T("get_NumberOfRows"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviSwtchScan_get_AdvancedOutput(Agilent34980A* pT, IviSwtchAdvancedOutputEnum* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchScan"), _T("get_AdvancedOutput"));
	NTL_METHOD_START(IIviSwtchScan, get_AdvancedOutput);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_AdvancedOutput"), _T("val"));
		*val = IviSwtchAdvancedOutputNone;
	CMethodTrace mt(pT, _T("IIviSwtchScan"), _T("get_AdvancedOutput"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviSwtchScan_put_AdvancedOutput(Agilent34980A* pT, IviSwtchAdvancedOutputEnum val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchScan"), _T("put_AdvancedOutput"));
	NTL_METHOD_START(IIviSwtchScan, put_AdvancedOutput);
	CMethodTrace mt(pT, _T("IIviSwtchScan"), _T("put_AdvancedOutput"), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviSwtchScan_get_Delay(Agilent34980A* pT, double* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchScan"), _T("get_Delay"));
	NTL_METHOD_START(IIviSwtchScan, get_Delay);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Delay"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IIviSwtchScan"), _T("get_Delay"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviSwtchScan_put_Delay(Agilent34980A* pT, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchScan"), _T("put_Delay"));
	NTL_METHOD_START(IIviSwtchScan, put_Delay);
	CMethodTrace mt(pT, _T("IIviSwtchScan"), _T("put_Delay"), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviSwtchScan_get_Input(Agilent34980A* pT, IviSwtchTriggerInputEnum* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchScan"), _T("get_Input"));
	NTL_METHOD_START(IIviSwtchScan, get_Input);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Input"), _T("val"));
		*val = IviSwtchTriggerInputImmediate;
	CMethodTrace mt(pT, _T("IIviSwtchScan"), _T("get_Input"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviSwtchScan_put_Input(Agilent34980A* pT, IviSwtchTriggerInputEnum val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchScan"), _T("put_Input"));
	NTL_METHOD_START(IIviSwtchScan, put_Input);
	CMethodTrace mt(pT, _T("IIviSwtchScan"), _T("put_Input"), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviSwtchScan_get_List(Agilent34980A* pT, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchScan"), _T("get_List"));
	NTL_METHOD_START(IIviSwtchScan, get_List);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_List"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviSwtchScan"), _T("get_List"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviSwtchScan_put_List(Agilent34980A* pT, BSTR val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchScan"), _T("put_List"));
	NTL_METHOD_START(IIviSwtchScan, put_List);
	CMethodTrace mt(pT, _T("IIviSwtchScan"), _T("put_List"), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviSwtchScan_get_Mode(Agilent34980A* pT, IviSwtchScanModeEnum* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchScan"), _T("get_Mode"));
	NTL_METHOD_START(IIviSwtchScan, get_Mode);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Mode"), _T("val"));
		*val = IviSwtchScanModeNone;
	CMethodTrace mt(pT, _T("IIviSwtchScan"), _T("get_Mode"), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IIviSwtchScan_put_Mode(Agilent34980A* pT, IviSwtchScanModeEnum val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IIviSwtchScan"), _T("put_Mode"));
	NTL_METHOD_START(IIviSwtchScan, put_Mode);
	CMethodTrace mt(pT, _T("IIviSwtchScan"), _T("put_Mode"), IN_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980ADMM_PerformCalibration(Agilent34980A* pT)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADMM"), _T("PerformCalibration"));
	NTL_METHOD_START(IAgilent34980ADMM, PerformCalibration);
	CMethodTrace mt(pT, _T("IAgilent34980ADMM"), _T("PerformCalibration"), NULL);

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

	strCmd.Format(_T(":CAL?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADMM_PerformCalibration();
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADMM_get_Count(Agilent34980A* pT, long* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADMM"), _T("get_Count"));
	NTL_METHOD_START(IAgilent34980ADMM, get_Count);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Count"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34980ADMM"), _T("get_Count"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":CAL:COUN? DMM"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADMM_get_Count(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADMM_get_String(Agilent34980A* pT, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADMM"), _T("get_String"));
	NTL_METHOD_START(IAgilent34980ADMM, get_String);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_String"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980ADMM"), _T("get_String"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":CAL:STR? DMM"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADMM_get_String(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADMM_put_String(Agilent34980A* pT, BSTR val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADMM"), _T("put_String"));
	NTL_METHOD_START(IAgilent34980ADMM, put_String);
	CMethodTrace mt(pT, _T("IAgilent34980ADMM"), _T("put_String"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":CAL:STR \"%s\", DMM"), LPCTSTR(COLE2T(val)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADMM_put_String(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADMM_get_Value(Agilent34980A* pT, double* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADMM"), _T("get_Value"));
	NTL_METHOD_START(IAgilent34980ADMM, get_Value);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Value"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IAgilent34980ADMM"), _T("get_Value"), OUT_PARAM(val), NULL);

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

	strCmd.Format(_T(":CAL:VAL?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADMM_get_Value(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADMM_put_Value(Agilent34980A* pT, double val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADMM"), _T("put_Value"));
	NTL_METHOD_START(IAgilent34980ADMM, put_Value);
	CMethodTrace mt(pT, _T("IAgilent34980ADMM"), _T("put_Value"), IN_PARAM(val), NULL);

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

	strCmd.Format(_T(":CAL:VAL %.15g"), val);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADMM_put_Value(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADAC_AutoCalibrate(Agilent34980A* pT, short SlotNumber, VARIANT_BOOL All)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADAC"), _T("AutoCalibrate"));
	NTL_METHOD_START(IAgilent34980ADAC, AutoCalibrate);
	CMethodTrace mt(pT, _T("IAgilent34980ADAC"), _T("AutoCalibrate"), IN_PARAM(SlotNumber), IN_PARAM(All), NULL);

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

	strCmd.Format(_T(":CAL:MOD? %d"), SlotNumber);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADAC_AutoCalibrate(SlotNumber, All);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADAC_Abort(Agilent34980A* pT)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADAC"), _T("Abort"));
	NTL_METHOD_START(IAgilent34980ADAC, Abort);
	CMethodTrace mt(pT, _T("IAgilent34980ADAC"), _T("Abort"), NULL);

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

	strCmd.Format(_T(":CAL:ABOR"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADAC_Abort();
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADAC_BeginVoltageCal(Agilent34980A* pT, BSTR ChannelList, short SetupNumber)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADAC"), _T("BeginVoltageCal"));
	NTL_METHOD_START(IAgilent34980ADAC, BeginVoltageCal);
	CMethodTrace mt(pT, _T("IAgilent34980ADAC"), _T("BeginVoltageCal"), IN_PARAM(ChannelList), IN_PARAM(SetupNumber), NULL);

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

	strCmd.Format(_T(":CAL:BEG %d, (@%s)"), SetupNumber, LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADAC_BeginVoltageCal(ChannelList, SetupNumber);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADAC_Point(Agilent34980A* pT, double PointData)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADAC"), _T("Point"));
	NTL_METHOD_START(IAgilent34980ADAC, Point);
	CMethodTrace mt(pT, _T("IAgilent34980ADAC"), _T("Point"), IN_PARAM(PointData), NULL);

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

	strCmd.Format(_T(":CAL:POIN? %.15g"), PointData);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADAC_Point(PointData);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADAC_get_Count(Agilent34980A* pT, short SlotNumber, long* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADAC"), _T("get_Count"));
	NTL_METHOD_START(IAgilent34980ADAC, get_Count);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Count"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34980ADAC"), _T("get_Count"), IN_PARAM(SlotNumber), OUT_PARAM(val), NULL);

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

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

	return hr;
}
HRESULT IAgilent34980ADAC_get_String(Agilent34980A* pT, short SlotNumber, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADAC"), _T("get_String"));
	NTL_METHOD_START(IAgilent34980ADAC, get_String);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_String"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980ADAC"), _T("get_String"), IN_PARAM(SlotNumber), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":CAL:STR? %d"), SlotNumber);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADAC_get_String(SlotNumber, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ADAC_put_String(Agilent34980A* pT, short SlotNumber, BSTR val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ADAC"), _T("put_String"));
	NTL_METHOD_START(IAgilent34980ADAC, put_String);
	CMethodTrace mt(pT, _T("IAgilent34980ADAC"), _T("put_String"), IN_PARAM(SlotNumber), IN_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":CAL:STR \"%s\", %d"), LPCTSTR(COLE2T(val)), SlotNumber);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ADAC_put_String(SlotNumber, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AAlarm2_get_AlarmSequence(Agilent34980A* pT, long Index, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AAlarm2"), _T("get_AlarmSequence"));
	NTL_METHOD_START(IAgilent34980AAlarm2, get_AlarmSequence);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_AlarmSequence"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980AAlarm2"), _T("get_AlarmSequence"), IN_PARAM(Index), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":OUTP:ALAR%d:SEQ?"), Index);
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AAlarm2_get_AlarmSequence(Index, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980A2_get_Alarm(Agilent34980A* pT, IAgilent34980AAlarm2** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A2"), _T("get_Alarm"));
	NTL_METHOD_START(IAgilent34980A2, get_Alarm);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Alarm"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A2"), _T("get_Alarm"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980A2_get_Alarm(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980A2_get_Route(Agilent34980A* pT, IAgilent34980ARoute2** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A2"), _T("get_Route"));
	NTL_METHOD_START(IAgilent34980A2, get_Route);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Route"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A2"), _T("get_Route"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980A2_get_Route(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980A2_get_Status(Agilent34980A* pT, IAgilent34980AStatus2** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A2"), _T("get_Status"));
	NTL_METHOD_START(IAgilent34980A2, get_Status);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Status"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A2"), _T("get_Status"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980A2_get_Status(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980A2_get_Calibration(Agilent34980A* pT, IAgilent34980ACalibration** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A2"), _T("get_Calibration"));
	NTL_METHOD_START(IAgilent34980A2, get_Calibration);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Calibration"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A2"), _T("get_Calibration"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980A2_get_Calibration(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980A2_get_Current(Agilent34980A* pT, IAgilent34980ACurrent** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A2"), _T("get_Current"));
	NTL_METHOD_START(IAgilent34980A2, get_Current);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Current"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A2"), _T("get_Current"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980A2_get_Current(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980A2_get_Diagnostic(Agilent34980A* pT, IAgilent34980ADiagnostic** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A2"), _T("get_Diagnostic"));
	NTL_METHOD_START(IAgilent34980A2, get_Diagnostic);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Diagnostic"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A2"), _T("get_Diagnostic"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980A2_get_Diagnostic(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980A2_get_Frequency(Agilent34980A* pT, IAgilent34980AFrequency** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A2"), _T("get_Frequency"));
	NTL_METHOD_START(IAgilent34980A2, get_Frequency);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Frequency"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A2"), _T("get_Frequency"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980A2_get_Frequency(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980A2_get_FResistance(Agilent34980A* pT, IAgilent34980AFResistance** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A2"), _T("get_FResistance"));
	NTL_METHOD_START(IAgilent34980A2, get_FResistance);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_FResistance"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A2"), _T("get_FResistance"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980A2_get_FResistance(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980A2_get_Measurement(Agilent34980A* pT, IAgilent34980AMeasurement** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A2"), _T("get_Measurement"));
	NTL_METHOD_START(IAgilent34980A2, get_Measurement);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Measurement"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A2"), _T("get_Measurement"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980A2_get_Measurement(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980A2_get_Memory(Agilent34980A* pT, IAgilent34980AMemory** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A2"), _T("get_Memory"));
	NTL_METHOD_START(IAgilent34980A2, get_Memory);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Memory"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A2"), _T("get_Memory"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980A2_get_Memory(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980A2_get_Period(Agilent34980A* pT, IAgilent34980APeriod** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A2"), _T("get_Period"));
	NTL_METHOD_START(IAgilent34980A2, get_Period);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Period"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A2"), _T("get_Period"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980A2_get_Period(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980A2_get_Personality(Agilent34980A* pT, IAgilent34980APersonality** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A2"), _T("get_Personality"));
	NTL_METHOD_START(IAgilent34980A2, get_Personality);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Personality"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A2"), _T("get_Personality"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980A2_get_Personality(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980A2_get_Resistance(Agilent34980A* pT, IAgilent34980AResistance** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A2"), _T("get_Resistance"));
	NTL_METHOD_START(IAgilent34980A2, get_Resistance);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Resistance"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A2"), _T("get_Resistance"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980A2_get_Resistance(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980A2_get_Scale(Agilent34980A* pT, IAgilent34980AScale** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A2"), _T("get_Scale"));
	NTL_METHOD_START(IAgilent34980A2, get_Scale);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Scale"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A2"), _T("get_Scale"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980A2_get_Scale(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980A2_get_Scan(Agilent34980A* pT, IAgilent34980AScan** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A2"), _T("get_Scan"));
	NTL_METHOD_START(IAgilent34980A2, get_Scan);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Scan"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A2"), _T("get_Scan"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980A2_get_Scan(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980A2_get_Statistics(Agilent34980A* pT, IAgilent34980AStatistics** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A2"), _T("get_Statistics"));
	NTL_METHOD_START(IAgilent34980A2, get_Statistics);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Statistics"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A2"), _T("get_Statistics"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980A2_get_Statistics(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980A2_get_System(Agilent34980A* pT, IAgilent34980ASystem** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A2"), _T("get_System"));
	NTL_METHOD_START(IAgilent34980A2, get_System);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_System"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A2"), _T("get_System"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980A2_get_System(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980A2_get_Temperature(Agilent34980A* pT, IAgilent34980ATemperature** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A2"), _T("get_Temperature"));
	NTL_METHOD_START(IAgilent34980A2, get_Temperature);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Temperature"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A2"), _T("get_Temperature"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980A2_get_Temperature(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980A2_get_Trigger(Agilent34980A* pT, IAgilent34980ATrigger** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A2"), _T("get_Trigger"));
	NTL_METHOD_START(IAgilent34980A2, get_Trigger);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Trigger"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A2"), _T("get_Trigger"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980A2_get_Trigger(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980A2_get_Voltage(Agilent34980A* pT, IAgilent34980AVoltage** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A2"), _T("get_Voltage"));
	NTL_METHOD_START(IAgilent34980A2, get_Voltage);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Voltage"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A2"), _T("get_Voltage"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980A2_get_Voltage(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980A2_get_Display(Agilent34980A* pT, IAgilent34980ADisplay** val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980A2"), _T("get_Display"));
	NTL_METHOD_START(IAgilent34980A2, get_Display);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Display"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980A2"), _T("get_Display"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980A2_get_Display(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ARoute2_SequenceDefine(Agilent34980A* pT, BSTR SequenceName, BSTR CommandString)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ARoute2"), _T("SequenceDefine"));
	NTL_METHOD_START(IAgilent34980ARoute2, SequenceDefine);
	CMethodTrace mt(pT, _T("IAgilent34980ARoute2"), _T("SequenceDefine"), IN_PARAM(SequenceName), IN_PARAM(CommandString), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":ROUT:SEQ:DEF %s,'%s'"), LPCTSTR(COLE2T(SequenceName)), LPCTSTR(COLE2T(CommandString)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ARoute2_SequenceDefine(SequenceName, CommandString);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ARoute2_SequenceDelete(Agilent34980A* pT, BSTR SequenceName)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ARoute2"), _T("SequenceDelete"));
	NTL_METHOD_START(IAgilent34980ARoute2, SequenceDelete);
	CMethodTrace mt(pT, _T("IAgilent34980ARoute2"), _T("SequenceDelete"), IN_PARAM(SequenceName), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":ROUT:SEQ:DEL %s"), LPCTSTR(COLE2T(SequenceName)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ARoute2_SequenceDelete(SequenceName);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ARoute2_SequenceDeleteAll(Agilent34980A* pT)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ARoute2"), _T("SequenceDeleteAll"));
	NTL_METHOD_START(IAgilent34980ARoute2, SequenceDeleteAll);
	CMethodTrace mt(pT, _T("IAgilent34980ARoute2"), _T("SequenceDeleteAll"), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":ROUT:SEQ:DEL:ALL"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ARoute2_SequenceDeleteAll();
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ARoute2_SequenceTriggerImmediate(Agilent34980A* pT, BSTR SequenceName)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ARoute2"), _T("SequenceTriggerImmediate"));
	NTL_METHOD_START(IAgilent34980ARoute2, SequenceTriggerImmediate);
	CMethodTrace mt(pT, _T("IAgilent34980ARoute2"), _T("SequenceTriggerImmediate"), IN_PARAM(SequenceName), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":ROUT:SEQ:TRIG  %s"), LPCTSTR(COLE2T(SequenceName)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ARoute2_SequenceTriggerImmediate(SequenceName);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ARoute2_get_ChannelLabel(Agilent34980A* pT, BSTR ChannelList, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ARoute2"), _T("get_ChannelLabel"));
	NTL_METHOD_START(IAgilent34980ARoute2, get_ChannelLabel);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ChannelLabel"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980ARoute2"), _T("get_ChannelLabel"), IN_PARAM(ChannelList), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":ROUT:CHAN:LAB? (@%s)"), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ARoute2_get_ChannelLabel(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ARoute2_put_ChannelLabel(Agilent34980A* pT, BSTR ChannelList, BSTR val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ARoute2"), _T("put_ChannelLabel"));
	NTL_METHOD_START(IAgilent34980ARoute2, put_ChannelLabel);
	CMethodTrace mt(pT, _T("IAgilent34980ARoute2"), _T("put_ChannelLabel"), IN_PARAM(ChannelList), IN_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":ROUT:CHAN:LAB '%s',(@%s)"), LPCTSTR(COLE2T(val)), LPCTSTR(COLE2T(ChannelList)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ARoute2_put_ChannelLabel(ChannelList, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ARoute2_get_SequenceCatalog(Agilent34980A* pT, BSTR* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ARoute2"), _T("get_SequenceCatalog"));
	NTL_METHOD_START(IAgilent34980ARoute2, get_SequenceCatalog);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_SequenceCatalog"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IAgilent34980ARoute2"), _T("get_SequenceCatalog"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":ROUT:SEQ:CAT?"));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ARoute2_get_SequenceCatalog(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ARoute2_get_SequenceTriggerSource(Agilent34980A* pT, BSTR SequenceName, Agilent34980ASequenceTriggerSourceEnum* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ARoute2"), _T("get_SequenceTriggerSource"));
	NTL_METHOD_START(IAgilent34980ARoute2, get_SequenceTriggerSource);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_SequenceTriggerSource"), _T("val"));
		*val = Agilent34980ASequenceTriggerSourceAlarm1;
	CMethodTrace mt(pT, _T("IAgilent34980ARoute2"), _T("get_SequenceTriggerSource"), IN_PARAM(SequenceName), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":ROUT:SEQ:TRIG:SOUR?  %s"), LPCTSTR(COLE2T(SequenceName)));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ARoute2_get_SequenceTriggerSource(SequenceName, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980ARoute2_put_SequenceTriggerSource(Agilent34980A* pT, BSTR SequenceName, Agilent34980ASequenceTriggerSourceEnum val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980ARoute2"), _T("put_SequenceTriggerSource"));
	NTL_METHOD_START(IAgilent34980ARoute2, put_SequenceTriggerSource);
	CMethodTrace mt(pT, _T("IAgilent34980ARoute2"), _T("put_SequenceTriggerSource"), IN_PARAM(SequenceName), IN_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	strCmd.Format(_T(":ROUT:SEQ:TRIG:SOUR  %s,%s"), LPCTSTR(COLE2T(SequenceName)), pT->EnumToString<Agilent34980ASequenceTriggerSourceEnum>(val));
	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980ARoute2_put_SequenceTriggerSource(SequenceName, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AStatus2_get_ModuleRegister(Agilent34980A* pT, long Slot, Agilent34980AStatusSubRegisterEnum SubRegister, long* val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AStatus2"), _T("get_ModuleRegister"));
	NTL_METHOD_START(IAgilent34980AStatus2, get_ModuleRegister);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ModuleRegister"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IAgilent34980AStatus2"), _T("get_ModuleRegister"), IN_PARAM(Slot), IN_PARAM(SubRegister), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AStatus2_get_ModuleRegister(Slot, SubRegister, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IAgilent34980AStatus2_put_ModuleRegister(Agilent34980A* pT, long Slot, Agilent34980AStatusSubRegisterEnum SubRegister, long val)
{
	Agilent34980A::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980A"), _T("IAgilent34980AStatus2"), _T("put_ModuleRegister"));
	NTL_METHOD_START(IAgilent34980AStatus2, put_ModuleRegister);
	CMethodTrace mt(pT, _T("IAgilent34980AStatus2"), _T("put_ModuleRegister"), IN_PARAM(Slot), IN_PARAM(SubRegister), IN_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IAgilent34980AStatus2_put_ModuleRegister(Slot, SubRegister, val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviSwtchChannel_get_IsConfigurationChannel(Agilent34980AChannel* pT, VARIANT_BOOL* val)
{
	Agilent34980AChannel::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980AChannel"), _T("IIviSwtchChannel"), _T("get_IsConfigurationChannel"));
	NTL_METHOD_START(IIviSwtchChannel, get_IsConfigurationChannel);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_IsConfigurationChannel"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IIviSwtchChannel"), _T("get_IsConfigurationChannel"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviSwtchChannel_get_IsConfigurationChannel(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviSwtchChannel_put_IsConfigurationChannel(Agilent34980AChannel* pT, VARIANT_BOOL val)
{
	Agilent34980AChannel::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980AChannel"), _T("IIviSwtchChannel"), _T("put_IsConfigurationChannel"));
	NTL_METHOD_START(IIviSwtchChannel, put_IsConfigurationChannel);
	CMethodTrace mt(pT, _T("IIviSwtchChannel"), _T("put_IsConfigurationChannel"), IN_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviSwtchChannel_put_IsConfigurationChannel(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviSwtchChannel_get_IsSourceChannel(Agilent34980AChannel* pT, VARIANT_BOOL* val)
{
	Agilent34980AChannel::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980AChannel"), _T("IIviSwtchChannel"), _T("get_IsSourceChannel"));
	NTL_METHOD_START(IIviSwtchChannel, get_IsSourceChannel);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_IsSourceChannel"), _T("val"));
		*val = VARIANT_TRUE;
	CMethodTrace mt(pT, _T("IIviSwtchChannel"), _T("get_IsSourceChannel"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviSwtchChannel_get_IsSourceChannel(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviSwtchChannel_put_IsSourceChannel(Agilent34980AChannel* pT, VARIANT_BOOL val)
{
	Agilent34980AChannel::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980AChannel"), _T("IIviSwtchChannel"), _T("put_IsSourceChannel"));
	NTL_METHOD_START(IIviSwtchChannel, put_IsSourceChannel);
	CMethodTrace mt(pT, _T("IIviSwtchChannel"), _T("put_IsSourceChannel"), IN_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviSwtchChannel_put_IsSourceChannel(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviSwtchChannel_get_Characteristics(Agilent34980AChannel* pT, IIviSwtchCharacteristics** val)
{
	Agilent34980AChannel::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980AChannel"), _T("IIviSwtchChannel"), _T("get_Characteristics"));
	NTL_METHOD_START(IIviSwtchChannel, get_Characteristics);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Characteristics"), _T("val"));
		*val = NULL;
	CMethodTrace mt(pT, _T("IIviSwtchChannel"), _T("get_Characteristics"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviSwtchChannel_get_Characteristics(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviSwtchCharacteristics_get_ACCurrentCarryMax(Agilent34980AChannel* pT, double* val)
{
	Agilent34980AChannel::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980AChannel"), _T("IIviSwtchCharacteristics"), _T("get_ACCurrentCarryMax"));
	NTL_METHOD_START(IIviSwtchCharacteristics, get_ACCurrentCarryMax);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ACCurrentCarryMax"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IIviSwtchCharacteristics"), _T("get_ACCurrentCarryMax"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviSwtchCharacteristics_get_ACCurrentCarryMax(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviSwtchCharacteristics_get_ACCurrentSwitchingMax(Agilent34980AChannel* pT, double* val)
{
	Agilent34980AChannel::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980AChannel"), _T("IIviSwtchCharacteristics"), _T("get_ACCurrentSwitchingMax"));
	NTL_METHOD_START(IIviSwtchCharacteristics, get_ACCurrentSwitchingMax);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ACCurrentSwitchingMax"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IIviSwtchCharacteristics"), _T("get_ACCurrentSwitchingMax"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviSwtchCharacteristics_get_ACCurrentSwitchingMax(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviSwtchCharacteristics_get_ACPowerCarryMax(Agilent34980AChannel* pT, double* val)
{
	Agilent34980AChannel::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980AChannel"), _T("IIviSwtchCharacteristics"), _T("get_ACPowerCarryMax"));
	NTL_METHOD_START(IIviSwtchCharacteristics, get_ACPowerCarryMax);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ACPowerCarryMax"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IIviSwtchCharacteristics"), _T("get_ACPowerCarryMax"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviSwtchCharacteristics_get_ACPowerCarryMax(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviSwtchCharacteristics_get_ACPowerSwitchingMax(Agilent34980AChannel* pT, double* val)
{
	Agilent34980AChannel::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980AChannel"), _T("IIviSwtchCharacteristics"), _T("get_ACPowerSwitchingMax"));
	NTL_METHOD_START(IIviSwtchCharacteristics, get_ACPowerSwitchingMax);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ACPowerSwitchingMax"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IIviSwtchCharacteristics"), _T("get_ACPowerSwitchingMax"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviSwtchCharacteristics_get_ACPowerSwitchingMax(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviSwtchCharacteristics_get_ACVoltageMax(Agilent34980AChannel* pT, double* val)
{
	Agilent34980AChannel::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980AChannel"), _T("IIviSwtchCharacteristics"), _T("get_ACVoltageMax"));
	NTL_METHOD_START(IIviSwtchCharacteristics, get_ACVoltageMax);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_ACVoltageMax"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IIviSwtchCharacteristics"), _T("get_ACVoltageMax"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviSwtchCharacteristics_get_ACVoltageMax(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviSwtchCharacteristics_get_Bandwidth(Agilent34980AChannel* pT, double* val)
{
	Agilent34980AChannel::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980AChannel"), _T("IIviSwtchCharacteristics"), _T("get_Bandwidth"));
	NTL_METHOD_START(IIviSwtchCharacteristics, get_Bandwidth);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Bandwidth"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IIviSwtchCharacteristics"), _T("get_Bandwidth"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviSwtchCharacteristics_get_Bandwidth(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviSwtchCharacteristics_get_DCCurrentCarryMax(Agilent34980AChannel* pT, double* val)
{
	Agilent34980AChannel::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980AChannel"), _T("IIviSwtchCharacteristics"), _T("get_DCCurrentCarryMax"));
	NTL_METHOD_START(IIviSwtchCharacteristics, get_DCCurrentCarryMax);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_DCCurrentCarryMax"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IIviSwtchCharacteristics"), _T("get_DCCurrentCarryMax"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviSwtchCharacteristics_get_DCCurrentCarryMax(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviSwtchCharacteristics_get_DCCurrentSwitchingMax(Agilent34980AChannel* pT, double* val)
{
	Agilent34980AChannel::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980AChannel"), _T("IIviSwtchCharacteristics"), _T("get_DCCurrentSwitchingMax"));
	NTL_METHOD_START(IIviSwtchCharacteristics, get_DCCurrentSwitchingMax);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_DCCurrentSwitchingMax"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IIviSwtchCharacteristics"), _T("get_DCCurrentSwitchingMax"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviSwtchCharacteristics_get_DCCurrentSwitchingMax(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviSwtchCharacteristics_get_DCPowerCarryMax(Agilent34980AChannel* pT, double* val)
{
	Agilent34980AChannel::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980AChannel"), _T("IIviSwtchCharacteristics"), _T("get_DCPowerCarryMax"));
	NTL_METHOD_START(IIviSwtchCharacteristics, get_DCPowerCarryMax);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_DCPowerCarryMax"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IIviSwtchCharacteristics"), _T("get_DCPowerCarryMax"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviSwtchCharacteristics_get_DCPowerCarryMax(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviSwtchCharacteristics_get_DCPowerSwitchingMax(Agilent34980AChannel* pT, double* val)
{
	Agilent34980AChannel::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980AChannel"), _T("IIviSwtchCharacteristics"), _T("get_DCPowerSwitchingMax"));
	NTL_METHOD_START(IIviSwtchCharacteristics, get_DCPowerSwitchingMax);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_DCPowerSwitchingMax"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IIviSwtchCharacteristics"), _T("get_DCPowerSwitchingMax"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviSwtchCharacteristics_get_DCPowerSwitchingMax(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviSwtchCharacteristics_get_DCVoltageMax(Agilent34980AChannel* pT, double* val)
{
	Agilent34980AChannel::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980AChannel"), _T("IIviSwtchCharacteristics"), _T("get_DCVoltageMax"));
	NTL_METHOD_START(IIviSwtchCharacteristics, get_DCVoltageMax);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_DCVoltageMax"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IIviSwtchCharacteristics"), _T("get_DCVoltageMax"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviSwtchCharacteristics_get_DCVoltageMax(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviSwtchCharacteristics_get_Impedance(Agilent34980AChannel* pT, double* val)
{
	Agilent34980AChannel::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980AChannel"), _T("IIviSwtchCharacteristics"), _T("get_Impedance"));
	NTL_METHOD_START(IIviSwtchCharacteristics, get_Impedance);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_Impedance"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IIviSwtchCharacteristics"), _T("get_Impedance"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviSwtchCharacteristics_get_Impedance(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviSwtchCharacteristics_get_SettlingTime(Agilent34980AChannel* pT, double* val)
{
	Agilent34980AChannel::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980AChannel"), _T("IIviSwtchCharacteristics"), _T("get_SettlingTime"));
	NTL_METHOD_START(IIviSwtchCharacteristics, get_SettlingTime);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_SettlingTime"), _T("val"));
		*val = 0.0;
	CMethodTrace mt(pT, _T("IIviSwtchCharacteristics"), _T("get_SettlingTime"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviSwtchCharacteristics_get_SettlingTime(val);
	pT->PopInstrCommand();

	return hr;
}
HRESULT IIviSwtchCharacteristics_get_WireMode(Agilent34980AChannel* pT, long* val)
{
	Agilent34980AChannel::ObjectLock lock(pT);
	CCallContext context(pT, _T("Agilent34980AChannel"), _T("IIviSwtchCharacteristics"), _T("get_WireMode"));
	NTL_METHOD_START(IIviSwtchCharacteristics, get_WireMode);
	if (val == NULL) return pT->ReportError(IDS_E_IVI_NULL_POINTER, _T("get_WireMode"), _T("val"));
		*val = 0;
	CMethodTrace mt(pT, _T("IIviSwtchCharacteristics"), _T("get_WireMode"), OUT_PARAM(val), NULL);

	CString strCmd;
	CString strModel = pT->GetModel();

	HRESULT hr = S_OK;
	pT->PushInstrCommand(strCmd);
	hr = pT->IIviSwtchCharacteristics_get_WireMode(val);
	pT->PopInstrCommand();

	return hr;
}

