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

#include "stdafx.h"

#include "ag34980a.h"
#include "ntlivicdriver.h"
#include "CoAgilent34980A.h"

#import "libid:f4bd6957-31be-4f0f-b462-938861ad069f" no_namespace raw_interfaces_only // Agilent34950A
#import "libid:df92738f-8e5f-4ef6-a4e6-43f280aef550" no_namespace raw_interfaces_only // Agilent34951A
#import "libid:88c5b8b5-5b38-4680-9096-f629906da090" no_namespace raw_interfaces_only // Agilent34952A
#import "libid:0f07ae3d-5225-400e-a585-2f91514b3dc7" no_namespace raw_interfaces_only // Agilent34945A
#import "libid:268bebf4-d991-4848-a7da-067aef80a95b" no_namespace raw_interfaces_only // Agilent34959A

ViStatus TranslateHRESULT(ViSession session, HRESULT hr);
ViStatus TranslateHRESULTAgilent34950A(ViSession session, HRESULT hr);
ViStatus TranslateHRESULTAgilent34951A(ViSession session, HRESULT hr);
ViStatus TranslateHRESULTAgilent34952A(ViSession session, HRESULT hr);
ViStatus TranslateHRESULTAgilent34945A(ViSession session, HRESULT hr);
ViStatus TranslateHRESULTAgilent34959A(ViSession session, HRESULT hr);

ViStatus GetPersonalityAgilent34950A(ViSession Vi, IUnknown** ppPersonality)
{
	*ppPersonality = NULL;

	IUnknown* pDriver = NULL;
	ViStatus status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980APersonality* pHost = NULL;
		hr = pDriver->QueryInterface(&pHost);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			hr = pHost->Select(CComBSTR("Agilent34950A"), ppPersonality);
			status = TranslateHRESULT(Vi, hr);
			
			pHost->Release();
		}
		
		pDriver->Release();
	}

	return status;
}
ViStatus GetPersonalityAgilent34951A(ViSession Vi, IUnknown** ppPersonality)
{
	*ppPersonality = NULL;

	IUnknown* pDriver = NULL;
	ViStatus status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980APersonality* pHost = NULL;
		hr = pDriver->QueryInterface(&pHost);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			hr = pHost->Select(CComBSTR("Agilent34951A"), ppPersonality);
			status = TranslateHRESULT(Vi, hr);
			
			pHost->Release();
		}
		
		pDriver->Release();
	}

	return status;
}
ViStatus GetPersonalityAgilent34952A(ViSession Vi, IUnknown** ppPersonality)
{
	*ppPersonality = NULL;

	IUnknown* pDriver = NULL;
	ViStatus status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980APersonality* pHost = NULL;
		hr = pDriver->QueryInterface(&pHost);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			hr = pHost->Select(CComBSTR("Agilent34952A"), ppPersonality);
			status = TranslateHRESULT(Vi, hr);
			
			pHost->Release();
		}
		
		pDriver->Release();
	}

	return status;
}
ViStatus GetPersonalityAgilent34945A(ViSession Vi, IUnknown** ppPersonality)
{
	*ppPersonality = NULL;

	IUnknown* pDriver = NULL;
	ViStatus status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980APersonality* pHost = NULL;
		hr = pDriver->QueryInterface(&pHost);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			hr = pHost->Select(CComBSTR("Agilent34945A"), ppPersonality);
			status = TranslateHRESULT(Vi, hr);
			
			pHost->Release();
		}
		
		pDriver->Release();
	}

	return status;
}
ViStatus GetPersonalityAgilent34959A(ViSession Vi, IUnknown** ppPersonality)
{
	*ppPersonality = NULL;

	IUnknown* pDriver = NULL;
	ViStatus status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980APersonality* pHost = NULL;
		hr = pDriver->QueryInterface(&pHost);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			hr = pHost->Select(CComBSTR("Agilent34959A"), ppPersonality);
			status = TranslateHRESULT(Vi, hr);
			
			pHost->Release();
		}
		
		pDriver->Release();
	}

	return status;
}



    /*- Agilent34980A */

ViStatus _VI_FUNC  ag34980a_init ( ViRsrc ResourceName, ViBoolean IdQuery, ViBoolean Reset, ViSession* Vi )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_init\n"));
	
	status = ntl_InitWithOptions(__uuidof(Agilent34980A), ResourceName, IdQuery, Reset, "", Vi);

	return status;
}


ViStatus _VI_FUNC  ag34980a_GetNativeIUnknownPtr ( ViSession Vi, IUnknown** NativeIUnknownPtr )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetNativeIUnknownPtr\n"));

	status = ntl_GetNativeIUnknownPtr(Vi, NativeIUnknownPtr);

	return status;
}


ViStatus _VI_FUNC  ag34980a_close ( ViSession Vi )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_close\n"));

	status = ntl_close(Vi);
	
	return status;
}


ViStatus _VI_FUNC  ag34980a_InitWithOptions ( ViRsrc ResourceName, ViBoolean IdQuery, ViBoolean Reset, ViConstString OptionsString, ViSession* Vi )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_InitWithOptions\n"));

	status = ntl_InitWithOptions(__uuidof(Agilent34980A), ResourceName, IdQuery, Reset, OptionsString, Vi);

	return status;
}


    /*- Low-Level Measurement */

ViStatus _VI_FUNC  ag34980a_Initiate ( ViSession Vi )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_Initiate\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AMeasurement* pIAgilent34980AMeasurement = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AMeasurement);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			hr = pIAgilent34980AMeasurement->Initiate();
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980AMeasurement->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_Abort ( ViSession Vi )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_Abort\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AMeasurement* pIAgilent34980AMeasurement = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AMeasurement);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			hr = pIAgilent34980AMeasurement->Abort();
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980AMeasurement->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_DestructiveRead ( ViSession Vi, ViInt32 MaxCount, ViInt32 retValBufferSize, ViReal64 retVal[], ViInt32* retValActualSize )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_DestructiveRead\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AMeasurement* pIAgilent34980AMeasurement = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AMeasurement);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _MaxCount(MaxCount);
			CSAFEARRAY<double> _returnVal;
			hr = pIAgilent34980AMeasurement->DestructiveRead(_MaxCount.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal, retValBufferSize);
				_returnVal.LengthToViDataType(retValActualSize);
			}
			pIAgilent34980AMeasurement->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_FetchNumbersOnly ( ViSession Vi, ViInt32 retValBufferSize, ViReal64 retVal[], ViInt32* retValActualSize )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_FetchNumbersOnly\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AMeasurement* pIAgilent34980AMeasurement = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AMeasurement);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CSAFEARRAY<double> _returnVal;
			hr = pIAgilent34980AMeasurement->FetchNumbersOnly(_returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal, retValBufferSize);
				_returnVal.LengthToViDataType(retValActualSize);
			}
			pIAgilent34980AMeasurement->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_QueryLast ( ViSession Vi, ViConstString Channel, ViReal64* retVal )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_QueryLast\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AMeasurement* pIAgilent34980AMeasurement = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AMeasurement);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _Channel(Channel);
			CDouble _returnVal;
			hr = pIAgilent34980AMeasurement->QueryLast(_Channel.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal);
			}
			pIAgilent34980AMeasurement->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_ReadNumbersOnly ( ViSession Vi, ViConstString ChannelList, ViInt32 retValBufferSize, ViReal64 retVal[], ViInt32* retValActualSize )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ReadNumbersOnly\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AMeasurement* pIAgilent34980AMeasurement = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AMeasurement);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CSAFEARRAY<double> _returnVal;
			hr = pIAgilent34980AMeasurement->ReadNumbersOnly(_ChannelList.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal, retValBufferSize);
				_returnVal.LengthToViDataType(retValActualSize);
			}
			pIAgilent34980AMeasurement->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_RemoveReadings ( ViSession Vi, ViInt32 NumReadings, ViInt32 retValBufferSize, ViReal64 retVal[], ViInt32* retValActualSize )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_RemoveReadings\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AMeasurement* pIAgilent34980AMeasurement = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AMeasurement);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _NumReadings(NumReadings);
			CSAFEARRAY<double> _returnVal;
			hr = pIAgilent34980AMeasurement->RemoveReadings(_NumReadings.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal, retValBufferSize);
				_returnVal.LengthToViDataType(retValActualSize);
			}
			pIAgilent34980AMeasurement->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_SendSoftwareTrigger ( ViSession Vi )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_SendSoftwareTrigger\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AMeasurement* pIAgilent34980AMeasurement = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AMeasurement);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			hr = pIAgilent34980AMeasurement->SendSoftwareTrigger();
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980AMeasurement->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- AC */

ViStatus _VI_FUNC  ag34980a_MeasureACVoltage ( ViSession Vi, ViConstString ChannelList, ViReal64 Range, ViInt32 Resolution, ViInt32 retValBufferSize, ViReal64 retVal[], ViInt32* retValActualSize )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_MeasureACVoltage\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AACVoltage* pIAgilent34980AACVoltage = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AACVoltage);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CDouble _Range(Range);
			CLong _Resolution(Resolution);
			CSAFEARRAY<double> _returnVal;
			hr = pIAgilent34980AACVoltage->Measure(_ChannelList.GetVal(), _Range.GetVal(), (Agilent34980AResolutionEnum)_Resolution.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal, retValBufferSize);
				_returnVal.LengthToViDataType(retValActualSize);
			}
			pIAgilent34980AACVoltage->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- DC */

ViStatus _VI_FUNC  ag34980a_MeasureDCVoltage ( ViSession Vi, ViConstString ChannelList, ViReal64 Range, ViInt32 Resolution, ViInt32 retValBufferSize, ViReal64 retVal[], ViInt32* retValActualSize )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_MeasureDCVoltage\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ADCVoltage* pIAgilent34980ADCVoltage = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ADCVoltage);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CDouble _Range(Range);
			CLong _Resolution(Resolution);
			CSAFEARRAY<double> _returnVal;
			hr = pIAgilent34980ADCVoltage->Measure(_ChannelList.GetVal(), _Range.GetVal(), (Agilent34980AResolutionEnum)_Resolution.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal, retValBufferSize);
				_returnVal.LengthToViDataType(retValActualSize);
			}
			pIAgilent34980ADCVoltage->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- AC */

ViStatus _VI_FUNC  ag34980a_MeasureACCurrent ( ViSession Vi, ViConstString ChannelList, ViReal64 Range, ViInt32 Resolution, ViInt32 retValBufferSize, ViReal64 retVal[], ViInt32* retValActualSize )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_MeasureACCurrent\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AACCurrent* pIAgilent34980AACCurrent = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AACCurrent);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CDouble _Range(Range);
			CLong _Resolution(Resolution);
			CSAFEARRAY<double> _returnVal;
			hr = pIAgilent34980AACCurrent->Measure(_ChannelList.GetVal(), _Range.GetVal(), (Agilent34980AResolutionEnum)_Resolution.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal, retValBufferSize);
				_returnVal.LengthToViDataType(retValActualSize);
			}
			pIAgilent34980AACCurrent->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- DC */

ViStatus _VI_FUNC  ag34980a_MeasureDCCurrent ( ViSession Vi, ViConstString ChannelList, ViReal64 Range, ViInt32 Resolution, ViInt32 retValBufferSize, ViReal64 retVal[], ViInt32* retValActualSize )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_MeasureDCCurrent\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ADCCurrent* pIAgilent34980ADCCurrent = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ADCCurrent);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CDouble _Range(Range);
			CLong _Resolution(Resolution);
			CSAFEARRAY<double> _returnVal;
			hr = pIAgilent34980ADCCurrent->Measure(_ChannelList.GetVal(), _Range.GetVal(), (Agilent34980AResolutionEnum)_Resolution.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal, retValBufferSize);
				_returnVal.LengthToViDataType(retValActualSize);
			}
			pIAgilent34980ADCCurrent->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Frequency */

ViStatus _VI_FUNC  ag34980a_MeasureFrequency ( ViSession Vi, ViConstString ChannelList, ViReal64 Range, ViInt32 Resolution, ViInt32 retValBufferSize, ViReal64 retVal[], ViInt32* retValActualSize )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_MeasureFrequency\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AFrequency* pIAgilent34980AFrequency = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AFrequency);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CDouble _Range(Range);
			CLong _Resolution(Resolution);
			CSAFEARRAY<double> _returnVal;
			hr = pIAgilent34980AFrequency->Measure(_ChannelList.GetVal(), _Range.GetVal(), (Agilent34980AResolutionEnum)_Resolution.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal, retValBufferSize);
				_returnVal.LengthToViDataType(retValActualSize);
			}
			pIAgilent34980AFrequency->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Resistance 4-Wire */

ViStatus _VI_FUNC  ag34980a_MeasureFResistance ( ViSession Vi, ViConstString ChannelList, ViReal64 Range, ViInt32 Resolution, ViInt32 retValBufferSize, ViReal64 retVal[], ViInt32* retValActualSize )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_MeasureFResistance\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AFResistance* pIAgilent34980AFResistance = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AFResistance);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CDouble _Range(Range);
			CLong _Resolution(Resolution);
			CSAFEARRAY<double> _returnVal;
			hr = pIAgilent34980AFResistance->Measure(_ChannelList.GetVal(), _Range.GetVal(), (Agilent34980AResolutionEnum)_Resolution.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal, retValBufferSize);
				_returnVal.LengthToViDataType(retValActualSize);
			}
			pIAgilent34980AFResistance->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Period */

ViStatus _VI_FUNC  ag34980a_MeasurePeriod ( ViSession Vi, ViConstString ChannelList, ViReal64 Range, ViInt32 Resolution, ViInt32 retValBufferSize, ViReal64 retVal[], ViInt32* retValActualSize )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_MeasurePeriod\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980APeriod* pIAgilent34980APeriod = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980APeriod);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CDouble _Range(Range);
			CLong _Resolution(Resolution);
			CSAFEARRAY<double> _returnVal;
			hr = pIAgilent34980APeriod->Measure(_ChannelList.GetVal(), _Range.GetVal(), (Agilent34980AResolutionEnum)_Resolution.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal, retValBufferSize);
				_returnVal.LengthToViDataType(retValActualSize);
			}
			pIAgilent34980APeriod->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Resistance 2-Wire */

ViStatus _VI_FUNC  ag34980a_MeasureResistance ( ViSession Vi, ViConstString ChannelList, ViReal64 Range, ViInt32 Resolution, ViInt32 retValBufferSize, ViReal64 retVal[], ViInt32* retValActualSize )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_MeasureResistance\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AResistance* pIAgilent34980AResistance = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AResistance);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CDouble _Range(Range);
			CLong _Resolution(Resolution);
			CSAFEARRAY<double> _returnVal;
			hr = pIAgilent34980AResistance->Measure(_ChannelList.GetVal(), _Range.GetVal(), (Agilent34980AResolutionEnum)_Resolution.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal, retValBufferSize);
				_returnVal.LengthToViDataType(retValActualSize);
			}
			pIAgilent34980AResistance->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Statistics */

ViStatus _VI_FUNC  ag34980a_ClearStatistics ( ViSession Vi, ViConstString ChannelList )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ClearStatistics\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AStatistics* pIAgilent34980AStatistics = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AStatistics);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			hr = pIAgilent34980AStatistics->ClearStatistics(_ChannelList.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980AStatistics->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- FRTD */

ViStatus _VI_FUNC  ag34980a_MeasureFRTD ( ViSession Vi, ViConstString ChannelList, ViInt32 Type, ViInt32 Resolution, ViInt32 retValBufferSize, ViReal64 retVal[], ViInt32* retValActualSize )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_MeasureFRTD\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AFRTD* pIAgilent34980AFRTD = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AFRTD);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _Type(Type);
			CLong _Resolution(Resolution);
			CSAFEARRAY<double> _returnVal;
			hr = pIAgilent34980AFRTD->Measure(_ChannelList.GetVal(), (Agilent34980ARTDAlphaEnum)_Type.GetVal(), (Agilent34980AResolutionEnum)_Resolution.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal, retValBufferSize);
				_returnVal.LengthToViDataType(retValActualSize);
			}
			pIAgilent34980AFRTD->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- RTD */

ViStatus _VI_FUNC  ag34980a_MeasureRTD ( ViSession Vi, ViConstString ChannelList, ViInt32 Type, ViInt32 Resolution, ViInt32 retValBufferSize, ViReal64 retVal[], ViInt32* retValActualSize )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_MeasureRTD\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ARTD* pIAgilent34980ARTD = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ARTD);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _Type(Type);
			CLong _Resolution(Resolution);
			CSAFEARRAY<double> _returnVal;
			hr = pIAgilent34980ARTD->Measure(_ChannelList.GetVal(), (Agilent34980ARTDAlphaEnum)_Type.GetVal(), (Agilent34980AResolutionEnum)_Resolution.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal, retValBufferSize);
				_returnVal.LengthToViDataType(retValActualSize);
			}
			pIAgilent34980ARTD->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Thermistor */

ViStatus _VI_FUNC  ag34980a_MeasureThermistor ( ViSession Vi, ViConstString ChannelList, ViInt32 Type, ViInt32 Resolution, ViInt32 retValBufferSize, ViReal64 retVal[], ViInt32* retValActualSize )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_MeasureThermistor\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AThermistor* pIAgilent34980AThermistor = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AThermistor);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _Type(Type);
			CLong _Resolution(Resolution);
			CSAFEARRAY<double> _returnVal;
			hr = pIAgilent34980AThermistor->Measure(_ChannelList.GetVal(), (Agilent34980AThermistorEnum)_Type.GetVal(), (Agilent34980AResolutionEnum)_Resolution.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal, retValBufferSize);
				_returnVal.LengthToViDataType(retValActualSize);
			}
			pIAgilent34980AThermistor->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Thermocouple */

ViStatus _VI_FUNC  ag34980a_MeasureThermocouple ( ViSession Vi, ViConstString ChannelList, ViInt32 Type, ViInt32 Resolution, ViInt32 retValBufferSize, ViReal64 retVal[], ViInt32* retValActualSize )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_MeasureThermocouple\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AThermocouple* pIAgilent34980AThermocouple = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AThermocouple);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _Type(Type);
			CLong _Resolution(Resolution);
			CSAFEARRAY<double> _returnVal;
			hr = pIAgilent34980AThermocouple->Measure(_ChannelList.GetVal(), (Agilent34980AThermocoupleEnum)_Type.GetVal(), (Agilent34980AResolutionEnum)_Resolution.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal, retValBufferSize);
				_returnVal.LengthToViDataType(retValActualSize);
			}
			pIAgilent34980AThermocouple->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- LowLevel */

ViStatus _VI_FUNC  ag34980a_AbortCounterMeasurement ( ViSession Vi, ViConstString ChannelList )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_AbortCounterMeasurement\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950AMeasurement* pIAgilent34950AMeasurement = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950AMeasurement);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			hr = pIAgilent34950AMeasurement->Abort(_ChannelList.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950AMeasurement->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_InitiateCounterMeasurement ( ViSession Vi, ViConstString ChannelList )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_InitiateCounterMeasurement\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950AMeasurement* pIAgilent34950AMeasurement = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950AMeasurement);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			hr = pIAgilent34950AMeasurement->Initiate(_ChannelList.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950AMeasurement->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_ReadData ( ViSession Vi, ViConstString ChannelList, ViReal64* retVal )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ReadData\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950AMeasurement* pIAgilent34950AMeasurement = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950AMeasurement);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CDouble _returnVal;
			hr = pIAgilent34950AMeasurement->ReadData(_ChannelList.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal);
			}
			pIAgilent34950AMeasurement->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Digital Generic */

ViStatus _VI_FUNC  ag34980a_QueryLastByte ( ViSession Vi, ViConstString ChannelList, ViChar* retVal )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_QueryLastByte\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CByte _returnVal;
			hr = pIAgilent34950ADigital->QueryLastByte(_ChannelList.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal);
			}
			pIAgilent34950ADigital->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_QueryLastWord ( ViSession Vi, ViConstString ChannelList, ViInt16* retVal )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_QueryLastWord\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CShort _returnVal;
			hr = pIAgilent34950ADigital->QueryLastWord(_ChannelList.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal);
			}
			pIAgilent34950ADigital->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_ReadBit ( ViSession Vi, ViConstString ChannelList, ViInt32 BitNumber, ViBoolean* retVal )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ReadBit\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _BitNumber(BitNumber);
			CVariantBool _returnVal;
			hr = pIAgilent34950ADigital->ReadBit(_ChannelList.GetVal(), _BitNumber.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal);
			}
			pIAgilent34950ADigital->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_ReadByte ( ViSession Vi, ViConstString ChannelList, ViChar* retVal )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ReadByte\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CByte _returnVal;
			hr = pIAgilent34950ADigital->ReadByte(_ChannelList.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal);
			}
			pIAgilent34950ADigital->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_ReadWord ( ViSession Vi, ViConstString ChannelList, ViInt16* retVal )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ReadWord\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CShort _returnVal;
			hr = pIAgilent34950ADigital->ReadWord(_ChannelList.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal);
			}
			pIAgilent34950ADigital->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_ReadLongWord ( ViSession Vi, ViConstString ChannelList, ViInt32* retVal )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ReadLongWord\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _returnVal;
			hr = pIAgilent34950ADigital->ReadLongWord(_ChannelList.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal);
			}
			pIAgilent34950ADigital->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_QueryLastBit ( ViSession Vi, ViConstString ChannelList, ViInt32 BitNumber, ViChar* retVal )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_QueryLastBit\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _BitNumber(BitNumber);
			CByte _returnVal;
			hr = pIAgilent34950ADigital->QueryLastBit(_ChannelList.GetVal(), _BitNumber.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal);
			}
			pIAgilent34950ADigital->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_QueryLastLongWord ( ViSession Vi, ViConstString ChannelList, ViInt32* retVal )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_QueryLastLongWord\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _returnVal;
			hr = pIAgilent34950ADigital->QueryLastLongWord(_ChannelList.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal);
			}
			pIAgilent34950ADigital->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Totalizer */

ViStatus _VI_FUNC  ag34980a_ReadTotalizerData34952A ( ViSession Vi, ViConstString ChannelList, ViReal64* retVal )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ReadTotalizerData34952A\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34952A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34952ATotalize* pIAgilent34952ATotalize = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34952ATotalize);
		status = TranslateHRESULTAgilent34952A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CDouble _returnVal;
			hr = pIAgilent34952ATotalize->ReadData(_ChannelList.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULTAgilent34952A(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal);
			}
			pIAgilent34952ATotalize->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Utility */

ViStatus _VI_FUNC  ag34980a_revision_query ( ViSession Vi, ViChar DriverRev[], ViChar InstrRev[] )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_revision_query\n"));

	status = ntl_revision_query(Vi, DriverRev, InstrRev);

	return status;
}


ViStatus _VI_FUNC  ag34980a_error_message ( ViSession Vi, ViStatus ErrorCode, ViChar ErrorMessage[] )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_error_message\n"));

	ErrorMessage[0] = 0;

	static const CIviCErrorDescriptionMap _errorMap(
		new CIviCDriverErrorDescriptionInfo(AG34980A_SUCCESS, _T("Success.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_WARN_NSUP_ID_QUERY, _T("ID Query is not supported by this instrument.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_WARN_NSUP_RESET, _T("Reset is not supported by this instrument.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_WARN_NSUP_SELF_TEST, _T("Self test is not supported by this instrument.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_WARN_NSUP_ERROR_QUERY, _T("Error query is not supported by this instrument.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_WARN_NSUP_REV_QUERY, _T("Firmware revision query is not supported by this instrument.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_CANNOT_RECOVER, _T("Failure cannot recover.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_INSTRUMENT_STATUS, _T("Instrument error detected.  Use ErrorQuery() to determine the error(s).")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_CANNOT_OPEN_FILE, _T("Cannot open file.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_READING_FILE, _T("Error reading file.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_WRITING_FILE, _T("Error writing file.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_INVALID_PATHNAME, _T("The pathname is invalid.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_INVALID_VALUE, _T("Invalid value (%1) for method %2, parameter %3.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_FUNCTION_NOT_SUPPORTED, _T("Does not support this class-compliant feature: method %1")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_ATTRIBUTE_NOT_SUPPORTED, _T("Does not support this class-compliant feature: property %1.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_VALUE_NOT_SUPPORTED, _T("Does not support this class-compliant feature:  (enumeration) value %1 passed as the value for parameter %2 in method %3.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_NOT_INITIALIZED, _T("A connection to the instrument has not been established.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_UNKNOWN_CHANNEL_NAME, _T("Unknown channel name.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_TOO_MANY_OPEN_FILES, _T("Too many files are open.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_CHANNEL_NAME_REQUIRED, _T("A channel name is required.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_MISSING_OPTION_NAME, _T("The option string is missing an option name.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_MISSING_OPTION_VALUE, _T("The option string is missing an option value.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_BAD_OPTION_NAME, _T("The %1 name in the option string is unknown.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_BAD_OPTION_VALUE, _T("The %1 value in the option string is unknown.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_OUT_OF_MEMORY, _T("Could not allocate necessary memory.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_OPERATION_PENDING, _T("Operation in progress.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_NULL_POINTER, _T("Null pointer passed for method %1, parameter %2.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_UNEXPECTED_RESPONSE, _T("Unexpected response from instrument.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_FILE_NOT_FOUND, _T("File not found.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_INVALID_FILE_FORMAT, _T("Invalid file format.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_STATUS_NOT_AVAILABLE, _T("The instrument status is not available.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_ID_QUERY_FAILED, _T("Instrument ID query failed.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_RESET_FAILED, _T("Instrument reset failed.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_RESOURCE_UNKNOWN, _T("Unknown resource.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_ALREADY_INITIALIZED, _T("The driver is already initialized.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_CANNOT_CHANGE_SIMULATION_STATE, _T("The simulation state cannot be changed.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_INVALID_NUMBER_OF_LEVELS_IN_SELECTOR, _T("The number of levels in the selector is not valid for the %1 repeated capability.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_INVALID_RANGE_IN_SELECTOR, _T("The range %1 is not valid for the repeated capability %2.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_UNKOWN_NAME_IN_SELECTOR, _T("Unknown name in selector.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_BADLY_FORMED_SELECTOR, _T("The repeated capability selector is badly-formed.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_UNKNOWN_PHYSICAL_IDENTIFIER, _T("Unknown physical repeated capability selector.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_IVIDMM_ERROR_MAX_TIME_EXCEEDED, _T("Max time exceeded.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_IVIDMM_ERROR_TRIGGER_NOT_SOFTWARE, _T("The trigger source is not set to software trigger.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_IVIDMM_WARN_OVER_RANGE, _T("Over Range")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_WARN_PATH_REMAINS, _T("Some connections remain after disconnecting.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_WARN_IMPLICIT_CONNECTION_EXISTS, _T("The channels are implicitly connected.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_TRIGGER_NOT_SOFTWARE, _T("The trigger source is not software trigger.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_INVALID_SWITCH_PATH, _T("Invalid path string.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_INVALID_SCAN_LIST, _T("Invalid Scan List string.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_RSRC_IN_USE, _T("One of the channels is a configuration channel that is in use or is a common multiplexer channel that is in use.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_EMPTY_SCAN_LIST, _T("The scan list string is empty.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_EMPTY_SWITCH_PATH, _T("The path string is empty.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_SCAN_IN_PROGRESS, _T("The switch module is currently in scanning mode, and the operation cannot be performed at this time.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_NO_SCAN_IN_PROGRESS, _T("The switch module is not currently in scanning mode, and the operation cannot be performed at this time.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_NO_SUCH_PATH, _T("No explicit path exists between the two channels.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_IS_CONFIGURATION_CHANNEL, _T("You cannot make an explicit connection to a configuration channel.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_NOT_A_CONFIGURATION_CHANNEL, _T("One of the non-terminal channels in the path is not a configuration channel.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_ATTEMPT_TO_CONNECT_SOURCES, _T("You cannot make a connection between two different sources.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_EXPLICIT_CONNECTION_EXISTS, _T("An explicit connection between the channels already exists.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_LEG_MISSING_FIRST_CHANNEL, _T("A leg in the path does not begin with a channel name.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_LEG_MISSING_SECOND_CHANNEL, _T("A leg in the path is missing the second channel.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_CHANNEL_DUPLICATED_IN_LEG, _T("The first and second channels in the leg are the same.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_CHANNEL_DUPLICATED_IN_PATH, _T("A channel name is duplicated in the path string.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_PATH_NOT_FOUND, _T("No path was found between the two channels.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_DISCONTINUOUS_PATH, _T("The first channel of a leg in the path is not the same as the second channel in the previous leg.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_CANNOT_CONNECT_DIRECTLY, _T("The path contains a leg with two channels that cannot be directly connected.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_CHANNELS_ALREADY_CONNECTED, _T("A leg in the path contains two channels that are already directly connected.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_CANNOT_CONNECT_TO_ITSELF, _T("A channel cannot be connected to itself.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_MAX_TIME_EXCEEDED, _T("Max time exceeded.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_UNEXPECTED, _T("An unexpected error occurred.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_PERSONALITY_NOT_ACTIVE, _T("Personality is not active.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_PERSONALITY_NOT_INSTALLED, _T("Personality is not installed.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_PERSONALITY_NOT_LICENSED, _T("Personality is not licensed.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_IO_GENERAL, _T("IO error: %1.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_IO_TIMEOUT, _T("IO timeout error: %1.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_MODEL_NOT_SUPPORTED, _T("Instrument model does not support this feature: %1.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_VALUE_OUT_OF_RANGE, _T("Value out of range (%1) for method %2, parameter %3.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_WRAPPED_DRIVER_ERROR, _T("Error in call to wrapped driver: ViStatus = %1.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_LOCATIONS_BUSY, _T("Specified memory location is in use.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_MULTIPLE_CHANNELS_IN_GET, _T("Only one channel can be specified for getter.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_MISSING_DMM_OPTION, _T("The DMM option is required in simulation mode but missing.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_BAD_SIMULATION_OPTION, _T("The %1 option has invalid value.")),
		new CIviCDriverErrorDescriptionInfo(AG34980A_ERROR_MISSING_SIMULATION_OPTION, _T("No mainframe configuration information specified for simulation.")),
		NULL);

	const CIviCDriverErrorDescriptionInfo* pIviCErrorDescInfo = NULL;
	if (_errorMap.GetErrorDescriptionMap()->Lookup(ErrorCode, pIviCErrorDescInfo))
	{
		// IVI 3.2, section 6.5 says the message buffer must be at least 256 characters
		CString strDesc = pIviCErrorDescInfo->GetDescription();
		strncpy(ErrorMessage, CT2A(strDesc), 255);
		ErrorMessage[255] = 0;
	}

	return status;
}


ViStatus _VI_FUNC  ag34980a_AttachToExistingCOMSession ( IUnknown* ExistingIUnknownPtr, ViSession* Vi )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_AttachToExistingCOMSession\n"));

	status = ntl_AttachToExistingCOMSession(ExistingIUnknownPtr, Vi);

	return status;
}


ViStatus _VI_FUNC  ag34980a_GetError ( ViSession Vi, ViStatus* ErrorCode, ViInt32 ErrorDescriptionBufferSize, ViChar ErrorDescription[] )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetError\n"));

	status = ntl_GetError(Vi, ErrorCode, ErrorDescriptionBufferSize, ErrorDescription);

	return status;
}


ViStatus _VI_FUNC  ag34980a_ClearError ( ViSession Vi )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ClearError\n"));

	status = ntl_ClearError(Vi);

	return status;
}


ViStatus _VI_FUNC  ag34980a_GetChannelName ( ViSession Vi, ViInt32 Index, ViInt32 NameBufferSize, ViChar Name[] )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetChannelName\n"));

	HRESULT hr;

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		IIviSwtchChannels* pIIviSwtchChannels = NULL;
		hr = pDriver->QueryInterface(&pIIviSwtchChannels);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _index(Index);
			CBSTR _name;
			hr = pIIviSwtchChannels->get_Name(_index.GetVal(), _name.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _name.ToViDataType(Name, NameBufferSize);
			}
			pIIviSwtchChannels->Release();
		}
	
		pDriver->Release();
	}

	return status;
}


ViStatus _VI_FUNC  ag34980a_GetNextCoercionRecord ( ViSession Vi, ViInt32 CoercionRecordBufferSize, ViChar CoercionRecord[] )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetNextCoercionRecord\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IIviDriverOperation* pIIviDriverOperation = NULL;
		hr = pDriver->QueryInterface(&pIIviDriverOperation);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _returnVal;
			hr = pIIviDriverOperation->GetNextCoercionRecord(_returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(CoercionRecord, CoercionRecordBufferSize);
			}
			pIIviDriverOperation->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_ResetInterchangeCheck ( ViSession Vi )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ResetInterchangeCheck\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IIviDriverOperation* pIIviDriverOperation = NULL;
		hr = pDriver->QueryInterface(&pIIviDriverOperation);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			hr = pIIviDriverOperation->ResetInterchangeCheck();
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIIviDriverOperation->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetNextInterchangeWarning ( ViSession Vi, ViInt32 InterchangeWarningBufferSize, ViChar InterchangeWarning[] )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetNextInterchangeWarning\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IIviDriverOperation* pIIviDriverOperation = NULL;
		hr = pDriver->QueryInterface(&pIIviDriverOperation);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _returnVal;
			hr = pIIviDriverOperation->GetNextInterchangeWarning(_returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(InterchangeWarning, InterchangeWarningBufferSize);
			}
			pIIviDriverOperation->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_ClearInterchangeWarnings ( ViSession Vi )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ClearInterchangeWarnings\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IIviDriverOperation* pIIviDriverOperation = NULL;
		hr = pDriver->QueryInterface(&pIIviDriverOperation);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			hr = pIIviDriverOperation->ClearInterchangeWarnings();
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIIviDriverOperation->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_InvalidateAllAttributes ( ViSession Vi )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_InvalidateAllAttributes\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IIviDriverOperation* pIIviDriverOperation = NULL;
		hr = pDriver->QueryInterface(&pIIviDriverOperation);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			hr = pIIviDriverOperation->InvalidateAllAttributes();
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIIviDriverOperation->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_UnlockSession ( ViSession Vi, ViBoolean* CallerHasLock )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_UnlockSession\n"));

	status = ntl_UnlockSession(Vi, CallerHasLock);

	return status;
}


ViStatus _VI_FUNC  ag34980a_LockSession ( ViSession Vi, ViBoolean* CallerHasLock )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_LockSession\n"));

	status = ntl_LockSession(Vi, CallerHasLock);
	
	return status;
}


ViStatus _VI_FUNC  ag34980a_error_query ( ViSession Vi, ViInt32* ErrorCode, ViChar ErrorMessage[] )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_error_query\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IIviDriverUtility* pIIviDriverUtility = NULL;
		hr = pDriver->QueryInterface(&pIIviDriverUtility);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _ErrorCode(ErrorCode);
			CBSTR _ErrorMessage(ErrorMessage);
			hr = pIIviDriverUtility->ErrorQuery(_ErrorCode.GetPtr(), _ErrorMessage.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _ErrorCode.ToViDataType(ErrorCode);
				status = _ErrorMessage.ToViDataType(ErrorMessage, 1024);
			}
			pIIviDriverUtility->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_self_test ( ViSession Vi, ViInt16* TestResult, ViChar TestMessage[] )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_self_test\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IIviDriverUtility* pIIviDriverUtility = NULL;
		hr = pDriver->QueryInterface(&pIIviDriverUtility);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _TestResult(TestResult);
			CBSTR _TestMessage(TestMessage);
			hr = pIIviDriverUtility->SelfTest(_TestResult.GetPtr(), _TestMessage.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _TestResult.ToViDataType(TestResult);
				status = _TestMessage.ToViDataType(TestMessage, 1024);
			}
			pIIviDriverUtility->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_Disable ( ViSession Vi )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_Disable\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IIviDriverUtility* pIIviDriverUtility = NULL;
		hr = pDriver->QueryInterface(&pIIviDriverUtility);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			hr = pIIviDriverUtility->Disable();
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIIviDriverUtility->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_ResetWithDefaults ( ViSession Vi )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ResetWithDefaults\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IIviDriverUtility* pIIviDriverUtility = NULL;
		hr = pDriver->QueryInterface(&pIIviDriverUtility);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			hr = pIIviDriverUtility->ResetWithDefaults();
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIIviDriverUtility->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_reset ( ViSession Vi )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_reset\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IIviDriverUtility* pIIviDriverUtility = NULL;
		hr = pDriver->QueryInterface(&pIIviDriverUtility);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			hr = pIIviDriverUtility->Reset();
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIIviDriverUtility->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_WaitForOperationComplete ( ViSession Vi, ViInt32 MaxTimeMilliseconds )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_WaitForOperationComplete\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ASystem* pIAgilent34980ASystem = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ASystem);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _MaxTimeMilliseconds(MaxTimeMilliseconds);
			hr = pIAgilent34980ASystem->WaitForOperationComplete(_MaxTimeMilliseconds.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ASystem->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_SetSystemTime ( ViSession Vi, ViInt32 Hours, ViInt32 Mins, ViReal64 Seconds )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_SetSystemTime\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ASystem* pIAgilent34980ASystem = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ASystem);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _Hours(Hours);
			CLong _Mins(Mins);
			CDouble _Seconds(Seconds);
			hr = pIAgilent34980ASystem->SetSystemTime(_Hours.GetVal(), _Mins.GetVal(), _Seconds.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ASystem->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_SetSystemDate ( ViSession Vi, ViInt32 Year, ViInt32 Month, ViInt32 Day )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_SetSystemDate\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ASystem* pIAgilent34980ASystem = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ASystem);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _Year(Year);
			CLong _Month(Month);
			CLong _Day(Day);
			hr = pIAgilent34980ASystem->SetSystemDate(_Year.GetVal(), _Month.GetVal(), _Day.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ASystem->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_SystemPreset ( ViSession Vi )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_SystemPreset\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ASystem* pIAgilent34980ASystem = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ASystem);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			hr = pIAgilent34980ASystem->Preset();
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ASystem->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetSystemTime ( ViSession Vi, ViInt32* Hours, ViInt32* Mins, ViReal64* Seconds )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetSystemTime\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ASystem* pIAgilent34980ASystem = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ASystem);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _Hours(Hours);
			CLong _Mins(Mins);
			CDouble _Seconds(Seconds);
			hr = pIAgilent34980ASystem->GetSystemTime(_Hours.GetPtr(), _Mins.GetPtr(), _Seconds.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _Hours.ToViDataType(Hours);
				status = _Mins.ToViDataType(Mins);
				status = _Seconds.ToViDataType(Seconds);
			}
			pIAgilent34980ASystem->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetSystemDate ( ViSession Vi, ViInt32* Year, ViInt32* Month, ViInt32* Day )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetSystemDate\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ASystem* pIAgilent34980ASystem = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ASystem);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _Year(Year);
			CLong _Month(Month);
			CLong _Day(Day);
			hr = pIAgilent34980ASystem->GetSystemDate(_Year.GetPtr(), _Month.GetPtr(), _Day.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _Year.ToViDataType(Year);
				status = _Month.ToViDataType(Month);
				status = _Day.ToViDataType(Day);
			}
			pIAgilent34980ASystem->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_CardReset ( ViSession Vi, ViInt32 SlotNum )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_CardReset\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ASystem* pIAgilent34980ASystem = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ASystem);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _SlotNum(SlotNum);
			hr = pIAgilent34980ASystem->CardReset(_SlotNum.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ASystem->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_LockRequest ( ViSession Vi, ViBoolean* retVal )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_LockRequest\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ASystem* pIAgilent34980ASystem = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ASystem);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CVariantBool _returnVal;
			hr = pIAgilent34980ASystem->LockRequest(_returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal);
			}
			pIAgilent34980ASystem->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_LockRelease ( ViSession Vi )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_LockRelease\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ASystem* pIAgilent34980ASystem = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ASystem);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			hr = pIAgilent34980ASystem->LockRelease();
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ASystem->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_SecureImmediate ( ViSession Vi )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_SecureImmediate\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ASystem* pIAgilent34980ASystem = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ASystem);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			hr = pIAgilent34980ASystem->SecureImmediate();
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ASystem->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetModuleTemperature ( ViSession Vi, ViInt32 Mode, ViInt32 Slot, ViReal64* retVal )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetModuleTemperature\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ASystem* pIAgilent34980ASystem = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ASystem);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _Mode(Mode);
			CLong _Slot(Slot);
			CDouble _returnVal;
			hr = pIAgilent34980ASystem->GetModuleTemperature((Agilent34980AModuleTemperatureEnum)_Mode.GetVal(), _Slot.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal);
			}
			pIAgilent34980ASystem->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetCardType ( ViSession Vi, ViInt32 SlotNum, ViInt32 retValBufferSize, ViChar retVal[] )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetCardType\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ASystem* pIAgilent34980ASystem = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ASystem);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _SlotNum(SlotNum);
			CBSTR _returnVal;
			hr = pIAgilent34980ASystem->get_CardType(_SlotNum.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal, retValBufferSize);
			}
			pIAgilent34980ASystem->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetEnableInterface ( ViSession Vi, ViInt32 HWInterface, ViBoolean* retVal )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetEnableInterface\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ASystem* pIAgilent34980ASystem = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ASystem);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _HWInterface(HWInterface);
			CVariantBool _returnVal;
			hr = pIAgilent34980ASystem->get_EnableInterface((Agilent34980AHWInterfaceEnum)_HWInterface.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal);
			}
			pIAgilent34980ASystem->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_SetEnableInterface ( ViSession Vi, ViInt32 HWInterface, ViBoolean val )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_SetEnableInterface\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ASystem* pIAgilent34980ASystem = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ASystem);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _HWInterface(HWInterface);
			CVariantBool _val(val);
			hr = pIAgilent34980ASystem->put_EnableInterface((Agilent34980AHWInterfaceEnum)_HWInterface.GetVal(), _val.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ASystem->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_SetModuleWireMode ( ViSession Vi, ViInt32 SlotNumber, ViInt32 val )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_SetModuleWireMode\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ASystem* pIAgilent34980ASystem = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ASystem);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _SlotNumber(SlotNumber);
			CLong _val(val);
			hr = pIAgilent34980ASystem->put_ModuleWireMode(_SlotNumber.GetVal(), (Agilent34980AWireModeEnum)_val.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ASystem->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetRemoteModuleDescription ( ViSession Vi, ViConstString RemoteModule, ViInt32 Bank, ViInt32 retValBufferSize, ViChar retVal[] )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetRemoteModuleDescription\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34945A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34945ASystem* pIAgilent34945ASystem = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34945ASystem);
		status = TranslateHRESULTAgilent34945A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _RemoteModule(RemoteModule);
			CLong _Bank(Bank);
			CBSTR _returnVal;
			hr = pIAgilent34945ASystem->get_RemoteModuleDescription(_RemoteModule.GetVal(), _Bank.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULTAgilent34945A(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal, retValBufferSize);
			}
			pIAgilent34945ASystem->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetRemoteModuleType ( ViSession Vi, ViConstString RemoteModule, ViInt32 Bank, ViInt32 retValBufferSize, ViChar retVal[] )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetRemoteModuleType\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34945A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34945ASystem* pIAgilent34945ASystem = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34945ASystem);
		status = TranslateHRESULTAgilent34945A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _RemoteModule(RemoteModule);
			CLong _Bank(Bank);
			CBSTR _returnVal;
			hr = pIAgilent34945ASystem->get_RemoteModuleType(_RemoteModule.GetVal(), _Bank.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULTAgilent34945A(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal, retValBufferSize);
			}
			pIAgilent34945ASystem->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetRemoteModuleStatus ( ViSession Vi, ViInt32 Slot, ViInt32 retValBufferSize, ViChar retVal[] )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetRemoteModuleStatus\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34945A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34945ASystem* pIAgilent34945ASystem = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34945ASystem);
		status = TranslateHRESULTAgilent34945A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _Slot(Slot);
			CBSTR _returnVal;
			hr = pIAgilent34945ASystem->get_RemoteModuleStatus(_Slot.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULTAgilent34945A(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal, retValBufferSize);
			}
			pIAgilent34945ASystem->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Attribute Accessors */

ViStatus _VI_FUNC  ag34980a_GetAttributeViInt32 ( ViSession Vi, ViConstString RepCapIdentifier, ViAttr AttributeID, ViInt32* AttributeValue )
{
	ViStatus status = VI_SUCCESS;

	switch (AttributeID)
	{
		case AG34980A_ATTR_SPECIFIC_DRIVER_DESCRIPTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_SPECIFIC_DRIVER_DESCRIPTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_PREFIX:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_SPECIFIC_DRIVER_PREFIX\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_VENDOR:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_SPECIFIC_DRIVER_VENDOR\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_REVISION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_SPECIFIC_DRIVER_REVISION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MAJOR_VERSION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MAJOR_VERSION\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			
			if (Vi == VI_NULL)
			{
				hr = CreateDriver(__uuidof(Agilent34980A), &pDriver);
				if (SUCCEEDED(hr))
				{
					status = VI_SUCCESS;
				}
				else
				{
					status = _VI_ERROR;
				}
			}
			else
			{
				status = GetDriver(Vi, &pDriver);
			}
			
			if (status == VI_SUCCESS)
			{
				IIviDriverIdentity* pIIviDriverIdentity = NULL;
				hr = pDriver->QueryInterface(&pIIviDriverIdentity);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CLong _val;
					hr = pIIviDriverIdentity->get_SpecificationMajorVersion(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIIviDriverIdentity->Release();
				}

				pDriver->Release();
			}
			break;
		}
		case AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MINOR_VERSION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MINOR_VERSION\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			
			if (Vi == VI_NULL)
			{
				hr = CreateDriver(__uuidof(Agilent34980A), &pDriver);
				if (SUCCEEDED(hr))
				{
					status = VI_SUCCESS;
				}
				else
				{
					status = _VI_ERROR;
				}
			}
			else
			{
				status = GetDriver(Vi, &pDriver);
			}
			
			if (status == VI_SUCCESS)
			{
				IIviDriverIdentity* pIIviDriverIdentity = NULL;
				hr = pDriver->QueryInterface(&pIIviDriverIdentity);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CLong _val;
					hr = pIIviDriverIdentity->get_SpecificationMinorVersion(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIIviDriverIdentity->Release();
				}

				pDriver->Release();
			}
			break;
		}
		case AG34980A_ATTR_LOGICAL_NAME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_LOGICAL_NAME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IO_RESOURCE_DESCRIPTOR:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_IO_RESOURCE_DESCRIPTOR\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CACHE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_CACHE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INTERCHANGE_CHECK:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_INTERCHANGE_CHECK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_QUERY_INSTRUMENT_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_QUERY_INSTRUMENT_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RANGE_CHECK:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_RANGE_CHECK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RECORD_COERCIONS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_RECORD_COERCIONS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SIMULATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_SIMULATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVER_SETUP:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DRIVER_SETUP\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INSTRUMENT_MANUFACTURER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_INSTRUMENT_MANUFACTURER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INSTRUMENT_MODEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_INSTRUMENT_MODEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INSTRUMENT_FIRMWARE_REVISION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_INSTRUMENT_FIRMWARE_REVISION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SUPPORTED_INSTRUMENT_MODELS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_SUPPORTED_INSTRUMENT_MODELS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GROUP_CAPABILITIES:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_GROUP_CAPABILITIES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_LOWER_LIMIT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_ALARM_LOWER_LIMIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_LOWER_LIMIT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_ALARM_LOWER_LIMIT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_ALARM_MODE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AAlarm* pIAgilent34980AAlarm = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AAlarm);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CLong _val;
					hr = pIAgilent34980AAlarm->get_Mode((Agilent34980AAlarmModeEnum*)_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AAlarm->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_QUERYALARMQUEUE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_QUERYALARMQUEUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_SLOPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_ALARM_SLOPE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AAlarm* pIAgilent34980AAlarm = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AAlarm);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CLong _val;
					hr = pIAgilent34980AAlarm->get_Slope((Agilent34980ASlopeEnum*)_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AAlarm->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_ALARM_UPPER_LIMIT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_ALARM_UPPER_LIMIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_UPPER_LIMIT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_ALARM_UPPER_LIMIT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_VOLTAGE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_AC_VOLTAGE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_VOLTAGE_BANDWIDTH:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_AC_VOLTAGE_BANDWIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_AC_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_CURRENT_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_AC_CURRENT_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_CURRENT_BANDWIDTH:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_AC_CURRENT_BANDWIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_CURRENT_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_AC_CURRENT_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SECURITY_PASSWORD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_SECURITY_PASSWORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_MAINFRAME_MESSAGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_CAL_MAINFRAME_MESSAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_TOTAL_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_CAL_TOTAL_COUNT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ACalibration* pIAgilent34980ACalibration = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ACalibration);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CLong _val;
					hr = pIAgilent34980ACalibration->get_Count(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ACalibration->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_CAL_LINE_FREQUENCY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_CAL_LINE_FREQUENCY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SECURITY_STATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_SECURITY_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DC_CURRENT_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DC_CURRENT_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DC_CURRENT_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DC_CURRENT_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DC_CURRENT_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DC_CURRENT_AUTOZERO\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADCCurrent* pIAgilent34980ADCCurrent = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADCCurrent);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34980ADCCurrent->get_AutoZero(_identifier.GetVal(), (Agilent34980AAutoZeroEnum*)_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ADCCurrent->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DC_VOLTAGE_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DC_VOLTAGE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DC_VOLTAGE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DC_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DC_VOLTAGE_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DC_VOLTAGE_AUTOZERO\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADCVoltage* pIAgilent34980ADCVoltage = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADCVoltage);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34980ADCVoltage->get_AutoZero(_identifier.GetVal(), (Agilent34980AAutoZeroEnum*)_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ADCVoltage->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_AUTO_IMPEDANCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DC_VOLTAGE_AUTO_IMPEDANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GETRELAYCYCLES:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_GETRELAYCYCLES\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADiagnostic* pIAgilent34980ADiagnostic = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADiagnostic);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34980ADiagnostic->get_RelayCycles(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ADiagnostic->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DISPLAY_ENABLED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DISPLAY_ENABLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DISPLAY_TEXT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DISPLAY_TEXT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MONITOR_DATA:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_MONITOR_DATA\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MONITOR_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_MONITOR_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MONITOR_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_MONITOR_MODE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADisplay* pIAgilent34980ADisplay = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADisplay);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CLong _val;
					hr = pIAgilent34980ADisplay->get_MonitorMode((Agilent34980AMonitorModeEnum*)_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ADisplay->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_ENABLE_MONITOR_CHAN:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_ENABLE_MONITOR_CHAN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SELECT_MONITOR_CHAN:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_SELECT_MONITOR_CHAN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_FREQUENCY_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE_AUTO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE_AUTO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_LOW_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_FREQUENCY_LOW_RANGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AFrequency* pIAgilent34980AFrequency = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AFrequency);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34980AFrequency->get_LowRange(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AFrequency->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_FRESISTANCE_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_FRESISTANCE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_FRESISTANCE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_FRESISTANCE_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_FRESISTANCE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_FRESISTANCE_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEASUREMENT_READING_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_MEASUREMENT_READING_COUNT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AMeasurement* pIAgilent34980AMeasurement = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AMeasurement);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CLong _val;
					hr = pIAgilent34980AMeasurement->get_ReadingCount(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AMeasurement->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_MEASUREMENT_FUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_MEASUREMENT_FUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AUTO_RECALL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_AUTO_RECALL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_NUMBER_OF_STATES:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_NUMBER_OF_STATES\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AMemory* pIAgilent34980AMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AMemory);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CLong _val;
					hr = pIAgilent34980AMemory->get_NumStates(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_MEMORY_CATALOG:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_MEMORY_CATALOG\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PERIOD_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_PERIOD_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PERIOD_VOLTAGE_RANGE_AUTO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_PERIOD_VOLTAGE_RANGE_AUTO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PERIOD_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_PERIOD_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_RESISTANCE_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_RESISTANCE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_RESISTANCE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_RESISTANCE_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_RESISTANCE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_RESISTANCE_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_RESISTANCE_AUTOZERO\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AResistance* pIAgilent34980AResistance = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AResistance);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34980AResistance->get_AutoZero(_identifier.GetVal(), (Agilent34980AAutoZeroEnum*)_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AResistance->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_SCALE_GAIN:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_SCALE_GAIN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_OFFSET:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_SCALE_OFFSET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_STATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_SCALE_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_UNIT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_SCALE_UNIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_AUTO_DELAY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_CHANNEL_AUTO_DELAY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_DELAY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_CHANNEL_DELAY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_FWIRE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_CHANNEL_FWIRE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ROUTE_DONE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_ROUTE_DONE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_IS_CLOSED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_CHANNEL_IS_CLOSED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_SCAN_SIZE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_CHANNEL_SCAN_SIZE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AScan* pIAgilent34980AScan = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AScan);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CLong _val;
					hr = pIAgilent34980AScan->get_ScanSize(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AScan->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_CHANNEL_SCAN_LIST:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_CHANNEL_SCAN_LIST\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_SCAN_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_CHANNEL_SCAN_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCAN_SWEEP_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_SCAN_SWEEP_COUNT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AScan* pIAgilent34980AScan = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AScan);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CLong _val;
					hr = pIAgilent34980AScan->get_SweepCount(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AScan->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_ORDERED_SCAN:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_ORDERED_SCAN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_AVERAGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_STATISTICS_AVERAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_STATISTICS_COUNT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AStatistics* pIAgilent34980AStatistics = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AStatistics);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34980AStatistics->get_Count(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AStatistics->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MAX_VALUE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_STATISTICS_MAX_VALUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MAX_VALUE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_STATISTICS_MAX_VALUE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MIN_VALUE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_STATISTICS_MIN_VALUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MIN_VALUE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_STATISTICS_MIN_VALUE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_PTPEAK:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_STATISTICS_PTPEAK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SERIAL_POLL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_SERIAL_POLL\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AStatus* pIAgilent34980AStatus = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AStatus);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CLong _val;
					hr = pIAgilent34980AStatus->get_SerialPoll(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AStatus->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_ASYNC_EVENTS_ENABLED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_ASYNC_EVENTS_ENABLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SYSTEM_DATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_SYSTEM_DATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DMM_ENABLED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DMM_ENABLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DMM_INSTALLED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DMM_INSTALLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_READING_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_READING_THRESHOLD\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ASystem* pIAgilent34980ASystem = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ASystem);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CLong _val;
					hr = pIAgilent34980ASystem->get_ReadingThreshold(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ASystem->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_SERIAL_NUMBER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_SERIAL_NUMBER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SYSTEM_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_SYSTEM_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TIMEOUT_MILLISECONDS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_TIMEOUT_MILLISECONDS\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ASystem* pIAgilent34980ASystem = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ASystem);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CLong _val;
					hr = pIAgilent34980ASystem->get_TimeoutMilliseconds(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ASystem->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_LOCK_OWNER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_LOCK_OWNER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MODULE_EVENTS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_MODULE_EVENTS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_READING_UNITS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_TEMPERATURE_READING_UNITS\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ATemperature* pIAgilent34980ATemperature = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ATemperature);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34980ATemperature->get_ReadingUnits(_identifier.GetVal(), (Agilent34980ATemperatureUnitsEnum*)_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ATemperature->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_TEMPERATURE_AUTOZERO\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ATemperature* pIAgilent34980ATemperature = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ATemperature);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34980ATemperature->get_AutoZero(_identifier.GetVal(), (Agilent34980AAutoZeroEnum*)_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ATemperature->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_TEMPERATURE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_TRANSDUCERTYPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_TEMPERATURE_TRANSDUCERTYPE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ATemperature* pIAgilent34980ATemperature = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ATemperature);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34980ATemperature->get_TransducerType(_identifier.GetVal(), (Agilent34980ATransducerEnum*)_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ATemperature->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_FRTD_RESISTANCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_FRTD_RESISTANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_ALPHA:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_FRTD_ALPHA\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AFRTD* pIAgilent34980AFRTD = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AFRTD);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34980AFRTD->get_Alpha(_identifier.GetVal(), (Agilent34980AFRTDAlphaEnum*)_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AFRTD->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_FRTD_IS_EXTERNAL_REFERENCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_FRTD_IS_EXTERNAL_REFERENCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_FRTD_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_ALARM_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DATA_FORMAT_ALARM_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_CHANNEL_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DATA_FORMAT_CHANNEL_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_TIME_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DATA_FORMAT_TIME_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_TIME_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DATA_FORMAT_TIME_TYPE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADataFormat* pIAgilent34980ADataFormat = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADataFormat);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CLong _val;
					hr = pIAgilent34980ADataFormat->get_TimeType((Agilent34980ATimeOffsetEnum*)_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ADataFormat->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_UNIT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DATA_FORMAT_UNIT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_RESISTANCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_RTD_RESISTANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_ALPHA:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_RTD_ALPHA\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ARTD* pIAgilent34980ARTD = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ARTD);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34980ARTD->get_Alpha(_identifier.GetVal(), (Agilent34980ARTDAlphaEnum*)_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ARTD->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_RTD_IS_EXTERNAL_REFERENCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_RTD_IS_EXTERNAL_REFERENCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_RTD_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMISTOR_RESISTANCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_THERMISTOR_RESISTANCE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AThermistor* pIAgilent34980AThermistor = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AThermistor);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34980AThermistor->get_Resistance(_identifier.GetVal(), (Agilent34980AThermistorEnum*)_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AThermistor->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_THERMISTOR_IS_EXTERNAL_REFERENCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_THERMISTOR_IS_EXTERNAL_REFERENCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_THERMOCOUPLE_TYPE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AThermocouple* pIAgilent34980AThermocouple = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AThermocouple);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34980AThermocouple->get_ThermocoupleType(_identifier.GetVal(), (Agilent34980AThermocoupleEnum*)_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AThermocouple->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_JUNCTION_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_THERMOCOUPLE_JUNCTION_TYPE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AThermocouple* pIAgilent34980AThermocouple = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AThermocouple);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34980AThermocouple->get_ReferenceJunctionType(_identifier.GetVal(), (Agilent34980ARJunctionEnum*)_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AThermocouple->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_FIXED_REFERENCE_JUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_THERMOCOUPLE_FIXED_REFERENCE_JUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_CHECK:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_THERMOCOUPLE_CHECK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_AUTO_IMPEDANCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_THERMOCOUPLE_AUTO_IMPEDANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_EXTERNAL_REFERENCE_JUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_THERMOCOUPLE_EXTERNAL_REFERENCE_JUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_INTERNAL_REFERENCE_JUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_THERMOCOUPLE_INTERNAL_REFERENCE_JUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_SAMPLE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_TRIGGER_SAMPLE_COUNT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ATrigger* pIAgilent34980ATrigger = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ATrigger);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CLong _val;
					hr = pIAgilent34980ATrigger->get_SampleCount(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ATrigger->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TRIGGER_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_TRIGGER_COUNT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ATrigger* pIAgilent34980ATrigger = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ATrigger);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CLong _val;
					hr = pIAgilent34980ATrigger->get_Count(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ATrigger->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TRIGGER_SOURCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_TRIGGER_SOURCE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ATrigger* pIAgilent34980ATrigger = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ATrigger);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CLong _val;
					hr = pIAgilent34980ATrigger->get_Source((Agilent34980ATriggerSourceEnum*)_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ATrigger->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TRIGGER_TIMER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_TRIGGER_TIMER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DELAY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DELAY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DELAY_AUTO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DELAY_AUTO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_CHANNEL_COUNT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IIviSwtchChannels* pIIviSwtchChannels = NULL;
				hr = pDriver->QueryInterface(&pIIviSwtchChannels);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CLong _val;
					hr = pIIviSwtchChannels->get_Count(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIIviSwtchChannels->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_IS_DEBOUNCED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_IS_DEBOUNCED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_DMM_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_CAL_DMM_COUNT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADMM* pIAgilent34980ADMM = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADMM);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CLong _val;
					hr = pIAgilent34980ADMM->get_Count(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ADMM->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_CAL_DMM_MESSAGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_CAL_DMM_MESSAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_VALUE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_CAL_VALUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_LABEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_CHANNEL_LABEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SEQUENCE_CATALOG:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_SEQUENCE_CATALOG\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GETSEQUENCETRIGGERSOURCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_GETSEQUENCETRIGGERSOURCE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ARoute2* pIAgilent34980ARoute2 = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ARoute2);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34980ARoute2->get_SequenceTriggerSource(_identifier.GetVal(), (Agilent34980ASequenceTriggerSourceEnum*)_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ARoute2->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_IS_CONFIGURATION_CHANNEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_IS_CONFIGURATION_CHANNEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_SOURCE_CHANNEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_IS_SOURCE_CHANNEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_AC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_MAX_CARRY_AC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_AC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_MAX_SWITCHING_AC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_AC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_MAX_CARRY_AC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_AC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_MAX_SWITCHING_AC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_AC_VOLTAGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_MAX_AC_VOLTAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_BANDWIDTH:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_BANDWIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_DC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_MAX_CARRY_DC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_DC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_MAX_SWITCHING_DC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_DC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_MAX_CARRY_DC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_DC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_MAX_SWITCHING_DC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_DC_VOLTAGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_MAX_DC_VOLTAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHARACTERISTIC_IMPEDANCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_CHARACTERISTIC_IMPEDANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SETTLING_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_SETTLING_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_WIRE_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_WIRE_MODE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				CAtlArray<CString> arSelectors;
				CRepCapSelector repCapSelector(RepCapIdentifier);

				IIviSwtchChannels* pIIviSwtchChannels = NULL;
				hr = pDriver->QueryInterface(&pIIviSwtchChannels);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					status = repCapSelector.GetSelectors(Vi, false, 0, arSelectors);
					if (status == VI_SUCCESS)
					{
						IIviSwtchChannel* pIIviSwtchChannel = NULL;
						hr = pIIviSwtchChannels->get_Item(CComBSTR(arSelectors.GetAt(0)), &pIIviSwtchChannel);
						status = TranslateHRESULT(Vi, hr);
						if (SUCCEEDED(hr))
						{
							IIviSwtchCharacteristics* pIIviSwtchCharacteristics = NULL;
							hr = pIIviSwtchChannel->QueryInterface(&pIIviSwtchCharacteristics);
							status = TranslateHRESULT(Vi, hr);
							ATLASSERT(SUCCEEDED(hr));
							if (SUCCEEDED(hr))
							{
								CLong _val;
								hr = pIIviSwtchCharacteristics->get_WireMode(_val.GetPtr());
								status = TranslateHRESULT(Vi, hr);
								if (SUCCEEDED(hr))
								{
									status = _val.ToViDataType(AttributeValue);
								}
								pIIviSwtchCharacteristics->Release();
							}
							pIIviSwtchChannel->Release();
						}
					}
					pIIviSwtchChannels->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_ASYNC_TIMEOUT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_ASYNC_TIMEOUT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_CYCLE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_HANDSHAKE_CYCLE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_HANDSHAKE_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_HANDSHAKE_MODE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AHandshake* pIAgilent34950AHandshake = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AHandshake);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34950AHandshake->get_Mode(_identifier.GetVal(), (Agilent34950AHandshakeModeEnum*)_val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AHandshake->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_RATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_HANDSHAKE_RATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_STATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_HANDSHAKE_STATE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AHandshake* pIAgilent34950AHandshake = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AHandshake);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34950AHandshake->get_State(_identifier.GetVal(), (Agilent34950AStateEnum*)_val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AHandshake->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_SYNC_STROBE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_HANDSHAKE_SYNC_STROBE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AHandshake* pIAgilent34950AHandshake = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AHandshake);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34950AHandshake->get_SyncStrobe(_identifier.GetVal(), (Agilent34950AHandshakeStrobeSourceEnum*)_val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AHandshake->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_HANDSHAKE_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_DRIVE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_HANDSHAKE_DRIVE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AHandshake* pIAgilent34950AHandshake = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AHandshake);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34950AHandshake->get_Drive(_identifier.GetVal(), (Agilent34950AHandshakeLineTypeEnum*)_val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AHandshake->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_INPUT_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_INPUT_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARE_ACTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_COMPARE_ACTION\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AInputMemory* pIAgilent34950AInputMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AInputMemory);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34950AInputMemory->get_CompareAction(_identifier.GetVal(), (Agilent34950AActionEnum*)_val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AInputMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DATA_FORMAT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AInputMemory* pIAgilent34950AInputMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AInputMemory);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34950AInputMemory->get_DataFormat(_identifier.GetVal(), (Agilent34950ADataFormatEnum*)_val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AInputMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DATA_POINTS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DATA_POINTS\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AInputMemory* pIAgilent34950AInputMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AInputMemory);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34950AInputMemory->get_DataPoints(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AInputMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_ENABLE_INPUT_MEMORY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_ENABLE_INPUT_MEMORY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_INPUT_INTERRUPT_MODE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AInputMemory* pIAgilent34950AInputMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AInputMemory);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34950AInputMemory->get_InterruptMode(_identifier.GetVal(), (Agilent34950AReportConditionEnum*)_val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AInputMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_INPUT_INTERRUPT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_INPUT_INTERRUPT_POLARITY\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AInputMemory* pIAgilent34950AInputMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AInputMemory);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34950AInputMemory->get_InterruptPolarity(_identifier.GetVal(), (Agilent34950APolarityEnum*)_val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AInputMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_INPUT_INTERRUPT_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_SAMPLE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_INPUT_SAMPLE_COUNT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AInputMemory* pIAgilent34950AInputMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AInputMemory);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34950AInputMemory->get_SampleCount(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AInputMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_INPUT_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_INPUT_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_DRIVE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_OUTPUT_DRIVE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AOutput* pIAgilent34950AOutput = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AOutput);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34950AOutput->get_Drive(_identifier.GetVal(), (Agilent34950AHandshakeLineTypeEnum*)_val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AOutput->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_OUTPUT_VOLT_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_OUTPUT_VOLT_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_CYCLE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_OUTPUT_CYCLE_COUNT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AOutputMemory* pIAgilent34950AOutputMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AOutputMemory);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34950AOutputMemory->get_CycleCount(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AOutputMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_OUTPUT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_OUTPUT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_INTERRUPT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_OUTPUT_INTERRUPT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_INTERRUPT_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_OUTPUT_INTERRUPT_MODE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AOutputMemory* pIAgilent34950AOutputMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AOutputMemory);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34950AOutputMemory->get_InterruptMode(_identifier.GetVal(), (Agilent34950AOutputModeEnum*)_val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AOutputMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_OUTPUT_INTERRUPT_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_OUTPUT_INTERRUPT_POLARITY\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AOutputMemory* pIAgilent34950AOutputMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AOutputMemory);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34950AOutputMemory->get_InterruptPolarity(_identifier.GetVal(), (Agilent34950APolarityEnum*)_val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AOutputMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_OUTPUT_TRACE_SELECT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_OUTPUT_TRACE_SELECT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEMORY_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_MEMORY_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_CATALOG_34950A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_TRACE_CATALOG_34950A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_MEMORY_FREE_34950A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_TRACE_MEMORY_FREE_34950A\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ATrace* pIAgilent34950ATrace = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ATrace);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34950ATrace->get_MemoryFree(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950ATrace->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_FUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_FUNCTION\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ACounter* pIAgilent34950ACounter = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ACounter);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34950ACounter->get_Function(_identifier.GetVal(), (Agilent34950AFunctionEnum*)_val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950ACounter->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_GATE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_GATE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GATE_SOURCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_GATE_SOURCE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ACounter* pIAgilent34950ACounter = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ACounter);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34950ACounter->get_GateSource(_identifier.GetVal(), (Agilent34950AGateSourceEnum*)_val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950ACounter->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_GATE_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_GATE_POLARITY\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ACounter* pIAgilent34950ACounter = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ACounter);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34950ACounter->get_GatePolarity(_identifier.GetVal(), (Agilent34950APolarityEnum*)_val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950ACounter->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_COUNTER_SLOPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_COUNTER_SLOPE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ACounter* pIAgilent34950ACounter = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ACounter);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34950ACounter->get_Slope(_identifier.GetVal(), (Agilent34950ATotalizeSlopeEnum*)_val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950ACounter->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_COUNTER_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_COUNTER_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_READ_TYPE_34950A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_TOTALIZER_READ_TYPE_34950A\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ATotalizer* pIAgilent34950ATotalizer = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ATotalizer);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34950ATotalizer->get_ReadType(_identifier.GetVal(), (Agilent34950ATotalizeTypeEnum*)_val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950ATotalizer->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_COUNTER_FREQUENCY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_COUNTER_FREQUENCY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_PERIOD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_COUNTER_PERIOD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_WIDTH:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_PULSE_WIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_DUTY_CYCLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_PULSE_DUTY_CYCLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_TOTALIZE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_COUNTER_TOTALIZE_COUNT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AMeasurement* pIAgilent34950AMeasurement = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AMeasurement);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34950AMeasurement->get_TotalizeCount(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AMeasurement->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_COMPARISON_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_COMPARISON_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_COMPARISON_TYPE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34950ADigital->get_ComparisonType(_identifier.GetVal(), (Agilent34950AComparisonTypeEnum*)_val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950ADigital->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DIGITAL_DIRECTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DIGITAL_DIRECTION\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34950ADigital->get_Direction(_identifier.GetVal(), (Agilent34950ADirectionEnum*)_val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950ADigital->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_COMPARISON_DATA_BYTE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_COMPARISON_DATA_BYTE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CByte _val;
					hr = pIAgilent34950ADigital->get_ComparisonDataByte(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950ADigital->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_COMPARISON_DATA_WORD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_COMPARISON_DATA_WORD\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CShort _val;
					hr = pIAgilent34950ADigital->get_ComparisonDataWord(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950ADigital->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_COMPARISON_DATA_LONG_WORD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_COMPARISON_DATA_LONG_WORD\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34950ADigital->get_ComparisonDataLongWord(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950ADigital->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_COMPARISON_ALARM_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_COMPARISON_ALARM_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_MASK_BYTE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_COMPARISON_MASK_BYTE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CByte _val;
					hr = pIAgilent34950ADigital->get_ComparisonMaskByte(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950ADigital->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_COMPARISON_MASK_WORD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_COMPARISON_MASK_WORD\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CShort _val;
					hr = pIAgilent34950ADigital->get_ComparisonMaskWord(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950ADigital->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_COMPARISON_MASK_LONG_WORD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_COMPARISON_MASK_LONG_WORD\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34950ADigital->get_ComparisonMaskLongWord(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950ADigital->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DIGITAL_WIDTH:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DIGITAL_WIDTH\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34950ADigital->get_Width(_identifier.GetVal(), (Agilent34950AChannelWidthEnum*)_val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950ADigital->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DIGITAL_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DIGITAL_POLARITY\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34950ADigital->get_Polarity(_identifier.GetVal(), (Agilent34950APolarityEnum*)_val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950ADigital->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_CURRENT_SOURCE_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_CURRENT_SOURCE_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CURRENT_SOURCE_GAIN:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_CURRENT_SOURCE_GAIN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CURRENT_SOURCE_OFFSET:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_CURRENT_SOURCE_OFFSET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_STATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_OUTPUT_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OPERATION_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_OPERATION_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FUNCTION_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_FUNCTION_TYPE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951ASource* pIAgilent34951ASource = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951ASource);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34951ASource->get_FunctionType(_identifier.GetVal(), (Agilent34951AFunctionTypeEnum*)_val.GetPtr());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34951ASource->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_NUM_CYCLES:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_NUM_CYCLES\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951ASource* pIAgilent34951ASource = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951ASource);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34951ASource->get_NumCycles(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34951ASource->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_START_INDEX:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_START_INDEX\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951ASource* pIAgilent34951ASource = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951ASource);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34951ASource->get_StartIndex(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34951ASource->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TRACE_NAME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_TRACE_NAME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SOURCE_FREQUENCY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_SOURCE_FREQUENCY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_TRIGGER_SOURCE_34951A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_TRACE_TRIGGER_SOURCE_34951A\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951ATrigger* pIAgilent34951ATrigger = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951ATrigger);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34951ATrigger->get_Source(_identifier.GetVal(), (Agilent34951ATraceTriggerSourceEnum*)_val.GetPtr());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34951ATrigger->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TRACE_CLOCK_SOURCE_34951A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_TRACE_CLOCK_SOURCE_34951A\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951ATrigger* pIAgilent34951ATrigger = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951ATrigger);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34951ATrigger->get_ClockSource(_identifier.GetVal(), (Agilent34951AClockSourceEnum*)_val.GetPtr());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34951ATrigger->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TRACE_CLOCK_PERIOD_34951A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_TRACE_CLOCK_PERIOD_34951A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VOLTAGE_SOURCE_GAIN:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_VOLTAGE_SOURCE_GAIN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VOLTAGE_SOURCE_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_VOLTAGE_SOURCE_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VOLTAGE_SOURCE_OFFSET:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_VOLTAGE_SOURCE_OFFSET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DAC_VOLTAGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DAC_VOLTAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_MODE_34952A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_TOTALIZER_MODE_34952A\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34952A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34952ATotalize* pIAgilent34952ATotalize = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34952ATotalize);
				status = TranslateHRESULTAgilent34952A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34952ATotalize->get_Mode(_identifier.GetVal(), (Agilent34952ATotalizeThresholdModeEnum*)_val.GetPtr());
					status = TranslateHRESULTAgilent34952A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34952ATotalize->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_READ_TYPE_34952A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_TOTALIZER_READ_TYPE_34952A\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34952A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34952ATotalize* pIAgilent34952ATotalize = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34952ATotalize);
				status = TranslateHRESULTAgilent34952A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34952ATotalize->get_ReadType(_identifier.GetVal(), (Agilent34952ATotalizeTypeEnum*)_val.GetPtr());
					status = TranslateHRESULTAgilent34952A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34952ATotalize->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_SLOPE_34952A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_TOTALIZER_SLOPE_34952A\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34952A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34952ATotalize* pIAgilent34952ATotalize = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34952ATotalize);
				status = TranslateHRESULTAgilent34952A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34952ATotalize->get_Slope(_identifier.GetVal(), (Agilent34952ATotalizeSlopeEnum*)_val.GetPtr());
					status = TranslateHRESULTAgilent34952A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34952ATotalize->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DRIVE_STATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DRIVE_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PAIRED_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_PAIRED_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_PULSE_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_WIDTH_34945A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_PULSE_WIDTH_34945A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RECOVERY_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_RECOVERY_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SETTLE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_SETTLE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VERIFICATION_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_VERIFICATION_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VERIFICATION_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_VERIFICATION_POLARITY\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34945A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34945AChannel* pIAgilent34945AChannel = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34945AChannel);
				status = TranslateHRESULTAgilent34945A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34945AChannel->get_VerificationPolarity(_identifier.GetVal(), (Agilent34945APolarityEnum*)_val.GetPtr());
					status = TranslateHRESULTAgilent34945A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34945AChannel->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_STATE_AT_RESET:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_STATE_AT_RESET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_CHANNEL_LIMIT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DRIVE_CHANNEL_LIMIT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34945A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34945AModule* pIAgilent34945AModule = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34945AModule);
				status = TranslateHRESULTAgilent34945A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34945AModule->get_DriveChannelLimit(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34945A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34945AModule->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DRIVE_SOURCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DRIVE_SOURCE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34945A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34945AModule* pIAgilent34945AModule = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34945AModule);
				status = TranslateHRESULTAgilent34945A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34945AModule->get_DriveSource(_identifier.GetVal(), (Agilent34945ADriveSourceEnum*)_val.GetPtr());
					status = TranslateHRESULTAgilent34945A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34945AModule->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DRIVE_SOURCE_BOOT_STATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_DRIVE_SOURCE_BOOT_STATE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34945A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34945AModule* pIAgilent34945AModule = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34945AModule);
				status = TranslateHRESULTAgilent34945A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val;
					hr = pIAgilent34945AModule->get_DriveSourceBootState(_identifier.GetVal(), (Agilent34945ADriveSourceEnum*)_val.GetPtr());
					status = TranslateHRESULTAgilent34945A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34945AModule->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_IS_CLOSED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: AG34980A_ATTR_IS_CLOSED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						

		default:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViInt32: Invalid Attribute=%d\n"), AttributeID);

			status = IviSession_SetError(Vi, IVIC_ERROR_INVALID_ATTRIBUTE, "Attribute not recognized.");
			status = IVIC_ERROR_INVALID_ATTRIBUTE;
			break;
		}
	}
		
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetAttributeViReal64 ( ViSession Vi, ViConstString RepCapIdentifier, ViAttr AttributeID, ViReal64* AttributeValue )
{
	ViStatus status = VI_SUCCESS;

	switch (AttributeID)
	{
		case AG34980A_ATTR_SPECIFIC_DRIVER_DESCRIPTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_SPECIFIC_DRIVER_DESCRIPTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_PREFIX:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_SPECIFIC_DRIVER_PREFIX\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_VENDOR:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_SPECIFIC_DRIVER_VENDOR\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_REVISION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_SPECIFIC_DRIVER_REVISION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MAJOR_VERSION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MAJOR_VERSION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MINOR_VERSION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MINOR_VERSION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_LOGICAL_NAME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_LOGICAL_NAME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IO_RESOURCE_DESCRIPTOR:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_IO_RESOURCE_DESCRIPTOR\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CACHE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_CACHE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INTERCHANGE_CHECK:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_INTERCHANGE_CHECK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_QUERY_INSTRUMENT_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_QUERY_INSTRUMENT_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RANGE_CHECK:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_RANGE_CHECK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RECORD_COERCIONS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_RECORD_COERCIONS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SIMULATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_SIMULATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVER_SETUP:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DRIVER_SETUP\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INSTRUMENT_MANUFACTURER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_INSTRUMENT_MANUFACTURER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INSTRUMENT_MODEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_INSTRUMENT_MODEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INSTRUMENT_FIRMWARE_REVISION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_INSTRUMENT_FIRMWARE_REVISION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SUPPORTED_INSTRUMENT_MODELS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_SUPPORTED_INSTRUMENT_MODELS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GROUP_CAPABILITIES:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_GROUP_CAPABILITIES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_LOWER_LIMIT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_ALARM_LOWER_LIMIT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AAlarm* pIAgilent34980AAlarm = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AAlarm);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980AAlarm->get_LowerLimit(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AAlarm->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_ALARM_LOWER_LIMIT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_ALARM_LOWER_LIMIT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_ALARM_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_QUERYALARMQUEUE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_QUERYALARMQUEUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_SLOPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_ALARM_SLOPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_UPPER_LIMIT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_ALARM_UPPER_LIMIT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AAlarm* pIAgilent34980AAlarm = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AAlarm);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980AAlarm->get_UpperLimit(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AAlarm->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_ALARM_UPPER_LIMIT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_ALARM_UPPER_LIMIT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_VOLTAGE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_AC_VOLTAGE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_VOLTAGE_BANDWIDTH:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_AC_VOLTAGE_BANDWIDTH\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AACVoltage* pIAgilent34980AACVoltage = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AACVoltage);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980AACVoltage->get_Bandwidth(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AACVoltage->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_AC_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_AC_VOLTAGE_RANGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AACVoltage* pIAgilent34980AACVoltage = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AACVoltage);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980AACVoltage->get_Range(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AACVoltage->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_AC_CURRENT_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_AC_CURRENT_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_CURRENT_BANDWIDTH:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_AC_CURRENT_BANDWIDTH\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AACCurrent* pIAgilent34980AACCurrent = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AACCurrent);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980AACCurrent->get_Bandwidth(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AACCurrent->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_AC_CURRENT_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_AC_CURRENT_RANGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AACCurrent* pIAgilent34980AACCurrent = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AACCurrent);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980AACCurrent->get_Range(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AACCurrent->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_SECURITY_PASSWORD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_SECURITY_PASSWORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_MAINFRAME_MESSAGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_CAL_MAINFRAME_MESSAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_TOTAL_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_CAL_TOTAL_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_LINE_FREQUENCY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_CAL_LINE_FREQUENCY\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ACalibration* pIAgilent34980ACalibration = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ACalibration);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CDouble _val;
					hr = pIAgilent34980ACalibration->get_LineFrequency(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ACalibration->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_SECURITY_STATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_SECURITY_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DC_CURRENT_APERTURE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADCCurrent* pIAgilent34980ADCCurrent = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADCCurrent);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980ADCCurrent->get_Aperture(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ADCCurrent->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DC_CURRENT_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DC_CURRENT_NPLC\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADCCurrent* pIAgilent34980ADCCurrent = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADCCurrent);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980ADCCurrent->get_NPLC(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ADCCurrent->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DC_CURRENT_RANGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADCCurrent* pIAgilent34980ADCCurrent = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADCCurrent);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980ADCCurrent->get_Range(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ADCCurrent->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DC_CURRENT_RESOLUTION\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADCCurrent* pIAgilent34980ADCCurrent = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADCCurrent);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980ADCCurrent->get_Resolution(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ADCCurrent->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DC_CURRENT_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DC_VOLTAGE_APERTURE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADCVoltage* pIAgilent34980ADCVoltage = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADCVoltage);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980ADCVoltage->get_Aperture(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ADCVoltage->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DC_VOLTAGE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DC_VOLTAGE_NPLC\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADCVoltage* pIAgilent34980ADCVoltage = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADCVoltage);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980ADCVoltage->get_NPLC(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ADCVoltage->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DC_VOLTAGE_RANGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADCVoltage* pIAgilent34980ADCVoltage = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADCVoltage);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980ADCVoltage->get_Range(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ADCVoltage->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DC_VOLTAGE_RESOLUTION\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADCVoltage* pIAgilent34980ADCVoltage = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADCVoltage);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980ADCVoltage->get_Resolution(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ADCVoltage->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DC_VOLTAGE_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_AUTO_IMPEDANCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DC_VOLTAGE_AUTO_IMPEDANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GETRELAYCYCLES:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_GETRELAYCYCLES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DISPLAY_ENABLED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DISPLAY_ENABLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DISPLAY_TEXT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DISPLAY_TEXT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MONITOR_DATA:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_MONITOR_DATA\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADisplay* pIAgilent34980ADisplay = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADisplay);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CDouble _val;
					hr = pIAgilent34980ADisplay->get_MonitorData(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ADisplay->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_MONITOR_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_MONITOR_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MONITOR_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_MONITOR_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ENABLE_MONITOR_CHAN:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_ENABLE_MONITOR_CHAN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SELECT_MONITOR_CHAN:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_SELECT_MONITOR_CHAN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_FREQUENCY_APERTURE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AFrequency* pIAgilent34980AFrequency = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AFrequency);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980AFrequency->get_Aperture(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AFrequency->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE_AUTO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE_AUTO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_LOW_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_FREQUENCY_LOW_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AFrequency* pIAgilent34980AFrequency = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AFrequency);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980AFrequency->get_Range(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AFrequency->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_FRESISTANCE_APERTURE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AFResistance* pIAgilent34980AFResistance = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AFResistance);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980AFResistance->get_Aperture(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AFResistance->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_FRESISTANCE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_FRESISTANCE_NPLC\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AFResistance* pIAgilent34980AFResistance = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AFResistance);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980AFResistance->get_NPLC(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AFResistance->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_FRESISTANCE_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_FRESISTANCE_RANGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AFResistance* pIAgilent34980AFResistance = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AFResistance);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980AFResistance->get_Range(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AFResistance->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_FRESISTANCE_RESOLUTION\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AFResistance* pIAgilent34980AFResistance = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AFResistance);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980AFResistance->get_Resolution(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AFResistance->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_MEASUREMENT_READING_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_MEASUREMENT_READING_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEASUREMENT_FUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_MEASUREMENT_FUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AUTO_RECALL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_AUTO_RECALL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_NUMBER_OF_STATES:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_NUMBER_OF_STATES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEMORY_CATALOG:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_MEMORY_CATALOG\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PERIOD_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_PERIOD_APERTURE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980APeriod* pIAgilent34980APeriod = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980APeriod);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980APeriod->get_Aperture(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980APeriod->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_PERIOD_VOLTAGE_RANGE_AUTO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_PERIOD_VOLTAGE_RANGE_AUTO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PERIOD_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_PERIOD_VOLTAGE_RANGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980APeriod* pIAgilent34980APeriod = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980APeriod);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980APeriod->get_Range(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980APeriod->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_RESISTANCE_APERTURE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AResistance* pIAgilent34980AResistance = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AResistance);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980AResistance->get_Aperture(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AResistance->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_RESISTANCE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_RESISTANCE_NPLC\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AResistance* pIAgilent34980AResistance = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AResistance);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980AResistance->get_NPLC(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AResistance->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_RESISTANCE_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_RESISTANCE_RANGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AResistance* pIAgilent34980AResistance = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AResistance);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980AResistance->get_Range(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AResistance->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_RESISTANCE_RESOLUTION\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AResistance* pIAgilent34980AResistance = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AResistance);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980AResistance->get_Resolution(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AResistance->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_RESISTANCE_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_GAIN:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_SCALE_GAIN\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AScale* pIAgilent34980AScale = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AScale);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980AScale->get_Gain(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AScale->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_SCALE_OFFSET:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_SCALE_OFFSET\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AScale* pIAgilent34980AScale = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AScale);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980AScale->get_Offset(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AScale->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_SCALE_STATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_SCALE_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_UNIT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_SCALE_UNIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_AUTO_DELAY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_CHANNEL_AUTO_DELAY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_DELAY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_CHANNEL_DELAY\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ARoute* pIAgilent34980ARoute = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ARoute);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980ARoute->get_Delay(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ARoute->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_CHANNEL_FWIRE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_CHANNEL_FWIRE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ROUTE_DONE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_ROUTE_DONE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_IS_CLOSED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_CHANNEL_IS_CLOSED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_SCAN_SIZE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_CHANNEL_SCAN_SIZE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_SCAN_LIST:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_CHANNEL_SCAN_LIST\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_SCAN_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_CHANNEL_SCAN_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCAN_SWEEP_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_SCAN_SWEEP_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ORDERED_SCAN:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_ORDERED_SCAN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_AVERAGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_STATISTICS_AVERAGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AStatistics* pIAgilent34980AStatistics = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AStatistics);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980AStatistics->get_Average(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AStatistics->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_STATISTICS_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_STATISTICS_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MAX_VALUE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_STATISTICS_MAX_VALUE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AStatistics* pIAgilent34980AStatistics = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AStatistics);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980AStatistics->get_MaxValue(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AStatistics->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MAX_VALUE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_STATISTICS_MAX_VALUE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MIN_VALUE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_STATISTICS_MIN_VALUE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AStatistics* pIAgilent34980AStatistics = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AStatistics);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980AStatistics->get_MinValue(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AStatistics->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MIN_VALUE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_STATISTICS_MIN_VALUE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_PTPEAK:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_STATISTICS_PTPEAK\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AStatistics* pIAgilent34980AStatistics = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AStatistics);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980AStatistics->get_PTPeak(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AStatistics->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_SERIAL_POLL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_SERIAL_POLL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ASYNC_EVENTS_ENABLED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_ASYNC_EVENTS_ENABLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SYSTEM_DATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_SYSTEM_DATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DMM_ENABLED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DMM_ENABLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DMM_INSTALLED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DMM_INSTALLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_READING_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_READING_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SERIAL_NUMBER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_SERIAL_NUMBER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SYSTEM_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_SYSTEM_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TIMEOUT_MILLISECONDS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_TIMEOUT_MILLISECONDS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_LOCK_OWNER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_LOCK_OWNER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MODULE_EVENTS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_MODULE_EVENTS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_READING_UNITS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_TEMPERATURE_READING_UNITS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_TEMPERATURE_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_TEMPERATURE_NPLC\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ATemperature* pIAgilent34980ATemperature = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ATemperature);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980ATemperature->get_NPLC(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ATemperature->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_TRANSDUCERTYPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_TEMPERATURE_TRANSDUCERTYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_RESISTANCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_FRTD_RESISTANCE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AFRTD* pIAgilent34980AFRTD = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AFRTD);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980AFRTD->get_Resistance(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AFRTD->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_FRTD_ALPHA:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_FRTD_ALPHA\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_IS_EXTERNAL_REFERENCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_FRTD_IS_EXTERNAL_REFERENCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_FRTD_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_ALARM_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DATA_FORMAT_ALARM_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_CHANNEL_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DATA_FORMAT_CHANNEL_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_TIME_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DATA_FORMAT_TIME_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_TIME_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DATA_FORMAT_TIME_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_UNIT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DATA_FORMAT_UNIT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_RESISTANCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_RTD_RESISTANCE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ARTD* pIAgilent34980ARTD = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ARTD);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980ARTD->get_Resistance(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ARTD->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_RTD_ALPHA:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_RTD_ALPHA\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_IS_EXTERNAL_REFERENCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_RTD_IS_EXTERNAL_REFERENCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_RTD_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMISTOR_RESISTANCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_THERMISTOR_RESISTANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMISTOR_IS_EXTERNAL_REFERENCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_THERMISTOR_IS_EXTERNAL_REFERENCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_THERMOCOUPLE_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_JUNCTION_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_THERMOCOUPLE_JUNCTION_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_FIXED_REFERENCE_JUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_THERMOCOUPLE_FIXED_REFERENCE_JUNCTION\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AThermocouple* pIAgilent34980AThermocouple = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AThermocouple);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980AThermocouple->get_FixedReferenceJunction(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AThermocouple->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_CHECK:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_THERMOCOUPLE_CHECK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_AUTO_IMPEDANCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_THERMOCOUPLE_AUTO_IMPEDANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_EXTERNAL_REFERENCE_JUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_THERMOCOUPLE_EXTERNAL_REFERENCE_JUNCTION\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AThermocouple* pIAgilent34980AThermocouple = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AThermocouple);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CDouble _val;
					hr = pIAgilent34980AThermocouple->get_ExternalReferenceJunction(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AThermocouple->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_INTERNAL_REFERENCE_JUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_THERMOCOUPLE_INTERNAL_REFERENCE_JUNCTION\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AThermocouple* pIAgilent34980AThermocouple = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AThermocouple);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34980AThermocouple->get_InternalReferenceJunction(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AThermocouple->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TRIGGER_SAMPLE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_TRIGGER_SAMPLE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_TRIGGER_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_SOURCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_TRIGGER_SOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_TIMER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_TRIGGER_TIMER\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ATrigger* pIAgilent34980ATrigger = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ATrigger);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CDouble _val;
					hr = pIAgilent34980ATrigger->get_Timer(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ATrigger->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DELAY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DELAY\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ATrigger* pIAgilent34980ATrigger = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ATrigger);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CDouble _val;
					hr = pIAgilent34980ATrigger->get_Delay(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ATrigger->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DELAY_AUTO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DELAY_AUTO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_CHANNEL_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_DEBOUNCED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_IS_DEBOUNCED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_DMM_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_CAL_DMM_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_DMM_MESSAGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_CAL_DMM_MESSAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_VALUE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_CAL_VALUE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADMM* pIAgilent34980ADMM = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADMM);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CDouble _val;
					hr = pIAgilent34980ADMM->get_Value(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ADMM->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_CHANNEL_LABEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_CHANNEL_LABEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SEQUENCE_CATALOG:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_SEQUENCE_CATALOG\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GETSEQUENCETRIGGERSOURCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_GETSEQUENCETRIGGERSOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_CONFIGURATION_CHANNEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_IS_CONFIGURATION_CHANNEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_SOURCE_CHANNEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_IS_SOURCE_CHANNEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_AC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_MAX_CARRY_AC_CURRENT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				CAtlArray<CString> arSelectors;
				CRepCapSelector repCapSelector(RepCapIdentifier);

				IIviSwtchChannels* pIIviSwtchChannels = NULL;
				hr = pDriver->QueryInterface(&pIIviSwtchChannels);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					status = repCapSelector.GetSelectors(Vi, false, 0, arSelectors);
					if (status == VI_SUCCESS)
					{
						IIviSwtchChannel* pIIviSwtchChannel = NULL;
						hr = pIIviSwtchChannels->get_Item(CComBSTR(arSelectors.GetAt(0)), &pIIviSwtchChannel);
						status = TranslateHRESULT(Vi, hr);
						if (SUCCEEDED(hr))
						{
							IIviSwtchCharacteristics* pIIviSwtchCharacteristics = NULL;
							hr = pIIviSwtchChannel->QueryInterface(&pIIviSwtchCharacteristics);
							status = TranslateHRESULT(Vi, hr);
							ATLASSERT(SUCCEEDED(hr));
							if (SUCCEEDED(hr))
							{
								CDouble _val;
								hr = pIIviSwtchCharacteristics->get_ACCurrentCarryMax(_val.GetPtr());
								status = TranslateHRESULT(Vi, hr);
								if (SUCCEEDED(hr))
								{
									status = _val.ToViDataType(AttributeValue);
								}
								pIIviSwtchCharacteristics->Release();
							}
							pIIviSwtchChannel->Release();
						}
					}
					pIIviSwtchChannels->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_AC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_MAX_SWITCHING_AC_CURRENT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				CAtlArray<CString> arSelectors;
				CRepCapSelector repCapSelector(RepCapIdentifier);

				IIviSwtchChannels* pIIviSwtchChannels = NULL;
				hr = pDriver->QueryInterface(&pIIviSwtchChannels);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					status = repCapSelector.GetSelectors(Vi, false, 0, arSelectors);
					if (status == VI_SUCCESS)
					{
						IIviSwtchChannel* pIIviSwtchChannel = NULL;
						hr = pIIviSwtchChannels->get_Item(CComBSTR(arSelectors.GetAt(0)), &pIIviSwtchChannel);
						status = TranslateHRESULT(Vi, hr);
						if (SUCCEEDED(hr))
						{
							IIviSwtchCharacteristics* pIIviSwtchCharacteristics = NULL;
							hr = pIIviSwtchChannel->QueryInterface(&pIIviSwtchCharacteristics);
							status = TranslateHRESULT(Vi, hr);
							ATLASSERT(SUCCEEDED(hr));
							if (SUCCEEDED(hr))
							{
								CDouble _val;
								hr = pIIviSwtchCharacteristics->get_ACCurrentSwitchingMax(_val.GetPtr());
								status = TranslateHRESULT(Vi, hr);
								if (SUCCEEDED(hr))
								{
									status = _val.ToViDataType(AttributeValue);
								}
								pIIviSwtchCharacteristics->Release();
							}
							pIIviSwtchChannel->Release();
						}
					}
					pIIviSwtchChannels->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_AC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_MAX_CARRY_AC_POWER\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				CAtlArray<CString> arSelectors;
				CRepCapSelector repCapSelector(RepCapIdentifier);

				IIviSwtchChannels* pIIviSwtchChannels = NULL;
				hr = pDriver->QueryInterface(&pIIviSwtchChannels);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					status = repCapSelector.GetSelectors(Vi, false, 0, arSelectors);
					if (status == VI_SUCCESS)
					{
						IIviSwtchChannel* pIIviSwtchChannel = NULL;
						hr = pIIviSwtchChannels->get_Item(CComBSTR(arSelectors.GetAt(0)), &pIIviSwtchChannel);
						status = TranslateHRESULT(Vi, hr);
						if (SUCCEEDED(hr))
						{
							IIviSwtchCharacteristics* pIIviSwtchCharacteristics = NULL;
							hr = pIIviSwtchChannel->QueryInterface(&pIIviSwtchCharacteristics);
							status = TranslateHRESULT(Vi, hr);
							ATLASSERT(SUCCEEDED(hr));
							if (SUCCEEDED(hr))
							{
								CDouble _val;
								hr = pIIviSwtchCharacteristics->get_ACPowerCarryMax(_val.GetPtr());
								status = TranslateHRESULT(Vi, hr);
								if (SUCCEEDED(hr))
								{
									status = _val.ToViDataType(AttributeValue);
								}
								pIIviSwtchCharacteristics->Release();
							}
							pIIviSwtchChannel->Release();
						}
					}
					pIIviSwtchChannels->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_AC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_MAX_SWITCHING_AC_POWER\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				CAtlArray<CString> arSelectors;
				CRepCapSelector repCapSelector(RepCapIdentifier);

				IIviSwtchChannels* pIIviSwtchChannels = NULL;
				hr = pDriver->QueryInterface(&pIIviSwtchChannels);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					status = repCapSelector.GetSelectors(Vi, false, 0, arSelectors);
					if (status == VI_SUCCESS)
					{
						IIviSwtchChannel* pIIviSwtchChannel = NULL;
						hr = pIIviSwtchChannels->get_Item(CComBSTR(arSelectors.GetAt(0)), &pIIviSwtchChannel);
						status = TranslateHRESULT(Vi, hr);
						if (SUCCEEDED(hr))
						{
							IIviSwtchCharacteristics* pIIviSwtchCharacteristics = NULL;
							hr = pIIviSwtchChannel->QueryInterface(&pIIviSwtchCharacteristics);
							status = TranslateHRESULT(Vi, hr);
							ATLASSERT(SUCCEEDED(hr));
							if (SUCCEEDED(hr))
							{
								CDouble _val;
								hr = pIIviSwtchCharacteristics->get_ACPowerSwitchingMax(_val.GetPtr());
								status = TranslateHRESULT(Vi, hr);
								if (SUCCEEDED(hr))
								{
									status = _val.ToViDataType(AttributeValue);
								}
								pIIviSwtchCharacteristics->Release();
							}
							pIIviSwtchChannel->Release();
						}
					}
					pIIviSwtchChannels->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_MAX_AC_VOLTAGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_MAX_AC_VOLTAGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				CAtlArray<CString> arSelectors;
				CRepCapSelector repCapSelector(RepCapIdentifier);

				IIviSwtchChannels* pIIviSwtchChannels = NULL;
				hr = pDriver->QueryInterface(&pIIviSwtchChannels);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					status = repCapSelector.GetSelectors(Vi, false, 0, arSelectors);
					if (status == VI_SUCCESS)
					{
						IIviSwtchChannel* pIIviSwtchChannel = NULL;
						hr = pIIviSwtchChannels->get_Item(CComBSTR(arSelectors.GetAt(0)), &pIIviSwtchChannel);
						status = TranslateHRESULT(Vi, hr);
						if (SUCCEEDED(hr))
						{
							IIviSwtchCharacteristics* pIIviSwtchCharacteristics = NULL;
							hr = pIIviSwtchChannel->QueryInterface(&pIIviSwtchCharacteristics);
							status = TranslateHRESULT(Vi, hr);
							ATLASSERT(SUCCEEDED(hr));
							if (SUCCEEDED(hr))
							{
								CDouble _val;
								hr = pIIviSwtchCharacteristics->get_ACVoltageMax(_val.GetPtr());
								status = TranslateHRESULT(Vi, hr);
								if (SUCCEEDED(hr))
								{
									status = _val.ToViDataType(AttributeValue);
								}
								pIIviSwtchCharacteristics->Release();
							}
							pIIviSwtchChannel->Release();
						}
					}
					pIIviSwtchChannels->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_BANDWIDTH:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_BANDWIDTH\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				CAtlArray<CString> arSelectors;
				CRepCapSelector repCapSelector(RepCapIdentifier);

				IIviSwtchChannels* pIIviSwtchChannels = NULL;
				hr = pDriver->QueryInterface(&pIIviSwtchChannels);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					status = repCapSelector.GetSelectors(Vi, false, 0, arSelectors);
					if (status == VI_SUCCESS)
					{
						IIviSwtchChannel* pIIviSwtchChannel = NULL;
						hr = pIIviSwtchChannels->get_Item(CComBSTR(arSelectors.GetAt(0)), &pIIviSwtchChannel);
						status = TranslateHRESULT(Vi, hr);
						if (SUCCEEDED(hr))
						{
							IIviSwtchCharacteristics* pIIviSwtchCharacteristics = NULL;
							hr = pIIviSwtchChannel->QueryInterface(&pIIviSwtchCharacteristics);
							status = TranslateHRESULT(Vi, hr);
							ATLASSERT(SUCCEEDED(hr));
							if (SUCCEEDED(hr))
							{
								CDouble _val;
								hr = pIIviSwtchCharacteristics->get_Bandwidth(_val.GetPtr());
								status = TranslateHRESULT(Vi, hr);
								if (SUCCEEDED(hr))
								{
									status = _val.ToViDataType(AttributeValue);
								}
								pIIviSwtchCharacteristics->Release();
							}
							pIIviSwtchChannel->Release();
						}
					}
					pIIviSwtchChannels->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_DC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_MAX_CARRY_DC_CURRENT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				CAtlArray<CString> arSelectors;
				CRepCapSelector repCapSelector(RepCapIdentifier);

				IIviSwtchChannels* pIIviSwtchChannels = NULL;
				hr = pDriver->QueryInterface(&pIIviSwtchChannels);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					status = repCapSelector.GetSelectors(Vi, false, 0, arSelectors);
					if (status == VI_SUCCESS)
					{
						IIviSwtchChannel* pIIviSwtchChannel = NULL;
						hr = pIIviSwtchChannels->get_Item(CComBSTR(arSelectors.GetAt(0)), &pIIviSwtchChannel);
						status = TranslateHRESULT(Vi, hr);
						if (SUCCEEDED(hr))
						{
							IIviSwtchCharacteristics* pIIviSwtchCharacteristics = NULL;
							hr = pIIviSwtchChannel->QueryInterface(&pIIviSwtchCharacteristics);
							status = TranslateHRESULT(Vi, hr);
							ATLASSERT(SUCCEEDED(hr));
							if (SUCCEEDED(hr))
							{
								CDouble _val;
								hr = pIIviSwtchCharacteristics->get_DCCurrentCarryMax(_val.GetPtr());
								status = TranslateHRESULT(Vi, hr);
								if (SUCCEEDED(hr))
								{
									status = _val.ToViDataType(AttributeValue);
								}
								pIIviSwtchCharacteristics->Release();
							}
							pIIviSwtchChannel->Release();
						}
					}
					pIIviSwtchChannels->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_DC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_MAX_SWITCHING_DC_CURRENT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				CAtlArray<CString> arSelectors;
				CRepCapSelector repCapSelector(RepCapIdentifier);

				IIviSwtchChannels* pIIviSwtchChannels = NULL;
				hr = pDriver->QueryInterface(&pIIviSwtchChannels);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					status = repCapSelector.GetSelectors(Vi, false, 0, arSelectors);
					if (status == VI_SUCCESS)
					{
						IIviSwtchChannel* pIIviSwtchChannel = NULL;
						hr = pIIviSwtchChannels->get_Item(CComBSTR(arSelectors.GetAt(0)), &pIIviSwtchChannel);
						status = TranslateHRESULT(Vi, hr);
						if (SUCCEEDED(hr))
						{
							IIviSwtchCharacteristics* pIIviSwtchCharacteristics = NULL;
							hr = pIIviSwtchChannel->QueryInterface(&pIIviSwtchCharacteristics);
							status = TranslateHRESULT(Vi, hr);
							ATLASSERT(SUCCEEDED(hr));
							if (SUCCEEDED(hr))
							{
								CDouble _val;
								hr = pIIviSwtchCharacteristics->get_DCCurrentSwitchingMax(_val.GetPtr());
								status = TranslateHRESULT(Vi, hr);
								if (SUCCEEDED(hr))
								{
									status = _val.ToViDataType(AttributeValue);
								}
								pIIviSwtchCharacteristics->Release();
							}
							pIIviSwtchChannel->Release();
						}
					}
					pIIviSwtchChannels->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_DC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_MAX_CARRY_DC_POWER\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				CAtlArray<CString> arSelectors;
				CRepCapSelector repCapSelector(RepCapIdentifier);

				IIviSwtchChannels* pIIviSwtchChannels = NULL;
				hr = pDriver->QueryInterface(&pIIviSwtchChannels);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					status = repCapSelector.GetSelectors(Vi, false, 0, arSelectors);
					if (status == VI_SUCCESS)
					{
						IIviSwtchChannel* pIIviSwtchChannel = NULL;
						hr = pIIviSwtchChannels->get_Item(CComBSTR(arSelectors.GetAt(0)), &pIIviSwtchChannel);
						status = TranslateHRESULT(Vi, hr);
						if (SUCCEEDED(hr))
						{
							IIviSwtchCharacteristics* pIIviSwtchCharacteristics = NULL;
							hr = pIIviSwtchChannel->QueryInterface(&pIIviSwtchCharacteristics);
							status = TranslateHRESULT(Vi, hr);
							ATLASSERT(SUCCEEDED(hr));
							if (SUCCEEDED(hr))
							{
								CDouble _val;
								hr = pIIviSwtchCharacteristics->get_DCPowerCarryMax(_val.GetPtr());
								status = TranslateHRESULT(Vi, hr);
								if (SUCCEEDED(hr))
								{
									status = _val.ToViDataType(AttributeValue);
								}
								pIIviSwtchCharacteristics->Release();
							}
							pIIviSwtchChannel->Release();
						}
					}
					pIIviSwtchChannels->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_DC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_MAX_SWITCHING_DC_POWER\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				CAtlArray<CString> arSelectors;
				CRepCapSelector repCapSelector(RepCapIdentifier);

				IIviSwtchChannels* pIIviSwtchChannels = NULL;
				hr = pDriver->QueryInterface(&pIIviSwtchChannels);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					status = repCapSelector.GetSelectors(Vi, false, 0, arSelectors);
					if (status == VI_SUCCESS)
					{
						IIviSwtchChannel* pIIviSwtchChannel = NULL;
						hr = pIIviSwtchChannels->get_Item(CComBSTR(arSelectors.GetAt(0)), &pIIviSwtchChannel);
						status = TranslateHRESULT(Vi, hr);
						if (SUCCEEDED(hr))
						{
							IIviSwtchCharacteristics* pIIviSwtchCharacteristics = NULL;
							hr = pIIviSwtchChannel->QueryInterface(&pIIviSwtchCharacteristics);
							status = TranslateHRESULT(Vi, hr);
							ATLASSERT(SUCCEEDED(hr));
							if (SUCCEEDED(hr))
							{
								CDouble _val;
								hr = pIIviSwtchCharacteristics->get_DCPowerSwitchingMax(_val.GetPtr());
								status = TranslateHRESULT(Vi, hr);
								if (SUCCEEDED(hr))
								{
									status = _val.ToViDataType(AttributeValue);
								}
								pIIviSwtchCharacteristics->Release();
							}
							pIIviSwtchChannel->Release();
						}
					}
					pIIviSwtchChannels->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_MAX_DC_VOLTAGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_MAX_DC_VOLTAGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				CAtlArray<CString> arSelectors;
				CRepCapSelector repCapSelector(RepCapIdentifier);

				IIviSwtchChannels* pIIviSwtchChannels = NULL;
				hr = pDriver->QueryInterface(&pIIviSwtchChannels);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					status = repCapSelector.GetSelectors(Vi, false, 0, arSelectors);
					if (status == VI_SUCCESS)
					{
						IIviSwtchChannel* pIIviSwtchChannel = NULL;
						hr = pIIviSwtchChannels->get_Item(CComBSTR(arSelectors.GetAt(0)), &pIIviSwtchChannel);
						status = TranslateHRESULT(Vi, hr);
						if (SUCCEEDED(hr))
						{
							IIviSwtchCharacteristics* pIIviSwtchCharacteristics = NULL;
							hr = pIIviSwtchChannel->QueryInterface(&pIIviSwtchCharacteristics);
							status = TranslateHRESULT(Vi, hr);
							ATLASSERT(SUCCEEDED(hr));
							if (SUCCEEDED(hr))
							{
								CDouble _val;
								hr = pIIviSwtchCharacteristics->get_DCVoltageMax(_val.GetPtr());
								status = TranslateHRESULT(Vi, hr);
								if (SUCCEEDED(hr))
								{
									status = _val.ToViDataType(AttributeValue);
								}
								pIIviSwtchCharacteristics->Release();
							}
							pIIviSwtchChannel->Release();
						}
					}
					pIIviSwtchChannels->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_CHARACTERISTIC_IMPEDANCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_CHARACTERISTIC_IMPEDANCE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				CAtlArray<CString> arSelectors;
				CRepCapSelector repCapSelector(RepCapIdentifier);

				IIviSwtchChannels* pIIviSwtchChannels = NULL;
				hr = pDriver->QueryInterface(&pIIviSwtchChannels);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					status = repCapSelector.GetSelectors(Vi, false, 0, arSelectors);
					if (status == VI_SUCCESS)
					{
						IIviSwtchChannel* pIIviSwtchChannel = NULL;
						hr = pIIviSwtchChannels->get_Item(CComBSTR(arSelectors.GetAt(0)), &pIIviSwtchChannel);
						status = TranslateHRESULT(Vi, hr);
						if (SUCCEEDED(hr))
						{
							IIviSwtchCharacteristics* pIIviSwtchCharacteristics = NULL;
							hr = pIIviSwtchChannel->QueryInterface(&pIIviSwtchCharacteristics);
							status = TranslateHRESULT(Vi, hr);
							ATLASSERT(SUCCEEDED(hr));
							if (SUCCEEDED(hr))
							{
								CDouble _val;
								hr = pIIviSwtchCharacteristics->get_Impedance(_val.GetPtr());
								status = TranslateHRESULT(Vi, hr);
								if (SUCCEEDED(hr))
								{
									status = _val.ToViDataType(AttributeValue);
								}
								pIIviSwtchCharacteristics->Release();
							}
							pIIviSwtchChannel->Release();
						}
					}
					pIIviSwtchChannels->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_SETTLING_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_SETTLING_TIME\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				CAtlArray<CString> arSelectors;
				CRepCapSelector repCapSelector(RepCapIdentifier);

				IIviSwtchChannels* pIIviSwtchChannels = NULL;
				hr = pDriver->QueryInterface(&pIIviSwtchChannels);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					status = repCapSelector.GetSelectors(Vi, false, 0, arSelectors);
					if (status == VI_SUCCESS)
					{
						IIviSwtchChannel* pIIviSwtchChannel = NULL;
						hr = pIIviSwtchChannels->get_Item(CComBSTR(arSelectors.GetAt(0)), &pIIviSwtchChannel);
						status = TranslateHRESULT(Vi, hr);
						if (SUCCEEDED(hr))
						{
							IIviSwtchCharacteristics* pIIviSwtchCharacteristics = NULL;
							hr = pIIviSwtchChannel->QueryInterface(&pIIviSwtchCharacteristics);
							status = TranslateHRESULT(Vi, hr);
							ATLASSERT(SUCCEEDED(hr));
							if (SUCCEEDED(hr))
							{
								CDouble _val;
								hr = pIIviSwtchCharacteristics->get_SettlingTime(_val.GetPtr());
								status = TranslateHRESULT(Vi, hr);
								if (SUCCEEDED(hr))
								{
									status = _val.ToViDataType(AttributeValue);
								}
								pIIviSwtchCharacteristics->Release();
							}
							pIIviSwtchChannel->Release();
						}
					}
					pIIviSwtchChannels->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_WIRE_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_WIRE_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ASYNC_TIMEOUT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_ASYNC_TIMEOUT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AHandshake* pIAgilent34950AHandshake = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AHandshake);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34950AHandshake->get_AsyncTimeout(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AHandshake->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_CYCLE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_HANDSHAKE_CYCLE_TIME\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AHandshake* pIAgilent34950AHandshake = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AHandshake);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34950AHandshake->get_CycleTime(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AHandshake->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_HANDSHAKE_LEVEL\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AHandshake* pIAgilent34950AHandshake = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AHandshake);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34950AHandshake->get_Level(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AHandshake->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_HANDSHAKE_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_RATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_HANDSHAKE_RATE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AHandshake* pIAgilent34950AHandshake = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AHandshake);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34950AHandshake->get_Rate(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AHandshake->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_STATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_HANDSHAKE_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_SYNC_STROBE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_HANDSHAKE_SYNC_STROBE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_HANDSHAKE_THRESHOLD\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AHandshake* pIAgilent34950AHandshake = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AHandshake);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34950AHandshake->get_Threshold(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AHandshake->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_DRIVE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_HANDSHAKE_DRIVE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_INPUT_THRESHOLD\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AInput* pIAgilent34950AInput = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AInput);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34950AInput->get_Threshold(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AInput->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_COMPARE_ACTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_COMPARE_ACTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DATA_FORMAT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_POINTS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DATA_POINTS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ENABLE_INPUT_MEMORY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_ENABLE_INPUT_MEMORY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_INPUT_INTERRUPT_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_INPUT_INTERRUPT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_INPUT_INTERRUPT_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_INPUT_INTERRUPT_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_SAMPLE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_INPUT_SAMPLE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_INPUT_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_DRIVE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_OUTPUT_DRIVE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_VOLT_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_OUTPUT_VOLT_LEVEL\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AOutput* pIAgilent34950AOutput = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AOutput);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34950AOutput->get_VoltLevel(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AOutput->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_OUTPUT_CYCLE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_OUTPUT_CYCLE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_OUTPUT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_INTERRUPT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_OUTPUT_INTERRUPT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_INTERRUPT_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_OUTPUT_INTERRUPT_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_INTERRUPT_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_OUTPUT_INTERRUPT_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_TRACE_SELECT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_OUTPUT_TRACE_SELECT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEMORY_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_MEMORY_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_CATALOG_34950A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_TRACE_CATALOG_34950A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_MEMORY_FREE_34950A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_TRACE_MEMORY_FREE_34950A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_FUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GATE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_GATE_TIME\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ACounter* pIAgilent34950ACounter = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ACounter);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34950ACounter->get_GateTime(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950ACounter->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_GATE_SOURCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_GATE_SOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GATE_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_GATE_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_SLOPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_COUNTER_SLOPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_COUNTER_THRESHOLD\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ACounter* pIAgilent34950ACounter = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ACounter);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34950ACounter->get_Threshold(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950ACounter->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_READ_TYPE_34950A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_TOTALIZER_READ_TYPE_34950A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_FREQUENCY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_COUNTER_FREQUENCY\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AMeasurement* pIAgilent34950AMeasurement = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AMeasurement);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34950AMeasurement->get_Frequency(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AMeasurement->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_COUNTER_PERIOD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_COUNTER_PERIOD\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AMeasurement* pIAgilent34950AMeasurement = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AMeasurement);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34950AMeasurement->get_Period(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AMeasurement->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_PULSE_WIDTH:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_PULSE_WIDTH\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AMeasurement* pIAgilent34950AMeasurement = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AMeasurement);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34950AMeasurement->get_PulseWidth(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AMeasurement->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_PULSE_DUTY_CYCLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_PULSE_DUTY_CYCLE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AMeasurement* pIAgilent34950AMeasurement = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AMeasurement);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34950AMeasurement->get_PulseDutyCycle(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AMeasurement->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_COUNTER_TOTALIZE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_COUNTER_TOTALIZE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_COMPARISON_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_COMPARISON_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DIGITAL_DIRECTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DIGITAL_DIRECTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_DATA_BYTE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_COMPARISON_DATA_BYTE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_DATA_WORD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_COMPARISON_DATA_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_DATA_LONG_WORD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_COMPARISON_DATA_LONG_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_ALARM_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_COMPARISON_ALARM_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_MASK_BYTE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_COMPARISON_MASK_BYTE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_MASK_WORD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_COMPARISON_MASK_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_MASK_LONG_WORD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_COMPARISON_MASK_LONG_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DIGITAL_WIDTH:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DIGITAL_WIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DIGITAL_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DIGITAL_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CURRENT_SOURCE_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_CURRENT_SOURCE_LEVEL\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951ACurrent* pIAgilent34951ACurrent = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951ACurrent);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34951ACurrent->get_Level(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34951ACurrent->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_CURRENT_SOURCE_GAIN:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_CURRENT_SOURCE_GAIN\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951ACurrent* pIAgilent34951ACurrent = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951ACurrent);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34951ACurrent->get_Gain(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34951ACurrent->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_CURRENT_SOURCE_OFFSET:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_CURRENT_SOURCE_OFFSET\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951ACurrent* pIAgilent34951ACurrent = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951ACurrent);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34951ACurrent->get_Offset(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34951ACurrent->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_OUTPUT_STATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_OUTPUT_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OPERATION_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_OPERATION_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FUNCTION_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_FUNCTION_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_NUM_CYCLES:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_NUM_CYCLES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_START_INDEX:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_START_INDEX\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_NAME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_TRACE_NAME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SOURCE_FREQUENCY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_SOURCE_FREQUENCY\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951ASource* pIAgilent34951ASource = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951ASource);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34951ASource->get_Frequency(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34951ASource->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TRACE_TRIGGER_SOURCE_34951A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_TRACE_TRIGGER_SOURCE_34951A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_CLOCK_SOURCE_34951A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_TRACE_CLOCK_SOURCE_34951A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_CLOCK_PERIOD_34951A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_TRACE_CLOCK_PERIOD_34951A\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951ATrigger* pIAgilent34951ATrigger = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951ATrigger);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34951ATrigger->get_ClockPeriod(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34951ATrigger->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_VOLTAGE_SOURCE_GAIN:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_VOLTAGE_SOURCE_GAIN\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951AVoltage* pIAgilent34951AVoltage = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951AVoltage);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34951AVoltage->get_Gain(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34951AVoltage->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_VOLTAGE_SOURCE_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_VOLTAGE_SOURCE_LEVEL\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951AVoltage* pIAgilent34951AVoltage = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951AVoltage);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34951AVoltage->get_Level(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34951AVoltage->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_VOLTAGE_SOURCE_OFFSET:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_VOLTAGE_SOURCE_OFFSET\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951AVoltage* pIAgilent34951AVoltage = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951AVoltage);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34951AVoltage->get_Offset(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34951AVoltage->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DAC_VOLTAGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DAC_VOLTAGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34952A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34952ADAC* pIAgilent34952ADAC = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34952ADAC);
				status = TranslateHRESULTAgilent34952A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34952ADAC->get_Voltage(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34952A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34952ADAC->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_MODE_34952A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_TOTALIZER_MODE_34952A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_READ_TYPE_34952A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_TOTALIZER_READ_TYPE_34952A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_SLOPE_34952A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_TOTALIZER_SLOPE_34952A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_STATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DRIVE_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PAIRED_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_PAIRED_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_PULSE_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_WIDTH_34945A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_PULSE_WIDTH_34945A\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34945A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34945AChannel* pIAgilent34945AChannel = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34945AChannel);
				status = TranslateHRESULTAgilent34945A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34945AChannel->get_PulseWidth(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34945A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34945AChannel->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_RECOVERY_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_RECOVERY_TIME\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34945A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34945AChannel* pIAgilent34945AChannel = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34945AChannel);
				status = TranslateHRESULTAgilent34945A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34945AChannel->get_RecoveryTime(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34945A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34945AChannel->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_SETTLE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_SETTLE_TIME\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34945A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34945AChannel* pIAgilent34945AChannel = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34945AChannel);
				status = TranslateHRESULTAgilent34945A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val;
					hr = pIAgilent34945AChannel->get_SettleTime(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34945A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34945AChannel->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_VERIFICATION_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_VERIFICATION_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VERIFICATION_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_VERIFICATION_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATE_AT_RESET:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_STATE_AT_RESET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_CHANNEL_LIMIT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DRIVE_CHANNEL_LIMIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_SOURCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DRIVE_SOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_SOURCE_BOOT_STATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_DRIVE_SOURCE_BOOT_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_CLOSED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: AG34980A_ATTR_IS_CLOSED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						

		default:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViReal64: Invalid Attribute=%d\n"), AttributeID);

			status = IviSession_SetError(Vi, IVIC_ERROR_INVALID_ATTRIBUTE, "Attribute not recognized.");
			status = IVIC_ERROR_INVALID_ATTRIBUTE;
			break;
		}
	}
		
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetAttributeViBoolean ( ViSession Vi, ViConstString RepCapIdentifier, ViAttr AttributeID, ViBoolean* AttributeValue )
{
	ViStatus status = VI_SUCCESS;

	switch (AttributeID)
	{
		case AG34980A_ATTR_SPECIFIC_DRIVER_DESCRIPTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_SPECIFIC_DRIVER_DESCRIPTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_PREFIX:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_SPECIFIC_DRIVER_PREFIX\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_VENDOR:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_SPECIFIC_DRIVER_VENDOR\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_REVISION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_SPECIFIC_DRIVER_REVISION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MAJOR_VERSION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MAJOR_VERSION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MINOR_VERSION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MINOR_VERSION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_LOGICAL_NAME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_LOGICAL_NAME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IO_RESOURCE_DESCRIPTOR:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_IO_RESOURCE_DESCRIPTOR\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CACHE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_CACHE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IIviDriverOperation* pIIviDriverOperation = NULL;
				hr = pDriver->QueryInterface(&pIIviDriverOperation);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val;
					hr = pIIviDriverOperation->get_Cache(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIIviDriverOperation->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_INTERCHANGE_CHECK:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_INTERCHANGE_CHECK\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IIviDriverOperation* pIIviDriverOperation = NULL;
				hr = pDriver->QueryInterface(&pIIviDriverOperation);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val;
					hr = pIIviDriverOperation->get_InterchangeCheck(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIIviDriverOperation->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_QUERY_INSTRUMENT_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_QUERY_INSTRUMENT_STATUS\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IIviDriverOperation* pIIviDriverOperation = NULL;
				hr = pDriver->QueryInterface(&pIIviDriverOperation);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val;
					hr = pIIviDriverOperation->get_QueryInstrumentStatus(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIIviDriverOperation->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_RANGE_CHECK:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_RANGE_CHECK\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IIviDriverOperation* pIIviDriverOperation = NULL;
				hr = pDriver->QueryInterface(&pIIviDriverOperation);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val;
					hr = pIIviDriverOperation->get_RangeCheck(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIIviDriverOperation->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_RECORD_COERCIONS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_RECORD_COERCIONS\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IIviDriverOperation* pIIviDriverOperation = NULL;
				hr = pDriver->QueryInterface(&pIIviDriverOperation);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val;
					hr = pIIviDriverOperation->get_RecordCoercions(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIIviDriverOperation->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_SIMULATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_SIMULATE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IIviDriverOperation* pIIviDriverOperation = NULL;
				hr = pDriver->QueryInterface(&pIIviDriverOperation);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val;
					hr = pIIviDriverOperation->get_Simulate(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIIviDriverOperation->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DRIVER_SETUP:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DRIVER_SETUP\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INSTRUMENT_MANUFACTURER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_INSTRUMENT_MANUFACTURER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INSTRUMENT_MODEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_INSTRUMENT_MODEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INSTRUMENT_FIRMWARE_REVISION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_INSTRUMENT_FIRMWARE_REVISION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SUPPORTED_INSTRUMENT_MODELS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_SUPPORTED_INSTRUMENT_MODELS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GROUP_CAPABILITIES:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_GROUP_CAPABILITIES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_LOWER_LIMIT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_ALARM_LOWER_LIMIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_LOWER_LIMIT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_ALARM_LOWER_LIMIT_ENABLE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AAlarm* pIAgilent34980AAlarm = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AAlarm);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34980AAlarm->get_LowerLimitEnable(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AAlarm->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_ALARM_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_ALARM_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_QUERYALARMQUEUE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_QUERYALARMQUEUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_SLOPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_ALARM_SLOPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_UPPER_LIMIT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_ALARM_UPPER_LIMIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_UPPER_LIMIT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_ALARM_UPPER_LIMIT_ENABLE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AAlarm* pIAgilent34980AAlarm = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AAlarm);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34980AAlarm->get_UpperLimitEnable(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AAlarm->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_AC_VOLTAGE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_AC_VOLTAGE_AUTORANGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AACVoltage* pIAgilent34980AACVoltage = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AACVoltage);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34980AACVoltage->get_AutoRange(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AACVoltage->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_AC_VOLTAGE_BANDWIDTH:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_AC_VOLTAGE_BANDWIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_AC_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_CURRENT_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_AC_CURRENT_AUTORANGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AACCurrent* pIAgilent34980AACCurrent = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AACCurrent);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34980AACCurrent->get_AutoRange(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AACCurrent->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_AC_CURRENT_BANDWIDTH:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_AC_CURRENT_BANDWIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_CURRENT_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_AC_CURRENT_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SECURITY_PASSWORD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_SECURITY_PASSWORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_MAINFRAME_MESSAGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_CAL_MAINFRAME_MESSAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_TOTAL_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_CAL_TOTAL_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_LINE_FREQUENCY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_CAL_LINE_FREQUENCY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SECURITY_STATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_SECURITY_STATE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ACalibration* pIAgilent34980ACalibration = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ACalibration);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val;
					hr = pIAgilent34980ACalibration->get_SecurityState(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ACalibration->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DC_CURRENT_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DC_CURRENT_AUTORANGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADCCurrent* pIAgilent34980ADCCurrent = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADCCurrent);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34980ADCCurrent->get_AutoRange(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ADCCurrent->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DC_CURRENT_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DC_CURRENT_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DC_CURRENT_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DC_CURRENT_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DC_VOLTAGE_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DC_VOLTAGE_AUTORANGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADCVoltage* pIAgilent34980ADCVoltage = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADCVoltage);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34980ADCVoltage->get_AutoRange(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ADCVoltage->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DC_VOLTAGE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DC_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DC_VOLTAGE_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DC_VOLTAGE_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_AUTO_IMPEDANCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DC_VOLTAGE_AUTO_IMPEDANCE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADCVoltage* pIAgilent34980ADCVoltage = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADCVoltage);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34980ADCVoltage->get_AutoImpedance(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ADCVoltage->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_GETRELAYCYCLES:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_GETRELAYCYCLES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DISPLAY_ENABLED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DISPLAY_ENABLED\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADisplay* pIAgilent34980ADisplay = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADisplay);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val;
					hr = pIAgilent34980ADisplay->get_DisplayEnabled(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ADisplay->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DISPLAY_TEXT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DISPLAY_TEXT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MONITOR_DATA:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_MONITOR_DATA\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MONITOR_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_MONITOR_ENABLE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADisplay* pIAgilent34980ADisplay = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADisplay);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val;
					hr = pIAgilent34980ADisplay->get_MonitorEnable(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ADisplay->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_MONITOR_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_MONITOR_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ENABLE_MONITOR_CHAN:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_ENABLE_MONITOR_CHAN\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADisplay* pIAgilent34980ADisplay = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADisplay);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34980ADisplay->get_EnableMonitorChan(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ADisplay->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_SELECT_MONITOR_CHAN:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_SELECT_MONITOR_CHAN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_FREQUENCY_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE_AUTO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE_AUTO\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AFrequency* pIAgilent34980AFrequency = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AFrequency);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34980AFrequency->get_AutoRange(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AFrequency->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_LOW_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_FREQUENCY_LOW_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_FRESISTANCE_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_FRESISTANCE_AUTORANGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AFResistance* pIAgilent34980AFResistance = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AFResistance);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34980AFResistance->get_AutoRange(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AFResistance->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_FRESISTANCE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_FRESISTANCE_OCOMPENSATED\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AFResistance* pIAgilent34980AFResistance = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AFResistance);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34980AFResistance->get_OCompensated(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AFResistance->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_FRESISTANCE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_FRESISTANCE_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEASUREMENT_READING_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_MEASUREMENT_READING_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEASUREMENT_FUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_MEASUREMENT_FUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AUTO_RECALL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_AUTO_RECALL\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AMemory* pIAgilent34980AMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AMemory);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val;
					hr = pIAgilent34980AMemory->get_AutoRecall(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_NUMBER_OF_STATES:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_NUMBER_OF_STATES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEMORY_CATALOG:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_MEMORY_CATALOG\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PERIOD_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_PERIOD_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PERIOD_VOLTAGE_RANGE_AUTO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_PERIOD_VOLTAGE_RANGE_AUTO\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980APeriod* pIAgilent34980APeriod = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980APeriod);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34980APeriod->get_AutoRange(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980APeriod->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_PERIOD_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_PERIOD_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_RESISTANCE_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_RESISTANCE_AUTORANGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AResistance* pIAgilent34980AResistance = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AResistance);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34980AResistance->get_AutoRange(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AResistance->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_RESISTANCE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_RESISTANCE_OCOMPENSATED\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AResistance* pIAgilent34980AResistance = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AResistance);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34980AResistance->get_OCompensated(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AResistance->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_RESISTANCE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_RESISTANCE_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_RESISTANCE_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_GAIN:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_SCALE_GAIN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_OFFSET:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_SCALE_OFFSET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_STATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_SCALE_STATE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AScale* pIAgilent34980AScale = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AScale);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34980AScale->get_State(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AScale->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_SCALE_UNIT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_SCALE_UNIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_AUTO_DELAY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_CHANNEL_AUTO_DELAY\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ARoute* pIAgilent34980ARoute = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ARoute);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34980ARoute->get_AutoDelay(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ARoute->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_CHANNEL_DELAY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_CHANNEL_DELAY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_FWIRE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_CHANNEL_FWIRE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ARoute* pIAgilent34980ARoute = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ARoute);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34980ARoute->get_FWire(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ARoute->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_ROUTE_DONE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_ROUTE_DONE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ARoute* pIAgilent34980ARoute = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ARoute);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val;
					hr = pIAgilent34980ARoute->get_Done(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ARoute->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_CHANNEL_IS_CLOSED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_CHANNEL_IS_CLOSED\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ARoute* pIAgilent34980ARoute = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ARoute);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34980ARoute->get_IsClosed(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ARoute->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_CHANNEL_SCAN_SIZE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_CHANNEL_SCAN_SIZE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_SCAN_LIST:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_CHANNEL_SCAN_LIST\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_SCAN_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_CHANNEL_SCAN_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCAN_SWEEP_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_SCAN_SWEEP_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ORDERED_SCAN:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_ORDERED_SCAN\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AScan* pIAgilent34980AScan = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AScan);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val;
					hr = pIAgilent34980AScan->get_OrderedScan(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AScan->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_STATISTICS_AVERAGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_STATISTICS_AVERAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_STATISTICS_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MAX_VALUE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_STATISTICS_MAX_VALUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MAX_VALUE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_STATISTICS_MAX_VALUE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MIN_VALUE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_STATISTICS_MIN_VALUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MIN_VALUE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_STATISTICS_MIN_VALUE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_PTPEAK:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_STATISTICS_PTPEAK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SERIAL_POLL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_SERIAL_POLL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ASYNC_EVENTS_ENABLED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_ASYNC_EVENTS_ENABLED\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ASystem* pIAgilent34980ASystem = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ASystem);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val;
					hr = pIAgilent34980ASystem->get_AsyncEventsEnabled(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ASystem->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_SYSTEM_DATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_SYSTEM_DATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DMM_ENABLED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DMM_ENABLED\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ASystem* pIAgilent34980ASystem = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ASystem);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val;
					hr = pIAgilent34980ASystem->get_DMMEnabled(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ASystem->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DMM_INSTALLED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DMM_INSTALLED\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ASystem* pIAgilent34980ASystem = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ASystem);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val;
					hr = pIAgilent34980ASystem->get_DMMInstalled(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ASystem->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_READING_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_READING_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SERIAL_NUMBER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_SERIAL_NUMBER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SYSTEM_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_SYSTEM_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TIMEOUT_MILLISECONDS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_TIMEOUT_MILLISECONDS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_LOCK_OWNER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_LOCK_OWNER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MODULE_EVENTS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_MODULE_EVENTS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_READING_UNITS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_TEMPERATURE_READING_UNITS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_TEMPERATURE_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_TEMPERATURE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_TRANSDUCERTYPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_TEMPERATURE_TRANSDUCERTYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_RESISTANCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_FRTD_RESISTANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_ALPHA:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_FRTD_ALPHA\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_IS_EXTERNAL_REFERENCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_FRTD_IS_EXTERNAL_REFERENCE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AFRTD* pIAgilent34980AFRTD = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AFRTD);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34980AFRTD->get_IsExternalReference(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AFRTD->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_FRTD_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_FRTD_OCOMPENSATED\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AFRTD* pIAgilent34980AFRTD = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AFRTD);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34980AFRTD->get_OCompensated(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AFRTD->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_ALARM_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DATA_FORMAT_ALARM_ENABLE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADataFormat* pIAgilent34980ADataFormat = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADataFormat);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val;
					hr = pIAgilent34980ADataFormat->get_AlarmEnable(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ADataFormat->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_CHANNEL_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DATA_FORMAT_CHANNEL_ENABLE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADataFormat* pIAgilent34980ADataFormat = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADataFormat);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val;
					hr = pIAgilent34980ADataFormat->get_ChannelEnable(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ADataFormat->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_TIME_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DATA_FORMAT_TIME_ENABLE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADataFormat* pIAgilent34980ADataFormat = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADataFormat);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val;
					hr = pIAgilent34980ADataFormat->get_TimeEnable(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ADataFormat->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_TIME_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DATA_FORMAT_TIME_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_UNIT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DATA_FORMAT_UNIT_ENABLE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADataFormat* pIAgilent34980ADataFormat = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADataFormat);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val;
					hr = pIAgilent34980ADataFormat->get_UnitEnable(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ADataFormat->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_RTD_RESISTANCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_RTD_RESISTANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_ALPHA:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_RTD_ALPHA\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_IS_EXTERNAL_REFERENCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_RTD_IS_EXTERNAL_REFERENCE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ARTD* pIAgilent34980ARTD = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ARTD);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34980ARTD->get_IsExternalReference(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ARTD->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_RTD_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_RTD_OCOMPENSATED\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ARTD* pIAgilent34980ARTD = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ARTD);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34980ARTD->get_OCompensated(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ARTD->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_THERMISTOR_RESISTANCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_THERMISTOR_RESISTANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMISTOR_IS_EXTERNAL_REFERENCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_THERMISTOR_IS_EXTERNAL_REFERENCE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AThermistor* pIAgilent34980AThermistor = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AThermistor);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34980AThermistor->get_IsExternalReference(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AThermistor->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_THERMOCOUPLE_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_JUNCTION_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_THERMOCOUPLE_JUNCTION_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_FIXED_REFERENCE_JUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_THERMOCOUPLE_FIXED_REFERENCE_JUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_CHECK:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_THERMOCOUPLE_CHECK\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AThermocouple* pIAgilent34980AThermocouple = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AThermocouple);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34980AThermocouple->get_Check(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AThermocouple->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_AUTO_IMPEDANCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_THERMOCOUPLE_AUTO_IMPEDANCE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AThermocouple* pIAgilent34980AThermocouple = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AThermocouple);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34980AThermocouple->get_AutoImpedance(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980AThermocouple->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_EXTERNAL_REFERENCE_JUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_THERMOCOUPLE_EXTERNAL_REFERENCE_JUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_INTERNAL_REFERENCE_JUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_THERMOCOUPLE_INTERNAL_REFERENCE_JUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_SAMPLE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_TRIGGER_SAMPLE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_TRIGGER_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_SOURCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_TRIGGER_SOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_TIMER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_TRIGGER_TIMER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DELAY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DELAY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DELAY_AUTO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DELAY_AUTO\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ATrigger* pIAgilent34980ATrigger = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ATrigger);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val;
					hr = pIAgilent34980ATrigger->get_DelayAuto(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34980ATrigger->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_CHANNEL_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_CHANNEL_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_DEBOUNCED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_IS_DEBOUNCED\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IIviSwtchPath* pIIviSwtchPath = NULL;
				hr = pDriver->QueryInterface(&pIIviSwtchPath);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val;
					hr = pIIviSwtchPath->get_IsDebounced(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIIviSwtchPath->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_CAL_DMM_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_CAL_DMM_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_DMM_MESSAGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_CAL_DMM_MESSAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_VALUE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_CAL_VALUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_LABEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_CHANNEL_LABEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SEQUENCE_CATALOG:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_SEQUENCE_CATALOG\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GETSEQUENCETRIGGERSOURCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_GETSEQUENCETRIGGERSOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_CONFIGURATION_CHANNEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_IS_CONFIGURATION_CHANNEL\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				CAtlArray<CString> arSelectors;
				CRepCapSelector repCapSelector(RepCapIdentifier);

				IIviSwtchChannels* pIIviSwtchChannels = NULL;
				hr = pDriver->QueryInterface(&pIIviSwtchChannels);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					status = repCapSelector.GetSelectors(Vi, false, 0, arSelectors);
					if (status == VI_SUCCESS)
					{
						IIviSwtchChannel* pIIviSwtchChannel = NULL;
						hr = pIIviSwtchChannels->get_Item(CComBSTR(arSelectors.GetAt(0)), &pIIviSwtchChannel);
						status = TranslateHRESULT(Vi, hr);
						if (SUCCEEDED(hr))
						{
							CVariantBool _val;
							hr = pIIviSwtchChannel->get_IsConfigurationChannel(_val.GetPtr());
							status = TranslateHRESULT(Vi, hr);
							if (SUCCEEDED(hr))
							{
								status = _val.ToViDataType(AttributeValue);
							}
							pIIviSwtchChannel->Release();
						}
					}
					pIIviSwtchChannels->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_IS_SOURCE_CHANNEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_IS_SOURCE_CHANNEL\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				CAtlArray<CString> arSelectors;
				CRepCapSelector repCapSelector(RepCapIdentifier);

				IIviSwtchChannels* pIIviSwtchChannels = NULL;
				hr = pDriver->QueryInterface(&pIIviSwtchChannels);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					status = repCapSelector.GetSelectors(Vi, false, 0, arSelectors);
					if (status == VI_SUCCESS)
					{
						IIviSwtchChannel* pIIviSwtchChannel = NULL;
						hr = pIIviSwtchChannels->get_Item(CComBSTR(arSelectors.GetAt(0)), &pIIviSwtchChannel);
						status = TranslateHRESULT(Vi, hr);
						if (SUCCEEDED(hr))
						{
							CVariantBool _val;
							hr = pIIviSwtchChannel->get_IsSourceChannel(_val.GetPtr());
							status = TranslateHRESULT(Vi, hr);
							if (SUCCEEDED(hr))
							{
								status = _val.ToViDataType(AttributeValue);
							}
							pIIviSwtchChannel->Release();
						}
					}
					pIIviSwtchChannels->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_AC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_MAX_CARRY_AC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_AC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_MAX_SWITCHING_AC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_AC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_MAX_CARRY_AC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_AC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_MAX_SWITCHING_AC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_AC_VOLTAGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_MAX_AC_VOLTAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_BANDWIDTH:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_BANDWIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_DC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_MAX_CARRY_DC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_DC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_MAX_SWITCHING_DC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_DC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_MAX_CARRY_DC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_DC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_MAX_SWITCHING_DC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_DC_VOLTAGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_MAX_DC_VOLTAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHARACTERISTIC_IMPEDANCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_CHARACTERISTIC_IMPEDANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SETTLING_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_SETTLING_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_WIRE_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_WIRE_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ASYNC_TIMEOUT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_ASYNC_TIMEOUT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_CYCLE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_HANDSHAKE_CYCLE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_HANDSHAKE_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_HANDSHAKE_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_RATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_HANDSHAKE_RATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_STATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_HANDSHAKE_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_SYNC_STROBE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_HANDSHAKE_SYNC_STROBE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_HANDSHAKE_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_DRIVE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_HANDSHAKE_DRIVE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_INPUT_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARE_ACTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_COMPARE_ACTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DATA_FORMAT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_POINTS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DATA_POINTS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ENABLE_INPUT_MEMORY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_ENABLE_INPUT_MEMORY\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AInputMemory* pIAgilent34950AInputMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AInputMemory);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34950AInputMemory->get_Enable(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AInputMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_INPUT_INTERRUPT_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_INPUT_INTERRUPT_ENABLE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AInputMemory* pIAgilent34950AInputMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AInputMemory);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34950AInputMemory->get_InterruptEnable(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AInputMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_INPUT_INTERRUPT_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_INPUT_INTERRUPT_STATUS\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AInputMemory* pIAgilent34950AInputMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AInputMemory);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34950AInputMemory->get_InterruptStatus(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AInputMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_INPUT_SAMPLE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_INPUT_SAMPLE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_INPUT_STATUS\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AInputMemory* pIAgilent34950AInputMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AInputMemory);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34950AInputMemory->get_Status(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AInputMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_OUTPUT_DRIVE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_OUTPUT_DRIVE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_VOLT_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_OUTPUT_VOLT_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_CYCLE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_OUTPUT_CYCLE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_OUTPUT_ENABLE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AOutputMemory* pIAgilent34950AOutputMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AOutputMemory);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34950AOutputMemory->get_Enable(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AOutputMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_OUTPUT_INTERRUPT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_OUTPUT_INTERRUPT_ENABLE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AOutputMemory* pIAgilent34950AOutputMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AOutputMemory);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34950AOutputMemory->get_InterruptEnable(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AOutputMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_OUTPUT_INTERRUPT_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_OUTPUT_INTERRUPT_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_INTERRUPT_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_OUTPUT_INTERRUPT_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_TRACE_SELECT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_OUTPUT_TRACE_SELECT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEMORY_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_MEMORY_STATUS\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AOutputMemory* pIAgilent34950AOutputMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AOutputMemory);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34950AOutputMemory->get_Status(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950AOutputMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TRACE_CATALOG_34950A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_TRACE_CATALOG_34950A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_MEMORY_FREE_34950A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_TRACE_MEMORY_FREE_34950A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_FUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GATE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_GATE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GATE_SOURCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_GATE_SOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GATE_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_GATE_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_SLOPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_COUNTER_SLOPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_COUNTER_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_READ_TYPE_34950A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_TOTALIZER_READ_TYPE_34950A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_FREQUENCY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_COUNTER_FREQUENCY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_PERIOD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_COUNTER_PERIOD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_WIDTH:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_PULSE_WIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_DUTY_CYCLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_PULSE_DUTY_CYCLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_TOTALIZE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_COUNTER_TOTALIZE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_COMPARISON_ENABLE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34950ADigital->get_ComparisonEnable(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950ADigital->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_COMPARISON_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_COMPARISON_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DIGITAL_DIRECTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DIGITAL_DIRECTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_DATA_BYTE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_COMPARISON_DATA_BYTE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_DATA_WORD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_COMPARISON_DATA_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_DATA_LONG_WORD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_COMPARISON_DATA_LONG_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_ALARM_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_COMPARISON_ALARM_ENABLE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34950ADigital->get_ComparisonAlarmEnable(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34950ADigital->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_COMPARISON_MASK_BYTE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_COMPARISON_MASK_BYTE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_MASK_WORD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_COMPARISON_MASK_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_MASK_LONG_WORD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_COMPARISON_MASK_LONG_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DIGITAL_WIDTH:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DIGITAL_WIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DIGITAL_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DIGITAL_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CURRENT_SOURCE_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_CURRENT_SOURCE_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CURRENT_SOURCE_GAIN:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_CURRENT_SOURCE_GAIN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CURRENT_SOURCE_OFFSET:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_CURRENT_SOURCE_OFFSET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_STATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_OUTPUT_STATE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951AOutput* pIAgilent34951AOutput = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951AOutput);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34951AOutput->get_State(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34951AOutput->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_OPERATION_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_OPERATION_MODE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951ASource* pIAgilent34951ASource = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951ASource);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34951ASource->get_OperationMode(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34951ASource->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_FUNCTION_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_FUNCTION_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_NUM_CYCLES:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_NUM_CYCLES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_START_INDEX:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_START_INDEX\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_NAME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_TRACE_NAME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SOURCE_FREQUENCY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_SOURCE_FREQUENCY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_TRIGGER_SOURCE_34951A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_TRACE_TRIGGER_SOURCE_34951A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_CLOCK_SOURCE_34951A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_TRACE_CLOCK_SOURCE_34951A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_CLOCK_PERIOD_34951A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_TRACE_CLOCK_PERIOD_34951A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VOLTAGE_SOURCE_GAIN:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_VOLTAGE_SOURCE_GAIN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VOLTAGE_SOURCE_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_VOLTAGE_SOURCE_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VOLTAGE_SOURCE_OFFSET:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_VOLTAGE_SOURCE_OFFSET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DAC_VOLTAGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DAC_VOLTAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_MODE_34952A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_TOTALIZER_MODE_34952A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_READ_TYPE_34952A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_TOTALIZER_READ_TYPE_34952A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_SLOPE_34952A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_TOTALIZER_SLOPE_34952A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_STATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DRIVE_STATE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34945A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34945AChannel* pIAgilent34945AChannel = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34945AChannel);
				status = TranslateHRESULTAgilent34945A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34945AChannel->get_DriveState(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34945A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34945AChannel->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_PAIRED_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_PAIRED_MODE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34945A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34945AChannel* pIAgilent34945AChannel = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34945AChannel);
				status = TranslateHRESULTAgilent34945A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34945AChannel->get_PairedMode(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34945A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34945AChannel->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_PULSE_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_PULSE_MODE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34945A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34945AChannel* pIAgilent34945AChannel = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34945AChannel);
				status = TranslateHRESULTAgilent34945A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34945AChannel->get_PulseMode(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34945A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34945AChannel->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_PULSE_WIDTH_34945A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_PULSE_WIDTH_34945A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RECOVERY_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_RECOVERY_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SETTLE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_SETTLE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VERIFICATION_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_VERIFICATION_ENABLE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34945A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34945AChannel* pIAgilent34945AChannel = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34945AChannel);
				status = TranslateHRESULTAgilent34945A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34945AChannel->get_VerificationEnable(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34945A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34945AChannel->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_VERIFICATION_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_VERIFICATION_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATE_AT_RESET:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_STATE_AT_RESET\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34945A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34945AChannel* pIAgilent34945AChannel = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34945AChannel);
				status = TranslateHRESULTAgilent34945A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34945AChannel->get_StateAtReset(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34945A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34945AChannel->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DRIVE_CHANNEL_LIMIT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DRIVE_CHANNEL_LIMIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_SOURCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DRIVE_SOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_SOURCE_BOOT_STATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_DRIVE_SOURCE_BOOT_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_CLOSED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: AG34980A_ATTR_IS_CLOSED\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34959A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34959ARoute* pIAgilent34959ARoute = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34959ARoute);
				status = TranslateHRESULTAgilent34959A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val;
					hr = pIAgilent34959ARoute->get_IsClosed(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34959A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue);
					}
					pIAgilent34959ARoute->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						

		default:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViBoolean: Invalid Attribute=%d\n"), AttributeID);

			status = IviSession_SetError(Vi, IVIC_ERROR_INVALID_ATTRIBUTE, "Attribute not recognized.");
			status = IVIC_ERROR_INVALID_ATTRIBUTE;
			break;
		}
	}
		
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetAttributeViSession ( ViSession Vi, ViConstString RepCapIdentifier, ViAttr AttributeID, ViSession* AttributeValue )
{
	ViStatus status = VI_SUCCESS;

	switch (AttributeID)
	{
		case AG34980A_ATTR_SPECIFIC_DRIVER_DESCRIPTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_SPECIFIC_DRIVER_DESCRIPTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_PREFIX:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_SPECIFIC_DRIVER_PREFIX\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_VENDOR:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_SPECIFIC_DRIVER_VENDOR\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_REVISION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_SPECIFIC_DRIVER_REVISION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MAJOR_VERSION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MAJOR_VERSION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MINOR_VERSION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MINOR_VERSION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_LOGICAL_NAME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_LOGICAL_NAME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IO_RESOURCE_DESCRIPTOR:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_IO_RESOURCE_DESCRIPTOR\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CACHE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_CACHE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INTERCHANGE_CHECK:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_INTERCHANGE_CHECK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_QUERY_INSTRUMENT_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_QUERY_INSTRUMENT_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RANGE_CHECK:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_RANGE_CHECK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RECORD_COERCIONS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_RECORD_COERCIONS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SIMULATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_SIMULATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVER_SETUP:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DRIVER_SETUP\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INSTRUMENT_MANUFACTURER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_INSTRUMENT_MANUFACTURER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INSTRUMENT_MODEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_INSTRUMENT_MODEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INSTRUMENT_FIRMWARE_REVISION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_INSTRUMENT_FIRMWARE_REVISION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SUPPORTED_INSTRUMENT_MODELS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_SUPPORTED_INSTRUMENT_MODELS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GROUP_CAPABILITIES:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_GROUP_CAPABILITIES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_LOWER_LIMIT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_ALARM_LOWER_LIMIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_LOWER_LIMIT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_ALARM_LOWER_LIMIT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_ALARM_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_QUERYALARMQUEUE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_QUERYALARMQUEUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_SLOPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_ALARM_SLOPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_UPPER_LIMIT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_ALARM_UPPER_LIMIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_UPPER_LIMIT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_ALARM_UPPER_LIMIT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_VOLTAGE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_AC_VOLTAGE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_VOLTAGE_BANDWIDTH:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_AC_VOLTAGE_BANDWIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_AC_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_CURRENT_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_AC_CURRENT_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_CURRENT_BANDWIDTH:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_AC_CURRENT_BANDWIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_CURRENT_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_AC_CURRENT_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SECURITY_PASSWORD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_SECURITY_PASSWORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_MAINFRAME_MESSAGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_CAL_MAINFRAME_MESSAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_TOTAL_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_CAL_TOTAL_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_LINE_FREQUENCY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_CAL_LINE_FREQUENCY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SECURITY_STATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_SECURITY_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DC_CURRENT_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DC_CURRENT_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DC_CURRENT_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DC_CURRENT_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DC_CURRENT_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DC_CURRENT_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DC_VOLTAGE_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DC_VOLTAGE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DC_VOLTAGE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DC_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DC_VOLTAGE_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DC_VOLTAGE_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_AUTO_IMPEDANCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DC_VOLTAGE_AUTO_IMPEDANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GETRELAYCYCLES:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_GETRELAYCYCLES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DISPLAY_ENABLED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DISPLAY_ENABLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DISPLAY_TEXT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DISPLAY_TEXT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MONITOR_DATA:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_MONITOR_DATA\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MONITOR_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_MONITOR_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MONITOR_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_MONITOR_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ENABLE_MONITOR_CHAN:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_ENABLE_MONITOR_CHAN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SELECT_MONITOR_CHAN:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_SELECT_MONITOR_CHAN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_FREQUENCY_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE_AUTO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE_AUTO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_LOW_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_FREQUENCY_LOW_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_FRESISTANCE_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_FRESISTANCE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_FRESISTANCE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_FRESISTANCE_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_FRESISTANCE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_FRESISTANCE_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEASUREMENT_READING_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_MEASUREMENT_READING_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEASUREMENT_FUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_MEASUREMENT_FUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AUTO_RECALL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_AUTO_RECALL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_NUMBER_OF_STATES:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_NUMBER_OF_STATES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEMORY_CATALOG:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_MEMORY_CATALOG\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PERIOD_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_PERIOD_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PERIOD_VOLTAGE_RANGE_AUTO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_PERIOD_VOLTAGE_RANGE_AUTO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PERIOD_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_PERIOD_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_RESISTANCE_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_RESISTANCE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_RESISTANCE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_RESISTANCE_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_RESISTANCE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_RESISTANCE_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_RESISTANCE_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_GAIN:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_SCALE_GAIN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_OFFSET:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_SCALE_OFFSET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_STATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_SCALE_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_UNIT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_SCALE_UNIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_AUTO_DELAY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_CHANNEL_AUTO_DELAY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_DELAY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_CHANNEL_DELAY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_FWIRE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_CHANNEL_FWIRE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ROUTE_DONE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_ROUTE_DONE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_IS_CLOSED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_CHANNEL_IS_CLOSED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_SCAN_SIZE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_CHANNEL_SCAN_SIZE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_SCAN_LIST:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_CHANNEL_SCAN_LIST\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_SCAN_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_CHANNEL_SCAN_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCAN_SWEEP_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_SCAN_SWEEP_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ORDERED_SCAN:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_ORDERED_SCAN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_AVERAGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_STATISTICS_AVERAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_STATISTICS_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MAX_VALUE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_STATISTICS_MAX_VALUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MAX_VALUE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_STATISTICS_MAX_VALUE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MIN_VALUE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_STATISTICS_MIN_VALUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MIN_VALUE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_STATISTICS_MIN_VALUE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_PTPEAK:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_STATISTICS_PTPEAK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SERIAL_POLL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_SERIAL_POLL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ASYNC_EVENTS_ENABLED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_ASYNC_EVENTS_ENABLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SYSTEM_DATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_SYSTEM_DATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DMM_ENABLED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DMM_ENABLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DMM_INSTALLED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DMM_INSTALLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_READING_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_READING_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SERIAL_NUMBER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_SERIAL_NUMBER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SYSTEM_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_SYSTEM_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TIMEOUT_MILLISECONDS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_TIMEOUT_MILLISECONDS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_LOCK_OWNER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_LOCK_OWNER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MODULE_EVENTS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_MODULE_EVENTS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_READING_UNITS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_TEMPERATURE_READING_UNITS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_TEMPERATURE_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_TEMPERATURE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_TRANSDUCERTYPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_TEMPERATURE_TRANSDUCERTYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_RESISTANCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_FRTD_RESISTANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_ALPHA:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_FRTD_ALPHA\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_IS_EXTERNAL_REFERENCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_FRTD_IS_EXTERNAL_REFERENCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_FRTD_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_ALARM_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DATA_FORMAT_ALARM_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_CHANNEL_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DATA_FORMAT_CHANNEL_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_TIME_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DATA_FORMAT_TIME_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_TIME_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DATA_FORMAT_TIME_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_UNIT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DATA_FORMAT_UNIT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_RESISTANCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_RTD_RESISTANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_ALPHA:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_RTD_ALPHA\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_IS_EXTERNAL_REFERENCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_RTD_IS_EXTERNAL_REFERENCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_RTD_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMISTOR_RESISTANCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_THERMISTOR_RESISTANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMISTOR_IS_EXTERNAL_REFERENCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_THERMISTOR_IS_EXTERNAL_REFERENCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_THERMOCOUPLE_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_JUNCTION_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_THERMOCOUPLE_JUNCTION_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_FIXED_REFERENCE_JUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_THERMOCOUPLE_FIXED_REFERENCE_JUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_CHECK:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_THERMOCOUPLE_CHECK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_AUTO_IMPEDANCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_THERMOCOUPLE_AUTO_IMPEDANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_EXTERNAL_REFERENCE_JUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_THERMOCOUPLE_EXTERNAL_REFERENCE_JUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_INTERNAL_REFERENCE_JUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_THERMOCOUPLE_INTERNAL_REFERENCE_JUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_SAMPLE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_TRIGGER_SAMPLE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_TRIGGER_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_SOURCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_TRIGGER_SOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_TIMER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_TRIGGER_TIMER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DELAY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DELAY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DELAY_AUTO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DELAY_AUTO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_CHANNEL_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_DEBOUNCED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_IS_DEBOUNCED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_DMM_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_CAL_DMM_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_DMM_MESSAGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_CAL_DMM_MESSAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_VALUE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_CAL_VALUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_LABEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_CHANNEL_LABEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SEQUENCE_CATALOG:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_SEQUENCE_CATALOG\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GETSEQUENCETRIGGERSOURCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_GETSEQUENCETRIGGERSOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_CONFIGURATION_CHANNEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_IS_CONFIGURATION_CHANNEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_SOURCE_CHANNEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_IS_SOURCE_CHANNEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_AC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_MAX_CARRY_AC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_AC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_MAX_SWITCHING_AC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_AC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_MAX_CARRY_AC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_AC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_MAX_SWITCHING_AC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_AC_VOLTAGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_MAX_AC_VOLTAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_BANDWIDTH:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_BANDWIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_DC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_MAX_CARRY_DC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_DC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_MAX_SWITCHING_DC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_DC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_MAX_CARRY_DC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_DC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_MAX_SWITCHING_DC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_DC_VOLTAGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_MAX_DC_VOLTAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHARACTERISTIC_IMPEDANCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_CHARACTERISTIC_IMPEDANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SETTLING_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_SETTLING_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_WIRE_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_WIRE_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ASYNC_TIMEOUT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_ASYNC_TIMEOUT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_CYCLE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_HANDSHAKE_CYCLE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_HANDSHAKE_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_HANDSHAKE_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_RATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_HANDSHAKE_RATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_STATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_HANDSHAKE_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_SYNC_STROBE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_HANDSHAKE_SYNC_STROBE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_HANDSHAKE_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_DRIVE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_HANDSHAKE_DRIVE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_INPUT_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARE_ACTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_COMPARE_ACTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DATA_FORMAT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_POINTS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DATA_POINTS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ENABLE_INPUT_MEMORY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_ENABLE_INPUT_MEMORY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_INPUT_INTERRUPT_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_INPUT_INTERRUPT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_INPUT_INTERRUPT_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_INPUT_INTERRUPT_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_SAMPLE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_INPUT_SAMPLE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_INPUT_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_DRIVE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_OUTPUT_DRIVE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_VOLT_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_OUTPUT_VOLT_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_CYCLE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_OUTPUT_CYCLE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_OUTPUT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_INTERRUPT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_OUTPUT_INTERRUPT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_INTERRUPT_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_OUTPUT_INTERRUPT_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_INTERRUPT_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_OUTPUT_INTERRUPT_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_TRACE_SELECT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_OUTPUT_TRACE_SELECT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEMORY_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_MEMORY_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_CATALOG_34950A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_TRACE_CATALOG_34950A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_MEMORY_FREE_34950A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_TRACE_MEMORY_FREE_34950A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_FUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GATE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_GATE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GATE_SOURCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_GATE_SOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GATE_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_GATE_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_SLOPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_COUNTER_SLOPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_COUNTER_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_READ_TYPE_34950A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_TOTALIZER_READ_TYPE_34950A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_FREQUENCY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_COUNTER_FREQUENCY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_PERIOD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_COUNTER_PERIOD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_WIDTH:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_PULSE_WIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_DUTY_CYCLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_PULSE_DUTY_CYCLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_TOTALIZE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_COUNTER_TOTALIZE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_COMPARISON_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_COMPARISON_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DIGITAL_DIRECTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DIGITAL_DIRECTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_DATA_BYTE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_COMPARISON_DATA_BYTE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_DATA_WORD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_COMPARISON_DATA_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_DATA_LONG_WORD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_COMPARISON_DATA_LONG_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_ALARM_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_COMPARISON_ALARM_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_MASK_BYTE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_COMPARISON_MASK_BYTE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_MASK_WORD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_COMPARISON_MASK_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_MASK_LONG_WORD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_COMPARISON_MASK_LONG_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DIGITAL_WIDTH:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DIGITAL_WIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DIGITAL_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DIGITAL_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CURRENT_SOURCE_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_CURRENT_SOURCE_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CURRENT_SOURCE_GAIN:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_CURRENT_SOURCE_GAIN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CURRENT_SOURCE_OFFSET:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_CURRENT_SOURCE_OFFSET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_STATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_OUTPUT_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OPERATION_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_OPERATION_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FUNCTION_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_FUNCTION_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_NUM_CYCLES:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_NUM_CYCLES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_START_INDEX:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_START_INDEX\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_NAME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_TRACE_NAME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SOURCE_FREQUENCY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_SOURCE_FREQUENCY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_TRIGGER_SOURCE_34951A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_TRACE_TRIGGER_SOURCE_34951A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_CLOCK_SOURCE_34951A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_TRACE_CLOCK_SOURCE_34951A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_CLOCK_PERIOD_34951A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_TRACE_CLOCK_PERIOD_34951A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VOLTAGE_SOURCE_GAIN:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_VOLTAGE_SOURCE_GAIN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VOLTAGE_SOURCE_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_VOLTAGE_SOURCE_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VOLTAGE_SOURCE_OFFSET:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_VOLTAGE_SOURCE_OFFSET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DAC_VOLTAGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DAC_VOLTAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_MODE_34952A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_TOTALIZER_MODE_34952A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_READ_TYPE_34952A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_TOTALIZER_READ_TYPE_34952A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_SLOPE_34952A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_TOTALIZER_SLOPE_34952A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_STATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DRIVE_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PAIRED_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_PAIRED_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_PULSE_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_WIDTH_34945A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_PULSE_WIDTH_34945A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RECOVERY_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_RECOVERY_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SETTLE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_SETTLE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VERIFICATION_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_VERIFICATION_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VERIFICATION_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_VERIFICATION_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATE_AT_RESET:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_STATE_AT_RESET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_CHANNEL_LIMIT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DRIVE_CHANNEL_LIMIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_SOURCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DRIVE_SOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_SOURCE_BOOT_STATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_DRIVE_SOURCE_BOOT_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_CLOSED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: AG34980A_ATTR_IS_CLOSED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						

		default:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViSession: Invalid Attribute=%d\n"), AttributeID);

			status = IviSession_SetError(Vi, IVIC_ERROR_INVALID_ATTRIBUTE, "Attribute not recognized.");
			status = IVIC_ERROR_INVALID_ATTRIBUTE;
			break;
		}
	}
		
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetAttributeViString ( ViSession Vi, ViConstString RepCapIdentifier, ViAttr AttributeID, ViInt32 AttributeValueBufferSize, ViChar AttributeValue[] )
{
	ViStatus status = VI_SUCCESS;

	switch (AttributeID)
	{
		case AG34980A_ATTR_SPECIFIC_DRIVER_DESCRIPTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_SPECIFIC_DRIVER_DESCRIPTION\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			
			if (Vi == VI_NULL)
			{
				hr = CreateDriver(__uuidof(Agilent34980A), &pDriver);
				if (SUCCEEDED(hr))
				{
					status = VI_SUCCESS;
				}
				else
				{
					status = _VI_ERROR;
				}
			}
			else
			{
				status = GetDriver(Vi, &pDriver);
			}
			
			if (status == VI_SUCCESS)
			{
				IIviDriverIdentity* pIIviDriverIdentity = NULL;
				hr = pDriver->QueryInterface(&pIIviDriverIdentity);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val;
					hr = pIIviDriverIdentity->get_Description(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIIviDriverIdentity->Release();
				}

				pDriver->Release();
			}
			break;
		}
		case AG34980A_ATTR_SPECIFIC_DRIVER_PREFIX:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_SPECIFIC_DRIVER_PREFIX\n"));

			CBSTR _val("ag34980a");
			status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
			break;
		}
		case AG34980A_ATTR_SPECIFIC_DRIVER_VENDOR:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_SPECIFIC_DRIVER_VENDOR\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			
			if (Vi == VI_NULL)
			{
				hr = CreateDriver(__uuidof(Agilent34980A), &pDriver);
				if (SUCCEEDED(hr))
				{
					status = VI_SUCCESS;
				}
				else
				{
					status = _VI_ERROR;
				}
			}
			else
			{
				status = GetDriver(Vi, &pDriver);
			}
			
			if (status == VI_SUCCESS)
			{
				IIviDriverIdentity* pIIviDriverIdentity = NULL;
				hr = pDriver->QueryInterface(&pIIviDriverIdentity);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val;
					hr = pIIviDriverIdentity->get_Vendor(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIIviDriverIdentity->Release();
				}

				pDriver->Release();
			}
			break;
		}
		case AG34980A_ATTR_SPECIFIC_DRIVER_REVISION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_SPECIFIC_DRIVER_REVISION\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			
			if (Vi == VI_NULL)
			{
				hr = CreateDriver(__uuidof(Agilent34980A), &pDriver);
				if (SUCCEEDED(hr))
				{
					status = VI_SUCCESS;
				}
				else
				{
					status = _VI_ERROR;
				}
			}
			else
			{
				status = GetDriver(Vi, &pDriver);
			}
			
			if (status == VI_SUCCESS)
			{
				IIviDriverIdentity* pIIviDriverIdentity = NULL;
				hr = pDriver->QueryInterface(&pIIviDriverIdentity);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val;
					hr = pIIviDriverIdentity->get_Revision(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIIviDriverIdentity->Release();
				}

				pDriver->Release();
			}
			break;
		}
		case AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MAJOR_VERSION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MAJOR_VERSION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MINOR_VERSION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MINOR_VERSION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_LOGICAL_NAME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_LOGICAL_NAME\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IIviDriverOperation* pIIviDriverOperation = NULL;
				hr = pDriver->QueryInterface(&pIIviDriverOperation);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val;
					hr = pIIviDriverOperation->get_LogicalName(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIIviDriverOperation->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_IO_RESOURCE_DESCRIPTOR:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_IO_RESOURCE_DESCRIPTOR\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IIviDriverOperation* pIIviDriverOperation = NULL;
				hr = pDriver->QueryInterface(&pIIviDriverOperation);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val;
					hr = pIIviDriverOperation->get_IoResourceDescriptor(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIIviDriverOperation->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_CACHE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_CACHE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INTERCHANGE_CHECK:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_INTERCHANGE_CHECK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_QUERY_INSTRUMENT_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_QUERY_INSTRUMENT_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RANGE_CHECK:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_RANGE_CHECK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RECORD_COERCIONS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_RECORD_COERCIONS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SIMULATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_SIMULATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVER_SETUP:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DRIVER_SETUP\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IIviDriverOperation* pIIviDriverOperation = NULL;
				hr = pDriver->QueryInterface(&pIIviDriverOperation);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val;
					hr = pIIviDriverOperation->get_DriverSetup(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIIviDriverOperation->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_INSTRUMENT_MANUFACTURER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_INSTRUMENT_MANUFACTURER\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IIviDriverIdentity* pIIviDriverIdentity = NULL;
				hr = pDriver->QueryInterface(&pIIviDriverIdentity);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val;
					hr = pIIviDriverIdentity->get_InstrumentManufacturer(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIIviDriverIdentity->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_INSTRUMENT_MODEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_INSTRUMENT_MODEL\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IIviDriverIdentity* pIIviDriverIdentity = NULL;
				hr = pDriver->QueryInterface(&pIIviDriverIdentity);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val;
					hr = pIIviDriverIdentity->get_InstrumentModel(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIIviDriverIdentity->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_INSTRUMENT_FIRMWARE_REVISION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_INSTRUMENT_FIRMWARE_REVISION\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IIviDriverIdentity* pIIviDriverIdentity = NULL;
				hr = pDriver->QueryInterface(&pIIviDriverIdentity);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val;
					hr = pIIviDriverIdentity->get_InstrumentFirmwareRevision(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIIviDriverIdentity->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_SUPPORTED_INSTRUMENT_MODELS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_SUPPORTED_INSTRUMENT_MODELS\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IIviDriverIdentity* pIIviDriverIdentity = NULL;
				hr = pDriver->QueryInterface(&pIIviDriverIdentity);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val;
					hr = pIIviDriverIdentity->get_SupportedInstrumentModels(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIIviDriverIdentity->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_GROUP_CAPABILITIES:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_GROUP_CAPABILITIES\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IIviDriverIdentity* pIIviDriverIdentity = NULL;
				hr = pDriver->QueryInterface(&pIIviDriverIdentity);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val;
					hr = pIIviDriverIdentity->get_GroupCapabilities(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIIviDriverIdentity->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_ALARM_LOWER_LIMIT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_ALARM_LOWER_LIMIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_LOWER_LIMIT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_ALARM_LOWER_LIMIT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_ALARM_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_QUERYALARMQUEUE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_QUERYALARMQUEUE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AAlarm* pIAgilent34980AAlarm = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AAlarm);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val;
					hr = pIAgilent34980AAlarm->get_QueryAlarmQueue(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIAgilent34980AAlarm->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_ALARM_SLOPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_ALARM_SLOPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_UPPER_LIMIT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_ALARM_UPPER_LIMIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_UPPER_LIMIT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_ALARM_UPPER_LIMIT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_VOLTAGE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_AC_VOLTAGE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_VOLTAGE_BANDWIDTH:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_AC_VOLTAGE_BANDWIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_AC_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_CURRENT_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_AC_CURRENT_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_CURRENT_BANDWIDTH:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_AC_CURRENT_BANDWIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_CURRENT_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_AC_CURRENT_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SECURITY_PASSWORD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_SECURITY_PASSWORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_READABLE, "Attribute is write only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_READABLE;
			break;
		}						
		case AG34980A_ATTR_CAL_MAINFRAME_MESSAGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_CAL_MAINFRAME_MESSAGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ACalibration* pIAgilent34980ACalibration = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ACalibration);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val;
					hr = pIAgilent34980ACalibration->get_String(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIAgilent34980ACalibration->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_CAL_TOTAL_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_CAL_TOTAL_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_LINE_FREQUENCY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_CAL_LINE_FREQUENCY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SECURITY_STATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_SECURITY_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DC_CURRENT_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DC_CURRENT_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DC_CURRENT_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DC_CURRENT_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DC_CURRENT_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DC_CURRENT_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DC_VOLTAGE_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DC_VOLTAGE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DC_VOLTAGE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DC_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DC_VOLTAGE_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DC_VOLTAGE_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_AUTO_IMPEDANCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DC_VOLTAGE_AUTO_IMPEDANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GETRELAYCYCLES:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_GETRELAYCYCLES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DISPLAY_ENABLED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DISPLAY_ENABLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DISPLAY_TEXT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DISPLAY_TEXT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADisplay* pIAgilent34980ADisplay = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADisplay);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val;
					hr = pIAgilent34980ADisplay->get_DisplayText(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIAgilent34980ADisplay->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_MONITOR_DATA:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_MONITOR_DATA\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MONITOR_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_MONITOR_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MONITOR_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_MONITOR_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ENABLE_MONITOR_CHAN:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_ENABLE_MONITOR_CHAN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SELECT_MONITOR_CHAN:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_SELECT_MONITOR_CHAN\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADisplay* pIAgilent34980ADisplay = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADisplay);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val;
					hr = pIAgilent34980ADisplay->get_SelectMonitorChan(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIAgilent34980ADisplay->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_FREQUENCY_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE_AUTO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE_AUTO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_LOW_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_FREQUENCY_LOW_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_FRESISTANCE_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_FRESISTANCE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_FRESISTANCE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_FRESISTANCE_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_FRESISTANCE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_FRESISTANCE_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEASUREMENT_READING_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_MEASUREMENT_READING_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEASUREMENT_FUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_MEASUREMENT_FUNCTION\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AMeasurement* pIAgilent34980AMeasurement = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AMeasurement);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CBSTR _val;
					hr = pIAgilent34980AMeasurement->get_MeasurementFunction(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIAgilent34980AMeasurement->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_AUTO_RECALL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_AUTO_RECALL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_NUMBER_OF_STATES:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_NUMBER_OF_STATES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEMORY_CATALOG:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_MEMORY_CATALOG\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AMemory* pIAgilent34980AMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AMemory);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val;
					hr = pIAgilent34980AMemory->get_Catalog(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIAgilent34980AMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_PERIOD_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_PERIOD_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PERIOD_VOLTAGE_RANGE_AUTO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_PERIOD_VOLTAGE_RANGE_AUTO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PERIOD_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_PERIOD_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_RESISTANCE_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_RESISTANCE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_RESISTANCE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_RESISTANCE_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_RESISTANCE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_RESISTANCE_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_RESISTANCE_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_GAIN:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_SCALE_GAIN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_OFFSET:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_SCALE_OFFSET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_STATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_SCALE_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_UNIT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_SCALE_UNIT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AScale* pIAgilent34980AScale = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AScale);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CBSTR _val;
					hr = pIAgilent34980AScale->get_Unit(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIAgilent34980AScale->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_CHANNEL_AUTO_DELAY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_CHANNEL_AUTO_DELAY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_DELAY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_CHANNEL_DELAY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_FWIRE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_CHANNEL_FWIRE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ROUTE_DONE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_ROUTE_DONE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_IS_CLOSED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_CHANNEL_IS_CLOSED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_SCAN_SIZE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_CHANNEL_SCAN_SIZE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_SCAN_LIST:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_CHANNEL_SCAN_LIST\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AScan* pIAgilent34980AScan = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AScan);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val;
					hr = pIAgilent34980AScan->get_ScanList(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIAgilent34980AScan->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_CHANNEL_SCAN_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_CHANNEL_SCAN_TIME\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AScan* pIAgilent34980AScan = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AScan);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val;
					hr = pIAgilent34980AScan->get_ScanTime(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIAgilent34980AScan->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_SCAN_SWEEP_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_SCAN_SWEEP_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ORDERED_SCAN:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_ORDERED_SCAN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_AVERAGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_STATISTICS_AVERAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_STATISTICS_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MAX_VALUE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_STATISTICS_MAX_VALUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MAX_VALUE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_STATISTICS_MAX_VALUE_TIME\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AStatistics* pIAgilent34980AStatistics = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AStatistics);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CBSTR _val;
					hr = pIAgilent34980AStatistics->get_MaxValueTime(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIAgilent34980AStatistics->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MIN_VALUE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_STATISTICS_MIN_VALUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MIN_VALUE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_STATISTICS_MIN_VALUE_TIME\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AStatistics* pIAgilent34980AStatistics = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AStatistics);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CBSTR _val;
					hr = pIAgilent34980AStatistics->get_MinValueTime(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIAgilent34980AStatistics->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_STATISTICS_PTPEAK:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_STATISTICS_PTPEAK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SERIAL_POLL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_SERIAL_POLL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ASYNC_EVENTS_ENABLED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_ASYNC_EVENTS_ENABLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SYSTEM_DATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_SYSTEM_DATE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ASystem* pIAgilent34980ASystem = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ASystem);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val;
					hr = pIAgilent34980ASystem->get_Date(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIAgilent34980ASystem->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DMM_ENABLED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DMM_ENABLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DMM_INSTALLED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DMM_INSTALLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_READING_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_READING_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SERIAL_NUMBER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_SERIAL_NUMBER\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ASystem* pIAgilent34980ASystem = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ASystem);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val;
					hr = pIAgilent34980ASystem->get_SerialNumber(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIAgilent34980ASystem->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_SYSTEM_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_SYSTEM_TIME\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ASystem* pIAgilent34980ASystem = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ASystem);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val;
					hr = pIAgilent34980ASystem->get_Time(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIAgilent34980ASystem->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TIMEOUT_MILLISECONDS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_TIMEOUT_MILLISECONDS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_LOCK_OWNER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_LOCK_OWNER\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ASystem* pIAgilent34980ASystem = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ASystem);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val;
					hr = pIAgilent34980ASystem->get_LockOwner(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIAgilent34980ASystem->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_MODULE_EVENTS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_MODULE_EVENTS\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ASystem* pIAgilent34980ASystem = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ASystem);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val;
					hr = pIAgilent34980ASystem->get_ModuleEvents(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIAgilent34980ASystem->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_READING_UNITS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_TEMPERATURE_READING_UNITS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_TEMPERATURE_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_TEMPERATURE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_TRANSDUCERTYPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_TEMPERATURE_TRANSDUCERTYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_RESISTANCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_FRTD_RESISTANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_ALPHA:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_FRTD_ALPHA\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_IS_EXTERNAL_REFERENCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_FRTD_IS_EXTERNAL_REFERENCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_FRTD_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_ALARM_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DATA_FORMAT_ALARM_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_CHANNEL_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DATA_FORMAT_CHANNEL_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_TIME_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DATA_FORMAT_TIME_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_TIME_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DATA_FORMAT_TIME_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_UNIT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DATA_FORMAT_UNIT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_RESISTANCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_RTD_RESISTANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_ALPHA:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_RTD_ALPHA\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_IS_EXTERNAL_REFERENCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_RTD_IS_EXTERNAL_REFERENCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_RTD_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMISTOR_RESISTANCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_THERMISTOR_RESISTANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMISTOR_IS_EXTERNAL_REFERENCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_THERMISTOR_IS_EXTERNAL_REFERENCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_THERMOCOUPLE_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_JUNCTION_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_THERMOCOUPLE_JUNCTION_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_FIXED_REFERENCE_JUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_THERMOCOUPLE_FIXED_REFERENCE_JUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_CHECK:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_THERMOCOUPLE_CHECK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_AUTO_IMPEDANCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_THERMOCOUPLE_AUTO_IMPEDANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_EXTERNAL_REFERENCE_JUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_THERMOCOUPLE_EXTERNAL_REFERENCE_JUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_INTERNAL_REFERENCE_JUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_THERMOCOUPLE_INTERNAL_REFERENCE_JUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_SAMPLE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_TRIGGER_SAMPLE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_TRIGGER_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_SOURCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_TRIGGER_SOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_TIMER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_TRIGGER_TIMER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DELAY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DELAY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DELAY_AUTO:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DELAY_AUTO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_CHANNEL_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_DEBOUNCED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_IS_DEBOUNCED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_DMM_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_CAL_DMM_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_DMM_MESSAGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_CAL_DMM_MESSAGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADMM* pIAgilent34980ADMM = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADMM);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val;
					hr = pIAgilent34980ADMM->get_String(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIAgilent34980ADMM->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_CAL_VALUE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_CAL_VALUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_LABEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_CHANNEL_LABEL\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ARoute2* pIAgilent34980ARoute2 = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ARoute2);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CBSTR _val;
					hr = pIAgilent34980ARoute2->get_ChannelLabel(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIAgilent34980ARoute2->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_SEQUENCE_CATALOG:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_SEQUENCE_CATALOG\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ARoute2* pIAgilent34980ARoute2 = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ARoute2);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val;
					hr = pIAgilent34980ARoute2->get_SequenceCatalog(_val.GetPtr());
					status = TranslateHRESULT(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIAgilent34980ARoute2->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_GETSEQUENCETRIGGERSOURCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_GETSEQUENCETRIGGERSOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_CONFIGURATION_CHANNEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_IS_CONFIGURATION_CHANNEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_SOURCE_CHANNEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_IS_SOURCE_CHANNEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_AC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_MAX_CARRY_AC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_AC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_MAX_SWITCHING_AC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_AC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_MAX_CARRY_AC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_AC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_MAX_SWITCHING_AC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_AC_VOLTAGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_MAX_AC_VOLTAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_BANDWIDTH:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_BANDWIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_DC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_MAX_CARRY_DC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_DC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_MAX_SWITCHING_DC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_DC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_MAX_CARRY_DC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_DC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_MAX_SWITCHING_DC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_DC_VOLTAGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_MAX_DC_VOLTAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHARACTERISTIC_IMPEDANCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_CHARACTERISTIC_IMPEDANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SETTLING_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_SETTLING_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_WIRE_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_WIRE_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ASYNC_TIMEOUT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_ASYNC_TIMEOUT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_CYCLE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_HANDSHAKE_CYCLE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_HANDSHAKE_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_HANDSHAKE_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_RATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_HANDSHAKE_RATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_STATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_HANDSHAKE_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_SYNC_STROBE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_HANDSHAKE_SYNC_STROBE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_HANDSHAKE_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_DRIVE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_HANDSHAKE_DRIVE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_INPUT_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARE_ACTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_COMPARE_ACTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DATA_FORMAT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_POINTS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DATA_POINTS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ENABLE_INPUT_MEMORY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_ENABLE_INPUT_MEMORY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_INPUT_INTERRUPT_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_INPUT_INTERRUPT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_INPUT_INTERRUPT_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_INPUT_INTERRUPT_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_SAMPLE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_INPUT_SAMPLE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_INPUT_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_DRIVE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_OUTPUT_DRIVE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_VOLT_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_OUTPUT_VOLT_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_CYCLE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_OUTPUT_CYCLE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_OUTPUT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_INTERRUPT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_OUTPUT_INTERRUPT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_INTERRUPT_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_OUTPUT_INTERRUPT_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_INTERRUPT_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_OUTPUT_INTERRUPT_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_TRACE_SELECT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_OUTPUT_TRACE_SELECT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AOutputMemory* pIAgilent34950AOutputMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AOutputMemory);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CBSTR _val;
					hr = pIAgilent34950AOutputMemory->get_TraceSelect(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIAgilent34950AOutputMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_MEMORY_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_MEMORY_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_CATALOG_34950A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_TRACE_CATALOG_34950A\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ATrace* pIAgilent34950ATrace = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ATrace);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CBSTR _val;
					hr = pIAgilent34950ATrace->get_Catalog(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIAgilent34950ATrace->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TRACE_MEMORY_FREE_34950A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_TRACE_MEMORY_FREE_34950A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_FUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GATE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_GATE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GATE_SOURCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_GATE_SOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GATE_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_GATE_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_SLOPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_COUNTER_SLOPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_COUNTER_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_READ_TYPE_34950A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_TOTALIZER_READ_TYPE_34950A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_FREQUENCY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_COUNTER_FREQUENCY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_PERIOD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_COUNTER_PERIOD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_WIDTH:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_PULSE_WIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_DUTY_CYCLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_PULSE_DUTY_CYCLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_TOTALIZE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_COUNTER_TOTALIZE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_COMPARISON_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_COMPARISON_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DIGITAL_DIRECTION:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DIGITAL_DIRECTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_DATA_BYTE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_COMPARISON_DATA_BYTE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_DATA_WORD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_COMPARISON_DATA_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_DATA_LONG_WORD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_COMPARISON_DATA_LONG_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_ALARM_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_COMPARISON_ALARM_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_MASK_BYTE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_COMPARISON_MASK_BYTE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_MASK_WORD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_COMPARISON_MASK_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_MASK_LONG_WORD:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_COMPARISON_MASK_LONG_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DIGITAL_WIDTH:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DIGITAL_WIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DIGITAL_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DIGITAL_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CURRENT_SOURCE_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_CURRENT_SOURCE_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CURRENT_SOURCE_GAIN:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_CURRENT_SOURCE_GAIN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CURRENT_SOURCE_OFFSET:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_CURRENT_SOURCE_OFFSET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_STATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_OUTPUT_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OPERATION_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_OPERATION_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FUNCTION_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_FUNCTION_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_NUM_CYCLES:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_NUM_CYCLES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_START_INDEX:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_START_INDEX\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_NAME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_TRACE_NAME\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951ASource* pIAgilent34951ASource = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951ASource);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CBSTR _val;
					hr = pIAgilent34951ASource->get_TraceName(_identifier.GetVal(), _val.GetPtr());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					if (SUCCEEDED(hr))
					{
						status = _val.ToViDataType(AttributeValue, AttributeValueBufferSize);
					}
					pIAgilent34951ASource->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_SOURCE_FREQUENCY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_SOURCE_FREQUENCY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_TRIGGER_SOURCE_34951A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_TRACE_TRIGGER_SOURCE_34951A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_CLOCK_SOURCE_34951A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_TRACE_CLOCK_SOURCE_34951A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_CLOCK_PERIOD_34951A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_TRACE_CLOCK_PERIOD_34951A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VOLTAGE_SOURCE_GAIN:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_VOLTAGE_SOURCE_GAIN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VOLTAGE_SOURCE_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_VOLTAGE_SOURCE_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VOLTAGE_SOURCE_OFFSET:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_VOLTAGE_SOURCE_OFFSET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DAC_VOLTAGE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DAC_VOLTAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_MODE_34952A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_TOTALIZER_MODE_34952A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_READ_TYPE_34952A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_TOTALIZER_READ_TYPE_34952A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_SLOPE_34952A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_TOTALIZER_SLOPE_34952A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_STATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DRIVE_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PAIRED_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_PAIRED_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_MODE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_PULSE_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_WIDTH_34945A:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_PULSE_WIDTH_34945A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RECOVERY_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_RECOVERY_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SETTLE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_SETTLE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VERIFICATION_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_VERIFICATION_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VERIFICATION_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_VERIFICATION_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATE_AT_RESET:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_STATE_AT_RESET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_CHANNEL_LIMIT:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DRIVE_CHANNEL_LIMIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_SOURCE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DRIVE_SOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_SOURCE_BOOT_STATE:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_DRIVE_SOURCE_BOOT_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_CLOSED:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: AG34980A_ATTR_IS_CLOSED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect GetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						

		default:
		{
			IVIC_TRACE(_T("ag34980a_GetAttributeViString: Invalid Attribute=%d\n"), AttributeID);

			status = IviSession_SetError(Vi, IVIC_ERROR_INVALID_ATTRIBUTE, "Attribute not recognized.");
			status = IVIC_ERROR_INVALID_ATTRIBUTE;
			break;
		}
	}
		
	return status;
}


ViStatus _VI_FUNC  ag34980a_SetAttributeViInt32 ( ViSession Vi, ViConstString RepCapIdentifier, ViAttr AttributeID, ViInt32 AttributeValue )
{
	ViStatus status = VI_SUCCESS;

	switch (AttributeID)
	{
		case AG34980A_ATTR_SPECIFIC_DRIVER_DESCRIPTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_SPECIFIC_DRIVER_DESCRIPTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_PREFIX:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_SPECIFIC_DRIVER_PREFIX\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_VENDOR:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_SPECIFIC_DRIVER_VENDOR\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_REVISION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_SPECIFIC_DRIVER_REVISION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MAJOR_VERSION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MAJOR_VERSION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MINOR_VERSION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MINOR_VERSION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_LOGICAL_NAME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_LOGICAL_NAME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IO_RESOURCE_DESCRIPTOR:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_IO_RESOURCE_DESCRIPTOR\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CACHE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_CACHE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INTERCHANGE_CHECK:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_INTERCHANGE_CHECK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_QUERY_INSTRUMENT_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_QUERY_INSTRUMENT_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RANGE_CHECK:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_RANGE_CHECK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RECORD_COERCIONS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_RECORD_COERCIONS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SIMULATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_SIMULATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVER_SETUP:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DRIVER_SETUP\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INSTRUMENT_MANUFACTURER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_INSTRUMENT_MANUFACTURER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INSTRUMENT_MODEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_INSTRUMENT_MODEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INSTRUMENT_FIRMWARE_REVISION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_INSTRUMENT_FIRMWARE_REVISION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SUPPORTED_INSTRUMENT_MODELS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_SUPPORTED_INSTRUMENT_MODELS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GROUP_CAPABILITIES:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_GROUP_CAPABILITIES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_LOWER_LIMIT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_ALARM_LOWER_LIMIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_LOWER_LIMIT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_ALARM_LOWER_LIMIT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_ALARM_MODE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AAlarm* pIAgilent34980AAlarm = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AAlarm);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CLong _val(AttributeValue);
					hr = pIAgilent34980AAlarm->put_Mode((Agilent34980AAlarmModeEnum)_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AAlarm->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_QUERYALARMQUEUE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_QUERYALARMQUEUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_SLOPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_ALARM_SLOPE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AAlarm* pIAgilent34980AAlarm = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AAlarm);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CLong _val(AttributeValue);
					hr = pIAgilent34980AAlarm->put_Slope((Agilent34980ASlopeEnum)_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AAlarm->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_ALARM_UPPER_LIMIT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_ALARM_UPPER_LIMIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_UPPER_LIMIT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_ALARM_UPPER_LIMIT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_VOLTAGE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_AC_VOLTAGE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_VOLTAGE_BANDWIDTH:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_AC_VOLTAGE_BANDWIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_AC_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_CURRENT_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_AC_CURRENT_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_CURRENT_BANDWIDTH:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_AC_CURRENT_BANDWIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_CURRENT_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_AC_CURRENT_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SECURITY_PASSWORD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_SECURITY_PASSWORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_MAINFRAME_MESSAGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_CAL_MAINFRAME_MESSAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_TOTAL_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_CAL_TOTAL_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_CAL_LINE_FREQUENCY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_CAL_LINE_FREQUENCY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SECURITY_STATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_SECURITY_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DC_CURRENT_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DC_CURRENT_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DC_CURRENT_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DC_CURRENT_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DC_CURRENT_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DC_CURRENT_AUTOZERO\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADCCurrent* pIAgilent34980ADCCurrent = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADCCurrent);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34980ADCCurrent->put_AutoZero(_identifier.GetVal(), (Agilent34980AAutoZeroEnum)_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ADCCurrent->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DC_VOLTAGE_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DC_VOLTAGE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DC_VOLTAGE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DC_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DC_VOLTAGE_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DC_VOLTAGE_AUTOZERO\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADCVoltage* pIAgilent34980ADCVoltage = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADCVoltage);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34980ADCVoltage->put_AutoZero(_identifier.GetVal(), (Agilent34980AAutoZeroEnum)_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ADCVoltage->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_AUTO_IMPEDANCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DC_VOLTAGE_AUTO_IMPEDANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GETRELAYCYCLES:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_GETRELAYCYCLES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_DISPLAY_ENABLED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DISPLAY_ENABLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DISPLAY_TEXT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DISPLAY_TEXT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MONITOR_DATA:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_MONITOR_DATA\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MONITOR_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_MONITOR_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MONITOR_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_MONITOR_MODE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADisplay* pIAgilent34980ADisplay = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADisplay);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CLong _val(AttributeValue);
					hr = pIAgilent34980ADisplay->put_MonitorMode((Agilent34980AMonitorModeEnum)_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ADisplay->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_ENABLE_MONITOR_CHAN:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_ENABLE_MONITOR_CHAN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SELECT_MONITOR_CHAN:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_SELECT_MONITOR_CHAN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_FREQUENCY_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE_AUTO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE_AUTO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_LOW_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_FREQUENCY_LOW_RANGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AFrequency* pIAgilent34980AFrequency = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AFrequency);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34980AFrequency->put_LowRange(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AFrequency->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_FRESISTANCE_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_FRESISTANCE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_FRESISTANCE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_FRESISTANCE_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_FRESISTANCE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_FRESISTANCE_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEASUREMENT_READING_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_MEASUREMENT_READING_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_MEASUREMENT_FUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_MEASUREMENT_FUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AUTO_RECALL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_AUTO_RECALL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_NUMBER_OF_STATES:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_NUMBER_OF_STATES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_MEMORY_CATALOG:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_MEMORY_CATALOG\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PERIOD_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_PERIOD_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PERIOD_VOLTAGE_RANGE_AUTO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_PERIOD_VOLTAGE_RANGE_AUTO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PERIOD_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_PERIOD_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_RESISTANCE_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_RESISTANCE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_RESISTANCE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_RESISTANCE_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_RESISTANCE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_RESISTANCE_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_RESISTANCE_AUTOZERO\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AResistance* pIAgilent34980AResistance = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AResistance);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34980AResistance->put_AutoZero(_identifier.GetVal(), (Agilent34980AAutoZeroEnum)_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AResistance->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_SCALE_GAIN:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_SCALE_GAIN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_OFFSET:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_SCALE_OFFSET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_STATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_SCALE_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_UNIT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_SCALE_UNIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_AUTO_DELAY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_CHANNEL_AUTO_DELAY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_DELAY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_CHANNEL_DELAY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_FWIRE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_CHANNEL_FWIRE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ROUTE_DONE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_ROUTE_DONE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_IS_CLOSED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_CHANNEL_IS_CLOSED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_SCAN_SIZE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_CHANNEL_SCAN_SIZE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_SCAN_LIST:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_CHANNEL_SCAN_LIST\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_SCAN_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_CHANNEL_SCAN_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCAN_SWEEP_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_SCAN_SWEEP_COUNT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AScan* pIAgilent34980AScan = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AScan);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CLong _val(AttributeValue);
					hr = pIAgilent34980AScan->put_SweepCount(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AScan->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_ORDERED_SCAN:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_ORDERED_SCAN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_AVERAGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_STATISTICS_AVERAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_STATISTICS_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MAX_VALUE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_STATISTICS_MAX_VALUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MAX_VALUE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_STATISTICS_MAX_VALUE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MIN_VALUE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_STATISTICS_MIN_VALUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MIN_VALUE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_STATISTICS_MIN_VALUE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_PTPEAK:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_STATISTICS_PTPEAK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SERIAL_POLL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_SERIAL_POLL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_ASYNC_EVENTS_ENABLED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_ASYNC_EVENTS_ENABLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SYSTEM_DATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_SYSTEM_DATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DMM_ENABLED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DMM_ENABLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DMM_INSTALLED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DMM_INSTALLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_READING_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_READING_THRESHOLD\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ASystem* pIAgilent34980ASystem = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ASystem);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CLong _val(AttributeValue);
					hr = pIAgilent34980ASystem->put_ReadingThreshold(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ASystem->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_SERIAL_NUMBER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_SERIAL_NUMBER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SYSTEM_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_SYSTEM_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TIMEOUT_MILLISECONDS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_TIMEOUT_MILLISECONDS\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ASystem* pIAgilent34980ASystem = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ASystem);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CLong _val(AttributeValue);
					hr = pIAgilent34980ASystem->put_TimeoutMilliseconds(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ASystem->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_LOCK_OWNER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_LOCK_OWNER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MODULE_EVENTS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_MODULE_EVENTS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_READING_UNITS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_TEMPERATURE_READING_UNITS\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ATemperature* pIAgilent34980ATemperature = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ATemperature);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34980ATemperature->put_ReadingUnits(_identifier.GetVal(), (Agilent34980ATemperatureUnitsEnum)_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ATemperature->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_TEMPERATURE_AUTOZERO\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ATemperature* pIAgilent34980ATemperature = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ATemperature);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34980ATemperature->put_AutoZero(_identifier.GetVal(), (Agilent34980AAutoZeroEnum)_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ATemperature->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_TEMPERATURE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_TRANSDUCERTYPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_TEMPERATURE_TRANSDUCERTYPE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ATemperature* pIAgilent34980ATemperature = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ATemperature);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34980ATemperature->put_TransducerType(_identifier.GetVal(), (Agilent34980ATransducerEnum)_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ATemperature->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_FRTD_RESISTANCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_FRTD_RESISTANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_ALPHA:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_FRTD_ALPHA\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AFRTD* pIAgilent34980AFRTD = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AFRTD);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34980AFRTD->put_Alpha(_identifier.GetVal(), (Agilent34980AFRTDAlphaEnum)_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AFRTD->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_FRTD_IS_EXTERNAL_REFERENCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_FRTD_IS_EXTERNAL_REFERENCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_FRTD_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_ALARM_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DATA_FORMAT_ALARM_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_CHANNEL_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DATA_FORMAT_CHANNEL_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_TIME_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DATA_FORMAT_TIME_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_TIME_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DATA_FORMAT_TIME_TYPE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADataFormat* pIAgilent34980ADataFormat = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADataFormat);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CLong _val(AttributeValue);
					hr = pIAgilent34980ADataFormat->put_TimeType((Agilent34980ATimeOffsetEnum)_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ADataFormat->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_UNIT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DATA_FORMAT_UNIT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_RESISTANCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_RTD_RESISTANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_ALPHA:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_RTD_ALPHA\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ARTD* pIAgilent34980ARTD = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ARTD);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34980ARTD->put_Alpha(_identifier.GetVal(), (Agilent34980ARTDAlphaEnum)_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ARTD->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_RTD_IS_EXTERNAL_REFERENCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_RTD_IS_EXTERNAL_REFERENCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_RTD_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMISTOR_RESISTANCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_THERMISTOR_RESISTANCE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AThermistor* pIAgilent34980AThermistor = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AThermistor);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34980AThermistor->put_Resistance(_identifier.GetVal(), (Agilent34980AThermistorEnum)_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AThermistor->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_THERMISTOR_IS_EXTERNAL_REFERENCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_THERMISTOR_IS_EXTERNAL_REFERENCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_THERMOCOUPLE_TYPE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AThermocouple* pIAgilent34980AThermocouple = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AThermocouple);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34980AThermocouple->put_ThermocoupleType(_identifier.GetVal(), (Agilent34980AThermocoupleEnum)_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AThermocouple->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_JUNCTION_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_THERMOCOUPLE_JUNCTION_TYPE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AThermocouple* pIAgilent34980AThermocouple = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AThermocouple);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34980AThermocouple->put_ReferenceJunctionType(_identifier.GetVal(), (Agilent34980ARJunctionEnum)_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AThermocouple->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_FIXED_REFERENCE_JUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_THERMOCOUPLE_FIXED_REFERENCE_JUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_CHECK:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_THERMOCOUPLE_CHECK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_AUTO_IMPEDANCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_THERMOCOUPLE_AUTO_IMPEDANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_EXTERNAL_REFERENCE_JUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_THERMOCOUPLE_EXTERNAL_REFERENCE_JUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_INTERNAL_REFERENCE_JUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_THERMOCOUPLE_INTERNAL_REFERENCE_JUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_SAMPLE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_TRIGGER_SAMPLE_COUNT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ATrigger* pIAgilent34980ATrigger = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ATrigger);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CLong _val(AttributeValue);
					hr = pIAgilent34980ATrigger->put_SampleCount(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ATrigger->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TRIGGER_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_TRIGGER_COUNT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ATrigger* pIAgilent34980ATrigger = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ATrigger);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CLong _val(AttributeValue);
					hr = pIAgilent34980ATrigger->put_Count(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ATrigger->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TRIGGER_SOURCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_TRIGGER_SOURCE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ATrigger* pIAgilent34980ATrigger = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ATrigger);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CLong _val(AttributeValue);
					hr = pIAgilent34980ATrigger->put_Source((Agilent34980ATriggerSourceEnum)_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ATrigger->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TRIGGER_TIMER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_TRIGGER_TIMER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DELAY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DELAY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DELAY_AUTO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DELAY_AUTO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_CHANNEL_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_IS_DEBOUNCED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_IS_DEBOUNCED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_DMM_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_CAL_DMM_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_CAL_DMM_MESSAGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_CAL_DMM_MESSAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_VALUE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_CAL_VALUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_LABEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_CHANNEL_LABEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SEQUENCE_CATALOG:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_SEQUENCE_CATALOG\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GETSEQUENCETRIGGERSOURCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_GETSEQUENCETRIGGERSOURCE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ARoute2* pIAgilent34980ARoute2 = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ARoute2);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34980ARoute2->put_SequenceTriggerSource(_identifier.GetVal(), (Agilent34980ASequenceTriggerSourceEnum)_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ARoute2->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_IS_CONFIGURATION_CHANNEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_IS_CONFIGURATION_CHANNEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_SOURCE_CHANNEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_IS_SOURCE_CHANNEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_AC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_MAX_CARRY_AC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_AC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_MAX_SWITCHING_AC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_AC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_MAX_CARRY_AC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_AC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_MAX_SWITCHING_AC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_AC_VOLTAGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_MAX_AC_VOLTAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_BANDWIDTH:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_BANDWIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_DC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_MAX_CARRY_DC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_DC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_MAX_SWITCHING_DC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_DC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_MAX_CARRY_DC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_DC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_MAX_SWITCHING_DC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_DC_VOLTAGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_MAX_DC_VOLTAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHARACTERISTIC_IMPEDANCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_CHARACTERISTIC_IMPEDANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SETTLING_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_SETTLING_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_WIRE_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_WIRE_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_ASYNC_TIMEOUT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_ASYNC_TIMEOUT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_CYCLE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_HANDSHAKE_CYCLE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_HANDSHAKE_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_HANDSHAKE_MODE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AHandshake* pIAgilent34950AHandshake = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AHandshake);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34950AHandshake->put_Mode(_identifier.GetVal(), (Agilent34950AHandshakeModeEnum)_val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950AHandshake->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_RATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_HANDSHAKE_RATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_STATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_HANDSHAKE_STATE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AHandshake* pIAgilent34950AHandshake = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AHandshake);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34950AHandshake->put_State(_identifier.GetVal(), (Agilent34950AStateEnum)_val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950AHandshake->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_SYNC_STROBE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_HANDSHAKE_SYNC_STROBE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AHandshake* pIAgilent34950AHandshake = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AHandshake);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34950AHandshake->put_SyncStrobe(_identifier.GetVal(), (Agilent34950AHandshakeStrobeSourceEnum)_val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950AHandshake->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_HANDSHAKE_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_DRIVE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_HANDSHAKE_DRIVE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AHandshake* pIAgilent34950AHandshake = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AHandshake);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34950AHandshake->put_Drive(_identifier.GetVal(), (Agilent34950AHandshakeLineTypeEnum)_val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950AHandshake->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_INPUT_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_INPUT_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARE_ACTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_COMPARE_ACTION\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AInputMemory* pIAgilent34950AInputMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AInputMemory);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34950AInputMemory->put_CompareAction(_identifier.GetVal(), (Agilent34950AActionEnum)_val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950AInputMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DATA_FORMAT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AInputMemory* pIAgilent34950AInputMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AInputMemory);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34950AInputMemory->put_DataFormat(_identifier.GetVal(), (Agilent34950ADataFormatEnum)_val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950AInputMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DATA_POINTS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DATA_POINTS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_ENABLE_INPUT_MEMORY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_ENABLE_INPUT_MEMORY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_INPUT_INTERRUPT_MODE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AInputMemory* pIAgilent34950AInputMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AInputMemory);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34950AInputMemory->put_InterruptMode(_identifier.GetVal(), (Agilent34950AReportConditionEnum)_val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950AInputMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_INPUT_INTERRUPT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_INPUT_INTERRUPT_POLARITY\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AInputMemory* pIAgilent34950AInputMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AInputMemory);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34950AInputMemory->put_InterruptPolarity(_identifier.GetVal(), (Agilent34950APolarityEnum)_val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950AInputMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_INPUT_INTERRUPT_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_SAMPLE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_INPUT_SAMPLE_COUNT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AInputMemory* pIAgilent34950AInputMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AInputMemory);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34950AInputMemory->put_SampleCount(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950AInputMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_INPUT_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_INPUT_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_DRIVE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_OUTPUT_DRIVE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AOutput* pIAgilent34950AOutput = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AOutput);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34950AOutput->put_Drive(_identifier.GetVal(), (Agilent34950AHandshakeLineTypeEnum)_val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950AOutput->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_OUTPUT_VOLT_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_OUTPUT_VOLT_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_CYCLE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_OUTPUT_CYCLE_COUNT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AOutputMemory* pIAgilent34950AOutputMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AOutputMemory);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34950AOutputMemory->put_CycleCount(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950AOutputMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_OUTPUT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_OUTPUT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_INTERRUPT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_OUTPUT_INTERRUPT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_INTERRUPT_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_OUTPUT_INTERRUPT_MODE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AOutputMemory* pIAgilent34950AOutputMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AOutputMemory);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34950AOutputMemory->put_InterruptMode(_identifier.GetVal(), (Agilent34950AOutputModeEnum)_val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950AOutputMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_OUTPUT_INTERRUPT_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_OUTPUT_INTERRUPT_POLARITY\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AOutputMemory* pIAgilent34950AOutputMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AOutputMemory);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34950AOutputMemory->put_InterruptPolarity(_identifier.GetVal(), (Agilent34950APolarityEnum)_val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950AOutputMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_OUTPUT_TRACE_SELECT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_OUTPUT_TRACE_SELECT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEMORY_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_MEMORY_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_CATALOG_34950A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_TRACE_CATALOG_34950A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_MEMORY_FREE_34950A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_TRACE_MEMORY_FREE_34950A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_FUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_FUNCTION\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ACounter* pIAgilent34950ACounter = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ACounter);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34950ACounter->put_Function(_identifier.GetVal(), (Agilent34950AFunctionEnum)_val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950ACounter->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_GATE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_GATE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GATE_SOURCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_GATE_SOURCE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ACounter* pIAgilent34950ACounter = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ACounter);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34950ACounter->put_GateSource(_identifier.GetVal(), (Agilent34950AGateSourceEnum)_val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950ACounter->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_GATE_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_GATE_POLARITY\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ACounter* pIAgilent34950ACounter = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ACounter);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34950ACounter->put_GatePolarity(_identifier.GetVal(), (Agilent34950APolarityEnum)_val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950ACounter->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_COUNTER_SLOPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_COUNTER_SLOPE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ACounter* pIAgilent34950ACounter = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ACounter);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34950ACounter->put_Slope(_identifier.GetVal(), (Agilent34950ATotalizeSlopeEnum)_val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950ACounter->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_COUNTER_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_COUNTER_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_READ_TYPE_34950A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_TOTALIZER_READ_TYPE_34950A\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ATotalizer* pIAgilent34950ATotalizer = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ATotalizer);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34950ATotalizer->put_ReadType(_identifier.GetVal(), (Agilent34950ATotalizeTypeEnum)_val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950ATotalizer->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_COUNTER_FREQUENCY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_COUNTER_FREQUENCY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_PERIOD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_COUNTER_PERIOD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_WIDTH:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_PULSE_WIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_DUTY_CYCLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_PULSE_DUTY_CYCLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_TOTALIZE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_COUNTER_TOTALIZE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_COMPARISON_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_COMPARISON_TYPE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34950ADigital->put_ComparisonType(_identifier.GetVal(), (Agilent34950AComparisonTypeEnum)_val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950ADigital->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DIGITAL_DIRECTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DIGITAL_DIRECTION\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34950ADigital->put_Direction(_identifier.GetVal(), (Agilent34950ADirectionEnum)_val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950ADigital->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_COMPARISON_DATA_BYTE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_COMPARISON_DATA_BYTE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CByte _val(AttributeValue);
					hr = pIAgilent34950ADigital->put_ComparisonDataByte(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950ADigital->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_COMPARISON_DATA_WORD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_COMPARISON_DATA_WORD\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CShort _val(AttributeValue);
					hr = pIAgilent34950ADigital->put_ComparisonDataWord(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950ADigital->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_COMPARISON_DATA_LONG_WORD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_COMPARISON_DATA_LONG_WORD\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34950ADigital->put_ComparisonDataLongWord(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950ADigital->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_COMPARISON_ALARM_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_COMPARISON_ALARM_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_MASK_BYTE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_COMPARISON_MASK_BYTE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CByte _val(AttributeValue);
					hr = pIAgilent34950ADigital->put_ComparisonMaskByte(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950ADigital->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_COMPARISON_MASK_WORD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_COMPARISON_MASK_WORD\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CShort _val(AttributeValue);
					hr = pIAgilent34950ADigital->put_ComparisonMaskWord(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950ADigital->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_COMPARISON_MASK_LONG_WORD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_COMPARISON_MASK_LONG_WORD\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34950ADigital->put_ComparisonMaskLongWord(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950ADigital->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DIGITAL_WIDTH:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DIGITAL_WIDTH\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34950ADigital->put_Width(_identifier.GetVal(), (Agilent34950AChannelWidthEnum)_val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950ADigital->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DIGITAL_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DIGITAL_POLARITY\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34950ADigital->put_Polarity(_identifier.GetVal(), (Agilent34950APolarityEnum)_val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950ADigital->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_CURRENT_SOURCE_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_CURRENT_SOURCE_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CURRENT_SOURCE_GAIN:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_CURRENT_SOURCE_GAIN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CURRENT_SOURCE_OFFSET:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_CURRENT_SOURCE_OFFSET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_STATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_OUTPUT_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OPERATION_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_OPERATION_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FUNCTION_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_FUNCTION_TYPE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951ASource* pIAgilent34951ASource = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951ASource);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34951ASource->put_FunctionType(_identifier.GetVal(), (Agilent34951AFunctionTypeEnum)_val.GetVal());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					pIAgilent34951ASource->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_NUM_CYCLES:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_NUM_CYCLES\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951ASource* pIAgilent34951ASource = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951ASource);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34951ASource->put_NumCycles(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					pIAgilent34951ASource->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_START_INDEX:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_START_INDEX\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951ASource* pIAgilent34951ASource = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951ASource);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34951ASource->put_StartIndex(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					pIAgilent34951ASource->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TRACE_NAME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_TRACE_NAME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SOURCE_FREQUENCY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_SOURCE_FREQUENCY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_TRIGGER_SOURCE_34951A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_TRACE_TRIGGER_SOURCE_34951A\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951ATrigger* pIAgilent34951ATrigger = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951ATrigger);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34951ATrigger->put_Source(_identifier.GetVal(), (Agilent34951ATraceTriggerSourceEnum)_val.GetVal());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					pIAgilent34951ATrigger->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TRACE_CLOCK_SOURCE_34951A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_TRACE_CLOCK_SOURCE_34951A\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951ATrigger* pIAgilent34951ATrigger = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951ATrigger);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34951ATrigger->put_ClockSource(_identifier.GetVal(), (Agilent34951AClockSourceEnum)_val.GetVal());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					pIAgilent34951ATrigger->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TRACE_CLOCK_PERIOD_34951A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_TRACE_CLOCK_PERIOD_34951A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VOLTAGE_SOURCE_GAIN:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_VOLTAGE_SOURCE_GAIN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VOLTAGE_SOURCE_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_VOLTAGE_SOURCE_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VOLTAGE_SOURCE_OFFSET:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_VOLTAGE_SOURCE_OFFSET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DAC_VOLTAGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DAC_VOLTAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_MODE_34952A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_TOTALIZER_MODE_34952A\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34952A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34952ATotalize* pIAgilent34952ATotalize = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34952ATotalize);
				status = TranslateHRESULTAgilent34952A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34952ATotalize->put_Mode(_identifier.GetVal(), (Agilent34952ATotalizeThresholdModeEnum)_val.GetVal());
					status = TranslateHRESULTAgilent34952A(Vi, hr);
					pIAgilent34952ATotalize->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_READ_TYPE_34952A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_TOTALIZER_READ_TYPE_34952A\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34952A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34952ATotalize* pIAgilent34952ATotalize = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34952ATotalize);
				status = TranslateHRESULTAgilent34952A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34952ATotalize->put_ReadType(_identifier.GetVal(), (Agilent34952ATotalizeTypeEnum)_val.GetVal());
					status = TranslateHRESULTAgilent34952A(Vi, hr);
					pIAgilent34952ATotalize->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_SLOPE_34952A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_TOTALIZER_SLOPE_34952A\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34952A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34952ATotalize* pIAgilent34952ATotalize = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34952ATotalize);
				status = TranslateHRESULTAgilent34952A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34952ATotalize->put_Slope(_identifier.GetVal(), (Agilent34952ATotalizeSlopeEnum)_val.GetVal());
					status = TranslateHRESULTAgilent34952A(Vi, hr);
					pIAgilent34952ATotalize->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DRIVE_STATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DRIVE_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PAIRED_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_PAIRED_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_PULSE_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_WIDTH_34945A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_PULSE_WIDTH_34945A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RECOVERY_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_RECOVERY_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SETTLE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_SETTLE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VERIFICATION_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_VERIFICATION_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VERIFICATION_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_VERIFICATION_POLARITY\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34945A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34945AChannel* pIAgilent34945AChannel = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34945AChannel);
				status = TranslateHRESULTAgilent34945A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34945AChannel->put_VerificationPolarity(_identifier.GetVal(), (Agilent34945APolarityEnum)_val.GetVal());
					status = TranslateHRESULTAgilent34945A(Vi, hr);
					pIAgilent34945AChannel->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_STATE_AT_RESET:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_STATE_AT_RESET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_CHANNEL_LIMIT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DRIVE_CHANNEL_LIMIT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34945A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34945AModule* pIAgilent34945AModule = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34945AModule);
				status = TranslateHRESULTAgilent34945A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34945AModule->put_DriveChannelLimit(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34945A(Vi, hr);
					pIAgilent34945AModule->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DRIVE_SOURCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DRIVE_SOURCE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34945A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34945AModule* pIAgilent34945AModule = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34945AModule);
				status = TranslateHRESULTAgilent34945A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34945AModule->put_DriveSource(_identifier.GetVal(), (Agilent34945ADriveSourceEnum)_val.GetVal());
					status = TranslateHRESULTAgilent34945A(Vi, hr);
					pIAgilent34945AModule->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DRIVE_SOURCE_BOOT_STATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_DRIVE_SOURCE_BOOT_STATE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34945A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34945AModule* pIAgilent34945AModule = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34945AModule);
				status = TranslateHRESULTAgilent34945A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CLong _val(AttributeValue);
					hr = pIAgilent34945AModule->put_DriveSourceBootState(_identifier.GetVal(), (Agilent34945ADriveSourceEnum)_val.GetVal());
					status = TranslateHRESULTAgilent34945A(Vi, hr);
					pIAgilent34945AModule->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_IS_CLOSED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: AG34980A_ATTR_IS_CLOSED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						

		default:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViInt32: Invalid Attribute=%d\n"), AttributeID);

			status = IviSession_SetError(Vi, IVIC_ERROR_INVALID_ATTRIBUTE, "Attribute not recognized.");
			status = IVIC_ERROR_INVALID_ATTRIBUTE;
			break;
		}
	}
	
	return status;
}


ViStatus _VI_FUNC  ag34980a_SetAttributeViReal64 ( ViSession Vi, ViConstString RepCapIdentifier, ViAttr AttributeID, ViReal64 AttributeValue )
{
	ViStatus status = VI_SUCCESS;

	switch (AttributeID)
	{
		case AG34980A_ATTR_SPECIFIC_DRIVER_DESCRIPTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_SPECIFIC_DRIVER_DESCRIPTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_PREFIX:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_SPECIFIC_DRIVER_PREFIX\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_VENDOR:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_SPECIFIC_DRIVER_VENDOR\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_REVISION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_SPECIFIC_DRIVER_REVISION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MAJOR_VERSION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MAJOR_VERSION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MINOR_VERSION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MINOR_VERSION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_LOGICAL_NAME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_LOGICAL_NAME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IO_RESOURCE_DESCRIPTOR:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_IO_RESOURCE_DESCRIPTOR\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CACHE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_CACHE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INTERCHANGE_CHECK:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_INTERCHANGE_CHECK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_QUERY_INSTRUMENT_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_QUERY_INSTRUMENT_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RANGE_CHECK:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_RANGE_CHECK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RECORD_COERCIONS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_RECORD_COERCIONS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SIMULATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_SIMULATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVER_SETUP:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DRIVER_SETUP\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INSTRUMENT_MANUFACTURER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_INSTRUMENT_MANUFACTURER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INSTRUMENT_MODEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_INSTRUMENT_MODEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INSTRUMENT_FIRMWARE_REVISION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_INSTRUMENT_FIRMWARE_REVISION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SUPPORTED_INSTRUMENT_MODELS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_SUPPORTED_INSTRUMENT_MODELS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GROUP_CAPABILITIES:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_GROUP_CAPABILITIES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_LOWER_LIMIT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_ALARM_LOWER_LIMIT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AAlarm* pIAgilent34980AAlarm = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AAlarm);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34980AAlarm->put_LowerLimit(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AAlarm->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_ALARM_LOWER_LIMIT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_ALARM_LOWER_LIMIT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_ALARM_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_QUERYALARMQUEUE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_QUERYALARMQUEUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_SLOPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_ALARM_SLOPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_UPPER_LIMIT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_ALARM_UPPER_LIMIT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AAlarm* pIAgilent34980AAlarm = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AAlarm);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34980AAlarm->put_UpperLimit(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AAlarm->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_ALARM_UPPER_LIMIT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_ALARM_UPPER_LIMIT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_VOLTAGE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_AC_VOLTAGE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_VOLTAGE_BANDWIDTH:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_AC_VOLTAGE_BANDWIDTH\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AACVoltage* pIAgilent34980AACVoltage = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AACVoltage);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34980AACVoltage->put_Bandwidth(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AACVoltage->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_AC_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_AC_VOLTAGE_RANGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AACVoltage* pIAgilent34980AACVoltage = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AACVoltage);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34980AACVoltage->put_Range(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AACVoltage->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_AC_CURRENT_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_AC_CURRENT_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_CURRENT_BANDWIDTH:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_AC_CURRENT_BANDWIDTH\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AACCurrent* pIAgilent34980AACCurrent = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AACCurrent);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34980AACCurrent->put_Bandwidth(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AACCurrent->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_AC_CURRENT_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_AC_CURRENT_RANGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AACCurrent* pIAgilent34980AACCurrent = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AACCurrent);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34980AACCurrent->put_Range(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AACCurrent->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_SECURITY_PASSWORD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_SECURITY_PASSWORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_MAINFRAME_MESSAGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_CAL_MAINFRAME_MESSAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_TOTAL_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_CAL_TOTAL_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_LINE_FREQUENCY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_CAL_LINE_FREQUENCY\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ACalibration* pIAgilent34980ACalibration = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ACalibration);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CDouble _val(AttributeValue);
					hr = pIAgilent34980ACalibration->put_LineFrequency(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ACalibration->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_SECURITY_STATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_SECURITY_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DC_CURRENT_APERTURE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADCCurrent* pIAgilent34980ADCCurrent = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADCCurrent);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34980ADCCurrent->put_Aperture(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ADCCurrent->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DC_CURRENT_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DC_CURRENT_NPLC\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADCCurrent* pIAgilent34980ADCCurrent = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADCCurrent);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34980ADCCurrent->put_NPLC(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ADCCurrent->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DC_CURRENT_RANGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADCCurrent* pIAgilent34980ADCCurrent = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADCCurrent);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34980ADCCurrent->put_Range(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ADCCurrent->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DC_CURRENT_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DC_CURRENT_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DC_VOLTAGE_APERTURE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADCVoltage* pIAgilent34980ADCVoltage = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADCVoltage);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34980ADCVoltage->put_Aperture(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ADCVoltage->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DC_VOLTAGE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DC_VOLTAGE_NPLC\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADCVoltage* pIAgilent34980ADCVoltage = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADCVoltage);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34980ADCVoltage->put_NPLC(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ADCVoltage->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DC_VOLTAGE_RANGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADCVoltage* pIAgilent34980ADCVoltage = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADCVoltage);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34980ADCVoltage->put_Range(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ADCVoltage->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DC_VOLTAGE_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DC_VOLTAGE_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_AUTO_IMPEDANCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DC_VOLTAGE_AUTO_IMPEDANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GETRELAYCYCLES:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_GETRELAYCYCLES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DISPLAY_ENABLED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DISPLAY_ENABLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DISPLAY_TEXT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DISPLAY_TEXT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MONITOR_DATA:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_MONITOR_DATA\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_MONITOR_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_MONITOR_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MONITOR_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_MONITOR_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ENABLE_MONITOR_CHAN:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_ENABLE_MONITOR_CHAN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SELECT_MONITOR_CHAN:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_SELECT_MONITOR_CHAN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_FREQUENCY_APERTURE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AFrequency* pIAgilent34980AFrequency = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AFrequency);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34980AFrequency->put_Aperture(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AFrequency->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE_AUTO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE_AUTO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_LOW_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_FREQUENCY_LOW_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_FRESISTANCE_APERTURE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AFResistance* pIAgilent34980AFResistance = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AFResistance);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34980AFResistance->put_Aperture(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AFResistance->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_FRESISTANCE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_FRESISTANCE_NPLC\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AFResistance* pIAgilent34980AFResistance = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AFResistance);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34980AFResistance->put_NPLC(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AFResistance->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_FRESISTANCE_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_FRESISTANCE_RANGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AFResistance* pIAgilent34980AFResistance = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AFResistance);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34980AFResistance->put_Range(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AFResistance->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_FRESISTANCE_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_MEASUREMENT_READING_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_MEASUREMENT_READING_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEASUREMENT_FUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_MEASUREMENT_FUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AUTO_RECALL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_AUTO_RECALL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_NUMBER_OF_STATES:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_NUMBER_OF_STATES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEMORY_CATALOG:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_MEMORY_CATALOG\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PERIOD_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_PERIOD_APERTURE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980APeriod* pIAgilent34980APeriod = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980APeriod);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34980APeriod->put_Aperture(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980APeriod->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_PERIOD_VOLTAGE_RANGE_AUTO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_PERIOD_VOLTAGE_RANGE_AUTO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PERIOD_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_PERIOD_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_RESISTANCE_APERTURE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AResistance* pIAgilent34980AResistance = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AResistance);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34980AResistance->put_Aperture(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AResistance->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_RESISTANCE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_RESISTANCE_NPLC\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AResistance* pIAgilent34980AResistance = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AResistance);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34980AResistance->put_NPLC(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AResistance->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_RESISTANCE_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_RESISTANCE_RANGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AResistance* pIAgilent34980AResistance = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AResistance);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34980AResistance->put_Range(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AResistance->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_RESISTANCE_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_RESISTANCE_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_GAIN:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_SCALE_GAIN\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AScale* pIAgilent34980AScale = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AScale);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34980AScale->put_Gain(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AScale->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_SCALE_OFFSET:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_SCALE_OFFSET\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AScale* pIAgilent34980AScale = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AScale);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34980AScale->put_Offset(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AScale->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_SCALE_STATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_SCALE_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_UNIT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_SCALE_UNIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_AUTO_DELAY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_CHANNEL_AUTO_DELAY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_DELAY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_CHANNEL_DELAY\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ARoute* pIAgilent34980ARoute = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ARoute);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34980ARoute->put_Delay(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ARoute->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_CHANNEL_FWIRE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_CHANNEL_FWIRE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ROUTE_DONE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_ROUTE_DONE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_IS_CLOSED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_CHANNEL_IS_CLOSED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_SCAN_SIZE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_CHANNEL_SCAN_SIZE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_SCAN_LIST:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_CHANNEL_SCAN_LIST\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_SCAN_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_CHANNEL_SCAN_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCAN_SWEEP_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_SCAN_SWEEP_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ORDERED_SCAN:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_ORDERED_SCAN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_AVERAGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_STATISTICS_AVERAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_STATISTICS_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MAX_VALUE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_STATISTICS_MAX_VALUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MAX_VALUE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_STATISTICS_MAX_VALUE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MIN_VALUE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_STATISTICS_MIN_VALUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MIN_VALUE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_STATISTICS_MIN_VALUE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_PTPEAK:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_STATISTICS_PTPEAK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_SERIAL_POLL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_SERIAL_POLL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ASYNC_EVENTS_ENABLED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_ASYNC_EVENTS_ENABLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SYSTEM_DATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_SYSTEM_DATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DMM_ENABLED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DMM_ENABLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DMM_INSTALLED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DMM_INSTALLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_READING_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_READING_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SERIAL_NUMBER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_SERIAL_NUMBER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SYSTEM_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_SYSTEM_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TIMEOUT_MILLISECONDS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_TIMEOUT_MILLISECONDS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_LOCK_OWNER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_LOCK_OWNER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MODULE_EVENTS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_MODULE_EVENTS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_READING_UNITS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_TEMPERATURE_READING_UNITS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_TEMPERATURE_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_TEMPERATURE_NPLC\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ATemperature* pIAgilent34980ATemperature = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ATemperature);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34980ATemperature->put_NPLC(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ATemperature->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_TRANSDUCERTYPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_TEMPERATURE_TRANSDUCERTYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_RESISTANCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_FRTD_RESISTANCE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AFRTD* pIAgilent34980AFRTD = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AFRTD);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34980AFRTD->put_Resistance(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AFRTD->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_FRTD_ALPHA:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_FRTD_ALPHA\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_IS_EXTERNAL_REFERENCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_FRTD_IS_EXTERNAL_REFERENCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_FRTD_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_ALARM_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DATA_FORMAT_ALARM_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_CHANNEL_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DATA_FORMAT_CHANNEL_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_TIME_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DATA_FORMAT_TIME_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_TIME_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DATA_FORMAT_TIME_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_UNIT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DATA_FORMAT_UNIT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_RESISTANCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_RTD_RESISTANCE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ARTD* pIAgilent34980ARTD = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ARTD);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34980ARTD->put_Resistance(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ARTD->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_RTD_ALPHA:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_RTD_ALPHA\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_IS_EXTERNAL_REFERENCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_RTD_IS_EXTERNAL_REFERENCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_RTD_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMISTOR_RESISTANCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_THERMISTOR_RESISTANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMISTOR_IS_EXTERNAL_REFERENCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_THERMISTOR_IS_EXTERNAL_REFERENCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_THERMOCOUPLE_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_JUNCTION_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_THERMOCOUPLE_JUNCTION_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_FIXED_REFERENCE_JUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_THERMOCOUPLE_FIXED_REFERENCE_JUNCTION\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AThermocouple* pIAgilent34980AThermocouple = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AThermocouple);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34980AThermocouple->put_FixedReferenceJunction(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AThermocouple->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_CHECK:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_THERMOCOUPLE_CHECK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_AUTO_IMPEDANCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_THERMOCOUPLE_AUTO_IMPEDANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_EXTERNAL_REFERENCE_JUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_THERMOCOUPLE_EXTERNAL_REFERENCE_JUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_INTERNAL_REFERENCE_JUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_THERMOCOUPLE_INTERNAL_REFERENCE_JUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_SAMPLE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_TRIGGER_SAMPLE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_TRIGGER_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_SOURCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_TRIGGER_SOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_TIMER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_TRIGGER_TIMER\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ATrigger* pIAgilent34980ATrigger = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ATrigger);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CDouble _val(AttributeValue);
					hr = pIAgilent34980ATrigger->put_Timer(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ATrigger->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DELAY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DELAY\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ATrigger* pIAgilent34980ATrigger = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ATrigger);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CDouble _val(AttributeValue);
					hr = pIAgilent34980ATrigger->put_Delay(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ATrigger->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DELAY_AUTO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DELAY_AUTO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_CHANNEL_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_DEBOUNCED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_IS_DEBOUNCED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_DMM_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_CAL_DMM_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_DMM_MESSAGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_CAL_DMM_MESSAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_VALUE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_CAL_VALUE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADMM* pIAgilent34980ADMM = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADMM);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CDouble _val(AttributeValue);
					hr = pIAgilent34980ADMM->put_Value(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ADMM->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_CHANNEL_LABEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_CHANNEL_LABEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SEQUENCE_CATALOG:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_SEQUENCE_CATALOG\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GETSEQUENCETRIGGERSOURCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_GETSEQUENCETRIGGERSOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_CONFIGURATION_CHANNEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_IS_CONFIGURATION_CHANNEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_SOURCE_CHANNEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_IS_SOURCE_CHANNEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_AC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_MAX_CARRY_AC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_AC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_MAX_SWITCHING_AC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_AC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_MAX_CARRY_AC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_AC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_MAX_SWITCHING_AC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_MAX_AC_VOLTAGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_MAX_AC_VOLTAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_BANDWIDTH:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_BANDWIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_DC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_MAX_CARRY_DC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_DC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_MAX_SWITCHING_DC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_DC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_MAX_CARRY_DC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_DC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_MAX_SWITCHING_DC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_MAX_DC_VOLTAGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_MAX_DC_VOLTAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_CHARACTERISTIC_IMPEDANCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_CHARACTERISTIC_IMPEDANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_SETTLING_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_SETTLING_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_WIRE_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_WIRE_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ASYNC_TIMEOUT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_ASYNC_TIMEOUT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AHandshake* pIAgilent34950AHandshake = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AHandshake);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34950AHandshake->put_AsyncTimeout(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950AHandshake->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_CYCLE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_HANDSHAKE_CYCLE_TIME\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AHandshake* pIAgilent34950AHandshake = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AHandshake);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34950AHandshake->put_CycleTime(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950AHandshake->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_HANDSHAKE_LEVEL\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AHandshake* pIAgilent34950AHandshake = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AHandshake);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34950AHandshake->put_Level(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950AHandshake->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_HANDSHAKE_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_RATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_HANDSHAKE_RATE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AHandshake* pIAgilent34950AHandshake = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AHandshake);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34950AHandshake->put_Rate(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950AHandshake->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_STATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_HANDSHAKE_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_SYNC_STROBE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_HANDSHAKE_SYNC_STROBE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_HANDSHAKE_THRESHOLD\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AHandshake* pIAgilent34950AHandshake = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AHandshake);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34950AHandshake->put_Threshold(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950AHandshake->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_DRIVE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_HANDSHAKE_DRIVE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_INPUT_THRESHOLD\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AInput* pIAgilent34950AInput = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AInput);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34950AInput->put_Threshold(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950AInput->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_COMPARE_ACTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_COMPARE_ACTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DATA_FORMAT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_POINTS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DATA_POINTS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ENABLE_INPUT_MEMORY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_ENABLE_INPUT_MEMORY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_INPUT_INTERRUPT_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_INPUT_INTERRUPT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_INPUT_INTERRUPT_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_INPUT_INTERRUPT_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_SAMPLE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_INPUT_SAMPLE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_INPUT_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_DRIVE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_OUTPUT_DRIVE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_VOLT_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_OUTPUT_VOLT_LEVEL\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AOutput* pIAgilent34950AOutput = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AOutput);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34950AOutput->put_VoltLevel(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950AOutput->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_OUTPUT_CYCLE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_OUTPUT_CYCLE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_OUTPUT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_INTERRUPT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_OUTPUT_INTERRUPT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_INTERRUPT_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_OUTPUT_INTERRUPT_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_INTERRUPT_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_OUTPUT_INTERRUPT_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_TRACE_SELECT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_OUTPUT_TRACE_SELECT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEMORY_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_MEMORY_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_CATALOG_34950A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_TRACE_CATALOG_34950A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_MEMORY_FREE_34950A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_TRACE_MEMORY_FREE_34950A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_FUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GATE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_GATE_TIME\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ACounter* pIAgilent34950ACounter = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ACounter);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34950ACounter->put_GateTime(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950ACounter->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_GATE_SOURCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_GATE_SOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GATE_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_GATE_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_SLOPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_COUNTER_SLOPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_COUNTER_THRESHOLD\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ACounter* pIAgilent34950ACounter = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ACounter);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34950ACounter->put_Threshold(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950ACounter->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_READ_TYPE_34950A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_TOTALIZER_READ_TYPE_34950A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_FREQUENCY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_COUNTER_FREQUENCY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_COUNTER_PERIOD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_COUNTER_PERIOD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_PULSE_WIDTH:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_PULSE_WIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_PULSE_DUTY_CYCLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_PULSE_DUTY_CYCLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_COUNTER_TOTALIZE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_COUNTER_TOTALIZE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_COMPARISON_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_COMPARISON_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DIGITAL_DIRECTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DIGITAL_DIRECTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_DATA_BYTE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_COMPARISON_DATA_BYTE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_DATA_WORD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_COMPARISON_DATA_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_DATA_LONG_WORD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_COMPARISON_DATA_LONG_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_ALARM_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_COMPARISON_ALARM_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_MASK_BYTE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_COMPARISON_MASK_BYTE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_MASK_WORD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_COMPARISON_MASK_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_MASK_LONG_WORD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_COMPARISON_MASK_LONG_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DIGITAL_WIDTH:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DIGITAL_WIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DIGITAL_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DIGITAL_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CURRENT_SOURCE_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_CURRENT_SOURCE_LEVEL\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951ACurrent* pIAgilent34951ACurrent = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951ACurrent);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34951ACurrent->put_Level(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					pIAgilent34951ACurrent->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_CURRENT_SOURCE_GAIN:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_CURRENT_SOURCE_GAIN\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951ACurrent* pIAgilent34951ACurrent = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951ACurrent);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34951ACurrent->put_Gain(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					pIAgilent34951ACurrent->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_CURRENT_SOURCE_OFFSET:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_CURRENT_SOURCE_OFFSET\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951ACurrent* pIAgilent34951ACurrent = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951ACurrent);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34951ACurrent->put_Offset(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					pIAgilent34951ACurrent->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_OUTPUT_STATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_OUTPUT_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OPERATION_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_OPERATION_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FUNCTION_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_FUNCTION_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_NUM_CYCLES:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_NUM_CYCLES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_START_INDEX:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_START_INDEX\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_NAME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_TRACE_NAME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SOURCE_FREQUENCY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_SOURCE_FREQUENCY\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951ASource* pIAgilent34951ASource = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951ASource);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34951ASource->put_Frequency(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					pIAgilent34951ASource->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TRACE_TRIGGER_SOURCE_34951A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_TRACE_TRIGGER_SOURCE_34951A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_CLOCK_SOURCE_34951A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_TRACE_CLOCK_SOURCE_34951A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_CLOCK_PERIOD_34951A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_TRACE_CLOCK_PERIOD_34951A\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951ATrigger* pIAgilent34951ATrigger = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951ATrigger);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34951ATrigger->put_ClockPeriod(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					pIAgilent34951ATrigger->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_VOLTAGE_SOURCE_GAIN:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_VOLTAGE_SOURCE_GAIN\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951AVoltage* pIAgilent34951AVoltage = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951AVoltage);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34951AVoltage->put_Gain(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					pIAgilent34951AVoltage->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_VOLTAGE_SOURCE_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_VOLTAGE_SOURCE_LEVEL\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951AVoltage* pIAgilent34951AVoltage = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951AVoltage);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34951AVoltage->put_Level(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					pIAgilent34951AVoltage->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_VOLTAGE_SOURCE_OFFSET:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_VOLTAGE_SOURCE_OFFSET\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951AVoltage* pIAgilent34951AVoltage = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951AVoltage);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34951AVoltage->put_Offset(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					pIAgilent34951AVoltage->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DAC_VOLTAGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DAC_VOLTAGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34952A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34952ADAC* pIAgilent34952ADAC = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34952ADAC);
				status = TranslateHRESULTAgilent34952A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34952ADAC->put_Voltage(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34952A(Vi, hr);
					pIAgilent34952ADAC->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_MODE_34952A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_TOTALIZER_MODE_34952A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_READ_TYPE_34952A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_TOTALIZER_READ_TYPE_34952A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_SLOPE_34952A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_TOTALIZER_SLOPE_34952A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_STATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DRIVE_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PAIRED_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_PAIRED_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_PULSE_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_WIDTH_34945A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_PULSE_WIDTH_34945A\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34945A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34945AChannel* pIAgilent34945AChannel = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34945AChannel);
				status = TranslateHRESULTAgilent34945A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34945AChannel->put_PulseWidth(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34945A(Vi, hr);
					pIAgilent34945AChannel->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_RECOVERY_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_RECOVERY_TIME\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34945A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34945AChannel* pIAgilent34945AChannel = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34945AChannel);
				status = TranslateHRESULTAgilent34945A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34945AChannel->put_RecoveryTime(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34945A(Vi, hr);
					pIAgilent34945AChannel->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_SETTLE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_SETTLE_TIME\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34945A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34945AChannel* pIAgilent34945AChannel = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34945AChannel);
				status = TranslateHRESULTAgilent34945A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CDouble _val(AttributeValue);
					hr = pIAgilent34945AChannel->put_SettleTime(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34945A(Vi, hr);
					pIAgilent34945AChannel->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_VERIFICATION_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_VERIFICATION_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VERIFICATION_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_VERIFICATION_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATE_AT_RESET:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_STATE_AT_RESET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_CHANNEL_LIMIT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DRIVE_CHANNEL_LIMIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_SOURCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DRIVE_SOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_SOURCE_BOOT_STATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_DRIVE_SOURCE_BOOT_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_CLOSED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: AG34980A_ATTR_IS_CLOSED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						

		default:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViReal64: Invalid Attribute=%d\n"), AttributeID);

			status = IviSession_SetError(Vi, IVIC_ERROR_INVALID_ATTRIBUTE, "Attribute not recognized.");
			status = IVIC_ERROR_INVALID_ATTRIBUTE;
			break;
		}
	}
	
	return status;
}


ViStatus _VI_FUNC  ag34980a_SetAttributeViBoolean ( ViSession Vi, ViConstString RepCapIdentifier, ViAttr AttributeID, ViBoolean AttributeValue )
{
	ViStatus status = VI_SUCCESS;

	switch (AttributeID)
	{
		case AG34980A_ATTR_SPECIFIC_DRIVER_DESCRIPTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_SPECIFIC_DRIVER_DESCRIPTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_PREFIX:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_SPECIFIC_DRIVER_PREFIX\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_VENDOR:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_SPECIFIC_DRIVER_VENDOR\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_REVISION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_SPECIFIC_DRIVER_REVISION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MAJOR_VERSION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MAJOR_VERSION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MINOR_VERSION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MINOR_VERSION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_LOGICAL_NAME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_LOGICAL_NAME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IO_RESOURCE_DESCRIPTOR:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_IO_RESOURCE_DESCRIPTOR\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CACHE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_CACHE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IIviDriverOperation* pIIviDriverOperation = NULL;
				hr = pDriver->QueryInterface(&pIIviDriverOperation);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val(AttributeValue);
					hr = pIIviDriverOperation->put_Cache(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIIviDriverOperation->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_INTERCHANGE_CHECK:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_INTERCHANGE_CHECK\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IIviDriverOperation* pIIviDriverOperation = NULL;
				hr = pDriver->QueryInterface(&pIIviDriverOperation);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val(AttributeValue);
					hr = pIIviDriverOperation->put_InterchangeCheck(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIIviDriverOperation->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_QUERY_INSTRUMENT_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_QUERY_INSTRUMENT_STATUS\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IIviDriverOperation* pIIviDriverOperation = NULL;
				hr = pDriver->QueryInterface(&pIIviDriverOperation);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val(AttributeValue);
					hr = pIIviDriverOperation->put_QueryInstrumentStatus(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIIviDriverOperation->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_RANGE_CHECK:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_RANGE_CHECK\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IIviDriverOperation* pIIviDriverOperation = NULL;
				hr = pDriver->QueryInterface(&pIIviDriverOperation);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val(AttributeValue);
					hr = pIIviDriverOperation->put_RangeCheck(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIIviDriverOperation->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_RECORD_COERCIONS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_RECORD_COERCIONS\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IIviDriverOperation* pIIviDriverOperation = NULL;
				hr = pDriver->QueryInterface(&pIIviDriverOperation);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val(AttributeValue);
					hr = pIIviDriverOperation->put_RecordCoercions(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIIviDriverOperation->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_SIMULATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_SIMULATE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IIviDriverOperation* pIIviDriverOperation = NULL;
				hr = pDriver->QueryInterface(&pIIviDriverOperation);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val(AttributeValue);
					hr = pIIviDriverOperation->put_Simulate(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIIviDriverOperation->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DRIVER_SETUP:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DRIVER_SETUP\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INSTRUMENT_MANUFACTURER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_INSTRUMENT_MANUFACTURER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INSTRUMENT_MODEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_INSTRUMENT_MODEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INSTRUMENT_FIRMWARE_REVISION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_INSTRUMENT_FIRMWARE_REVISION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SUPPORTED_INSTRUMENT_MODELS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_SUPPORTED_INSTRUMENT_MODELS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GROUP_CAPABILITIES:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_GROUP_CAPABILITIES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_LOWER_LIMIT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_ALARM_LOWER_LIMIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_LOWER_LIMIT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_ALARM_LOWER_LIMIT_ENABLE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AAlarm* pIAgilent34980AAlarm = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AAlarm);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980AAlarm->put_LowerLimitEnable(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AAlarm->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_ALARM_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_ALARM_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_QUERYALARMQUEUE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_QUERYALARMQUEUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_SLOPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_ALARM_SLOPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_UPPER_LIMIT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_ALARM_UPPER_LIMIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_UPPER_LIMIT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_ALARM_UPPER_LIMIT_ENABLE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AAlarm* pIAgilent34980AAlarm = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AAlarm);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980AAlarm->put_UpperLimitEnable(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AAlarm->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_AC_VOLTAGE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_AC_VOLTAGE_AUTORANGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AACVoltage* pIAgilent34980AACVoltage = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AACVoltage);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980AACVoltage->put_AutoRange(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AACVoltage->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_AC_VOLTAGE_BANDWIDTH:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_AC_VOLTAGE_BANDWIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_AC_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_CURRENT_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_AC_CURRENT_AUTORANGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AACCurrent* pIAgilent34980AACCurrent = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AACCurrent);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980AACCurrent->put_AutoRange(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AACCurrent->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_AC_CURRENT_BANDWIDTH:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_AC_CURRENT_BANDWIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_CURRENT_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_AC_CURRENT_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SECURITY_PASSWORD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_SECURITY_PASSWORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_MAINFRAME_MESSAGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_CAL_MAINFRAME_MESSAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_TOTAL_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_CAL_TOTAL_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_LINE_FREQUENCY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_CAL_LINE_FREQUENCY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SECURITY_STATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_SECURITY_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DC_CURRENT_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DC_CURRENT_AUTORANGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADCCurrent* pIAgilent34980ADCCurrent = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADCCurrent);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980ADCCurrent->put_AutoRange(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ADCCurrent->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DC_CURRENT_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DC_CURRENT_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DC_CURRENT_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DC_CURRENT_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DC_VOLTAGE_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DC_VOLTAGE_AUTORANGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADCVoltage* pIAgilent34980ADCVoltage = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADCVoltage);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980ADCVoltage->put_AutoRange(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ADCVoltage->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DC_VOLTAGE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DC_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DC_VOLTAGE_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DC_VOLTAGE_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_AUTO_IMPEDANCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DC_VOLTAGE_AUTO_IMPEDANCE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADCVoltage* pIAgilent34980ADCVoltage = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADCVoltage);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980ADCVoltage->put_AutoImpedance(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ADCVoltage->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_GETRELAYCYCLES:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_GETRELAYCYCLES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DISPLAY_ENABLED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DISPLAY_ENABLED\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADisplay* pIAgilent34980ADisplay = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADisplay);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980ADisplay->put_DisplayEnabled(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ADisplay->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DISPLAY_TEXT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DISPLAY_TEXT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MONITOR_DATA:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_MONITOR_DATA\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MONITOR_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_MONITOR_ENABLE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADisplay* pIAgilent34980ADisplay = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADisplay);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980ADisplay->put_MonitorEnable(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ADisplay->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_MONITOR_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_MONITOR_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ENABLE_MONITOR_CHAN:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_ENABLE_MONITOR_CHAN\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADisplay* pIAgilent34980ADisplay = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADisplay);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980ADisplay->put_EnableMonitorChan(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ADisplay->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_SELECT_MONITOR_CHAN:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_SELECT_MONITOR_CHAN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_FREQUENCY_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE_AUTO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE_AUTO\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AFrequency* pIAgilent34980AFrequency = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AFrequency);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980AFrequency->put_AutoRange(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AFrequency->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_LOW_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_FREQUENCY_LOW_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_FRESISTANCE_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_FRESISTANCE_AUTORANGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AFResistance* pIAgilent34980AFResistance = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AFResistance);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980AFResistance->put_AutoRange(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AFResistance->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_FRESISTANCE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_FRESISTANCE_OCOMPENSATED\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AFResistance* pIAgilent34980AFResistance = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AFResistance);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980AFResistance->put_OCompensated(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AFResistance->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_FRESISTANCE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_FRESISTANCE_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEASUREMENT_READING_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_MEASUREMENT_READING_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEASUREMENT_FUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_MEASUREMENT_FUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AUTO_RECALL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_AUTO_RECALL\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AMemory* pIAgilent34980AMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AMemory);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980AMemory->put_AutoRecall(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_NUMBER_OF_STATES:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_NUMBER_OF_STATES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEMORY_CATALOG:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_MEMORY_CATALOG\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PERIOD_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_PERIOD_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PERIOD_VOLTAGE_RANGE_AUTO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_PERIOD_VOLTAGE_RANGE_AUTO\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980APeriod* pIAgilent34980APeriod = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980APeriod);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980APeriod->put_AutoRange(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980APeriod->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_PERIOD_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_PERIOD_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_RESISTANCE_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_RESISTANCE_AUTORANGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AResistance* pIAgilent34980AResistance = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AResistance);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980AResistance->put_AutoRange(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AResistance->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_RESISTANCE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_RESISTANCE_OCOMPENSATED\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AResistance* pIAgilent34980AResistance = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AResistance);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980AResistance->put_OCompensated(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AResistance->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_RESISTANCE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_RESISTANCE_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_RESISTANCE_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_GAIN:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_SCALE_GAIN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_OFFSET:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_SCALE_OFFSET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_STATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_SCALE_STATE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AScale* pIAgilent34980AScale = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AScale);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980AScale->put_State(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AScale->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_SCALE_UNIT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_SCALE_UNIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_AUTO_DELAY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_CHANNEL_AUTO_DELAY\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ARoute* pIAgilent34980ARoute = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ARoute);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980ARoute->put_AutoDelay(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ARoute->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_CHANNEL_DELAY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_CHANNEL_DELAY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_FWIRE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_CHANNEL_FWIRE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ARoute* pIAgilent34980ARoute = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ARoute);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980ARoute->put_FWire(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ARoute->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_ROUTE_DONE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_ROUTE_DONE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_IS_CLOSED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_CHANNEL_IS_CLOSED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_SCAN_SIZE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_CHANNEL_SCAN_SIZE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_SCAN_LIST:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_CHANNEL_SCAN_LIST\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_SCAN_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_CHANNEL_SCAN_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCAN_SWEEP_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_SCAN_SWEEP_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ORDERED_SCAN:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_ORDERED_SCAN\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AScan* pIAgilent34980AScan = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AScan);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980AScan->put_OrderedScan(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AScan->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_STATISTICS_AVERAGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_STATISTICS_AVERAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_STATISTICS_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MAX_VALUE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_STATISTICS_MAX_VALUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MAX_VALUE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_STATISTICS_MAX_VALUE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MIN_VALUE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_STATISTICS_MIN_VALUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MIN_VALUE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_STATISTICS_MIN_VALUE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_PTPEAK:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_STATISTICS_PTPEAK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SERIAL_POLL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_SERIAL_POLL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ASYNC_EVENTS_ENABLED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_ASYNC_EVENTS_ENABLED\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ASystem* pIAgilent34980ASystem = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ASystem);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980ASystem->put_AsyncEventsEnabled(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ASystem->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_SYSTEM_DATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_SYSTEM_DATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DMM_ENABLED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DMM_ENABLED\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ASystem* pIAgilent34980ASystem = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ASystem);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980ASystem->put_DMMEnabled(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ASystem->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DMM_INSTALLED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DMM_INSTALLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_READING_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_READING_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SERIAL_NUMBER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_SERIAL_NUMBER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SYSTEM_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_SYSTEM_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TIMEOUT_MILLISECONDS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_TIMEOUT_MILLISECONDS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_LOCK_OWNER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_LOCK_OWNER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MODULE_EVENTS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_MODULE_EVENTS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_READING_UNITS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_TEMPERATURE_READING_UNITS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_TEMPERATURE_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_TEMPERATURE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_TRANSDUCERTYPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_TEMPERATURE_TRANSDUCERTYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_RESISTANCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_FRTD_RESISTANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_ALPHA:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_FRTD_ALPHA\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_IS_EXTERNAL_REFERENCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_FRTD_IS_EXTERNAL_REFERENCE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AFRTD* pIAgilent34980AFRTD = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AFRTD);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980AFRTD->put_IsExternalReference(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AFRTD->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_FRTD_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_FRTD_OCOMPENSATED\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AFRTD* pIAgilent34980AFRTD = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AFRTD);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980AFRTD->put_OCompensated(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AFRTD->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_ALARM_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DATA_FORMAT_ALARM_ENABLE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADataFormat* pIAgilent34980ADataFormat = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADataFormat);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980ADataFormat->put_AlarmEnable(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ADataFormat->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_CHANNEL_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DATA_FORMAT_CHANNEL_ENABLE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADataFormat* pIAgilent34980ADataFormat = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADataFormat);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980ADataFormat->put_ChannelEnable(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ADataFormat->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_TIME_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DATA_FORMAT_TIME_ENABLE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADataFormat* pIAgilent34980ADataFormat = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADataFormat);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980ADataFormat->put_TimeEnable(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ADataFormat->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_TIME_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DATA_FORMAT_TIME_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_UNIT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DATA_FORMAT_UNIT_ENABLE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADataFormat* pIAgilent34980ADataFormat = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADataFormat);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980ADataFormat->put_UnitEnable(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ADataFormat->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_RTD_RESISTANCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_RTD_RESISTANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_ALPHA:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_RTD_ALPHA\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_IS_EXTERNAL_REFERENCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_RTD_IS_EXTERNAL_REFERENCE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ARTD* pIAgilent34980ARTD = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ARTD);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980ARTD->put_IsExternalReference(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ARTD->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_RTD_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_RTD_OCOMPENSATED\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ARTD* pIAgilent34980ARTD = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ARTD);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980ARTD->put_OCompensated(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ARTD->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_THERMISTOR_RESISTANCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_THERMISTOR_RESISTANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMISTOR_IS_EXTERNAL_REFERENCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_THERMISTOR_IS_EXTERNAL_REFERENCE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AThermistor* pIAgilent34980AThermistor = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AThermistor);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980AThermistor->put_IsExternalReference(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AThermistor->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_THERMOCOUPLE_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_JUNCTION_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_THERMOCOUPLE_JUNCTION_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_FIXED_REFERENCE_JUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_THERMOCOUPLE_FIXED_REFERENCE_JUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_CHECK:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_THERMOCOUPLE_CHECK\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AThermocouple* pIAgilent34980AThermocouple = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AThermocouple);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980AThermocouple->put_Check(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AThermocouple->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_AUTO_IMPEDANCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_THERMOCOUPLE_AUTO_IMPEDANCE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AThermocouple* pIAgilent34980AThermocouple = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AThermocouple);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980AThermocouple->put_AutoImpedance(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AThermocouple->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_EXTERNAL_REFERENCE_JUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_THERMOCOUPLE_EXTERNAL_REFERENCE_JUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_INTERNAL_REFERENCE_JUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_THERMOCOUPLE_INTERNAL_REFERENCE_JUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_SAMPLE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_TRIGGER_SAMPLE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_TRIGGER_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_SOURCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_TRIGGER_SOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_TIMER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_TRIGGER_TIMER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DELAY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DELAY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DELAY_AUTO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DELAY_AUTO\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ATrigger* pIAgilent34980ATrigger = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ATrigger);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34980ATrigger->put_DelayAuto(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ATrigger->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_CHANNEL_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_CHANNEL_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_DEBOUNCED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_IS_DEBOUNCED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_CAL_DMM_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_CAL_DMM_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_DMM_MESSAGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_CAL_DMM_MESSAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_VALUE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_CAL_VALUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_LABEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_CHANNEL_LABEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SEQUENCE_CATALOG:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_SEQUENCE_CATALOG\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GETSEQUENCETRIGGERSOURCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_GETSEQUENCETRIGGERSOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_CONFIGURATION_CHANNEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_IS_CONFIGURATION_CHANNEL\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				CAtlArray<CString> arSelectors;
				CRepCapSelector repCapSelector(RepCapIdentifier);

				IIviSwtchChannels* pIIviSwtchChannels = NULL;
				hr = pDriver->QueryInterface(&pIIviSwtchChannels);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					status = repCapSelector.GetSelectors(Vi, true, 0, arSelectors);
					if (status == VI_SUCCESS)
					{
						for (UINT i0 = 0; i0 < arSelectors.GetCount(); i0++)
						{
							IIviSwtchChannel* pIIviSwtchChannel = NULL;
							hr = pIIviSwtchChannels->get_Item(CComBSTR(arSelectors.GetAt(i0)), &pIIviSwtchChannel);
							status = TranslateHRESULT(Vi, hr);
							if (SUCCEEDED(hr))
							{
								CVariantBool _val(AttributeValue);
								hr = pIIviSwtchChannel->put_IsConfigurationChannel(_val.GetVal());
								status = TranslateHRESULT(Vi, hr);
								pIIviSwtchChannel->Release();
							}
						}
					}
					pIIviSwtchChannels->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_IS_SOURCE_CHANNEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_IS_SOURCE_CHANNEL\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				CAtlArray<CString> arSelectors;
				CRepCapSelector repCapSelector(RepCapIdentifier);

				IIviSwtchChannels* pIIviSwtchChannels = NULL;
				hr = pDriver->QueryInterface(&pIIviSwtchChannels);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					status = repCapSelector.GetSelectors(Vi, true, 0, arSelectors);
					if (status == VI_SUCCESS)
					{
						for (UINT i0 = 0; i0 < arSelectors.GetCount(); i0++)
						{
							IIviSwtchChannel* pIIviSwtchChannel = NULL;
							hr = pIIviSwtchChannels->get_Item(CComBSTR(arSelectors.GetAt(i0)), &pIIviSwtchChannel);
							status = TranslateHRESULT(Vi, hr);
							if (SUCCEEDED(hr))
							{
								CVariantBool _val(AttributeValue);
								hr = pIIviSwtchChannel->put_IsSourceChannel(_val.GetVal());
								status = TranslateHRESULT(Vi, hr);
								pIIviSwtchChannel->Release();
							}
						}
					}
					pIIviSwtchChannels->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_AC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_MAX_CARRY_AC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_AC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_MAX_SWITCHING_AC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_AC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_MAX_CARRY_AC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_AC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_MAX_SWITCHING_AC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_AC_VOLTAGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_MAX_AC_VOLTAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_BANDWIDTH:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_BANDWIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_DC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_MAX_CARRY_DC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_DC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_MAX_SWITCHING_DC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_DC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_MAX_CARRY_DC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_DC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_MAX_SWITCHING_DC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_DC_VOLTAGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_MAX_DC_VOLTAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHARACTERISTIC_IMPEDANCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_CHARACTERISTIC_IMPEDANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SETTLING_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_SETTLING_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_WIRE_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_WIRE_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ASYNC_TIMEOUT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_ASYNC_TIMEOUT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_CYCLE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_HANDSHAKE_CYCLE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_HANDSHAKE_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_HANDSHAKE_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_RATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_HANDSHAKE_RATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_STATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_HANDSHAKE_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_SYNC_STROBE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_HANDSHAKE_SYNC_STROBE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_HANDSHAKE_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_DRIVE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_HANDSHAKE_DRIVE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_INPUT_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARE_ACTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_COMPARE_ACTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DATA_FORMAT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_POINTS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DATA_POINTS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ENABLE_INPUT_MEMORY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_ENABLE_INPUT_MEMORY\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AInputMemory* pIAgilent34950AInputMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AInputMemory);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34950AInputMemory->put_Enable(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950AInputMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_INPUT_INTERRUPT_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_INPUT_INTERRUPT_ENABLE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AInputMemory* pIAgilent34950AInputMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AInputMemory);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34950AInputMemory->put_InterruptEnable(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950AInputMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_INPUT_INTERRUPT_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_INPUT_INTERRUPT_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_INPUT_SAMPLE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_INPUT_SAMPLE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_INPUT_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_DRIVE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_OUTPUT_DRIVE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_VOLT_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_OUTPUT_VOLT_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_CYCLE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_OUTPUT_CYCLE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_OUTPUT_ENABLE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AOutputMemory* pIAgilent34950AOutputMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AOutputMemory);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34950AOutputMemory->put_Enable(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950AOutputMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_OUTPUT_INTERRUPT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_OUTPUT_INTERRUPT_ENABLE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AOutputMemory* pIAgilent34950AOutputMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AOutputMemory);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34950AOutputMemory->put_InterruptEnable(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950AOutputMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_OUTPUT_INTERRUPT_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_OUTPUT_INTERRUPT_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_INTERRUPT_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_OUTPUT_INTERRUPT_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_TRACE_SELECT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_OUTPUT_TRACE_SELECT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEMORY_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_MEMORY_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_TRACE_CATALOG_34950A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_TRACE_CATALOG_34950A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_MEMORY_FREE_34950A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_TRACE_MEMORY_FREE_34950A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_FUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GATE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_GATE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GATE_SOURCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_GATE_SOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GATE_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_GATE_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_SLOPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_COUNTER_SLOPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_COUNTER_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_READ_TYPE_34950A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_TOTALIZER_READ_TYPE_34950A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_FREQUENCY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_COUNTER_FREQUENCY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_PERIOD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_COUNTER_PERIOD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_WIDTH:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_PULSE_WIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_DUTY_CYCLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_PULSE_DUTY_CYCLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_TOTALIZE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_COUNTER_TOTALIZE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_COMPARISON_ENABLE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34950ADigital->put_ComparisonEnable(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950ADigital->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_COMPARISON_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_COMPARISON_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DIGITAL_DIRECTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DIGITAL_DIRECTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_DATA_BYTE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_COMPARISON_DATA_BYTE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_DATA_WORD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_COMPARISON_DATA_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_DATA_LONG_WORD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_COMPARISON_DATA_LONG_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_ALARM_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_COMPARISON_ALARM_ENABLE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34950ADigital->put_ComparisonAlarmEnable(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950ADigital->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_COMPARISON_MASK_BYTE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_COMPARISON_MASK_BYTE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_MASK_WORD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_COMPARISON_MASK_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_MASK_LONG_WORD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_COMPARISON_MASK_LONG_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DIGITAL_WIDTH:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DIGITAL_WIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DIGITAL_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DIGITAL_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CURRENT_SOURCE_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_CURRENT_SOURCE_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CURRENT_SOURCE_GAIN:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_CURRENT_SOURCE_GAIN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CURRENT_SOURCE_OFFSET:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_CURRENT_SOURCE_OFFSET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_STATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_OUTPUT_STATE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951AOutput* pIAgilent34951AOutput = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951AOutput);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34951AOutput->put_State(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					pIAgilent34951AOutput->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_OPERATION_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_OPERATION_MODE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951ASource* pIAgilent34951ASource = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951ASource);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34951ASource->put_OperationMode(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					pIAgilent34951ASource->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_FUNCTION_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_FUNCTION_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_NUM_CYCLES:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_NUM_CYCLES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_START_INDEX:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_START_INDEX\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_NAME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_TRACE_NAME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SOURCE_FREQUENCY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_SOURCE_FREQUENCY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_TRIGGER_SOURCE_34951A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_TRACE_TRIGGER_SOURCE_34951A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_CLOCK_SOURCE_34951A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_TRACE_CLOCK_SOURCE_34951A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_CLOCK_PERIOD_34951A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_TRACE_CLOCK_PERIOD_34951A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VOLTAGE_SOURCE_GAIN:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_VOLTAGE_SOURCE_GAIN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VOLTAGE_SOURCE_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_VOLTAGE_SOURCE_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VOLTAGE_SOURCE_OFFSET:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_VOLTAGE_SOURCE_OFFSET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DAC_VOLTAGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DAC_VOLTAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_MODE_34952A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_TOTALIZER_MODE_34952A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_READ_TYPE_34952A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_TOTALIZER_READ_TYPE_34952A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_SLOPE_34952A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_TOTALIZER_SLOPE_34952A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_STATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DRIVE_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_PAIRED_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_PAIRED_MODE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34945A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34945AChannel* pIAgilent34945AChannel = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34945AChannel);
				status = TranslateHRESULTAgilent34945A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34945AChannel->put_PairedMode(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34945A(Vi, hr);
					pIAgilent34945AChannel->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_PULSE_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_PULSE_MODE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34945A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34945AChannel* pIAgilent34945AChannel = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34945AChannel);
				status = TranslateHRESULTAgilent34945A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34945AChannel->put_PulseMode(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34945A(Vi, hr);
					pIAgilent34945AChannel->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_PULSE_WIDTH_34945A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_PULSE_WIDTH_34945A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RECOVERY_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_RECOVERY_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SETTLE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_SETTLE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VERIFICATION_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_VERIFICATION_ENABLE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34945A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34945AChannel* pIAgilent34945AChannel = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34945AChannel);
				status = TranslateHRESULTAgilent34945A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34945AChannel->put_VerificationEnable(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34945A(Vi, hr);
					pIAgilent34945AChannel->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_VERIFICATION_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_VERIFICATION_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATE_AT_RESET:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_STATE_AT_RESET\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34945A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34945AChannel* pIAgilent34945AChannel = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34945AChannel);
				status = TranslateHRESULTAgilent34945A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CVariantBool _val(AttributeValue);
					hr = pIAgilent34945AChannel->put_StateAtReset(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34945A(Vi, hr);
					pIAgilent34945AChannel->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DRIVE_CHANNEL_LIMIT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DRIVE_CHANNEL_LIMIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_SOURCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DRIVE_SOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_SOURCE_BOOT_STATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_DRIVE_SOURCE_BOOT_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_CLOSED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: AG34980A_ATTR_IS_CLOSED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						

		default:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViBoolean: Invalid Attribute=%d\n"), AttributeID);

			status = IviSession_SetError(Vi, IVIC_ERROR_INVALID_ATTRIBUTE, "Attribute not recognized.");
			status = IVIC_ERROR_INVALID_ATTRIBUTE;
			break;
		}
	}
	
	return status;
}


ViStatus _VI_FUNC  ag34980a_SetAttributeViSession ( ViSession Vi, ViConstString RepCapIdentifier, ViAttr AttributeID, ViSession AttributeValue )
{
	ViStatus status = VI_SUCCESS;

	switch (AttributeID)
	{
		case AG34980A_ATTR_SPECIFIC_DRIVER_DESCRIPTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_SPECIFIC_DRIVER_DESCRIPTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_PREFIX:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_SPECIFIC_DRIVER_PREFIX\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_VENDOR:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_SPECIFIC_DRIVER_VENDOR\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_REVISION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_SPECIFIC_DRIVER_REVISION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MAJOR_VERSION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MAJOR_VERSION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MINOR_VERSION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MINOR_VERSION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_LOGICAL_NAME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_LOGICAL_NAME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IO_RESOURCE_DESCRIPTOR:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_IO_RESOURCE_DESCRIPTOR\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CACHE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_CACHE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INTERCHANGE_CHECK:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_INTERCHANGE_CHECK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_QUERY_INSTRUMENT_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_QUERY_INSTRUMENT_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RANGE_CHECK:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_RANGE_CHECK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RECORD_COERCIONS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_RECORD_COERCIONS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SIMULATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_SIMULATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVER_SETUP:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DRIVER_SETUP\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INSTRUMENT_MANUFACTURER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_INSTRUMENT_MANUFACTURER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INSTRUMENT_MODEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_INSTRUMENT_MODEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INSTRUMENT_FIRMWARE_REVISION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_INSTRUMENT_FIRMWARE_REVISION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SUPPORTED_INSTRUMENT_MODELS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_SUPPORTED_INSTRUMENT_MODELS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GROUP_CAPABILITIES:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_GROUP_CAPABILITIES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_LOWER_LIMIT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_ALARM_LOWER_LIMIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_LOWER_LIMIT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_ALARM_LOWER_LIMIT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_ALARM_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_QUERYALARMQUEUE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_QUERYALARMQUEUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_SLOPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_ALARM_SLOPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_UPPER_LIMIT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_ALARM_UPPER_LIMIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_UPPER_LIMIT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_ALARM_UPPER_LIMIT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_VOLTAGE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_AC_VOLTAGE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_VOLTAGE_BANDWIDTH:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_AC_VOLTAGE_BANDWIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_AC_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_CURRENT_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_AC_CURRENT_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_CURRENT_BANDWIDTH:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_AC_CURRENT_BANDWIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_CURRENT_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_AC_CURRENT_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SECURITY_PASSWORD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_SECURITY_PASSWORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_MAINFRAME_MESSAGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_CAL_MAINFRAME_MESSAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_TOTAL_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_CAL_TOTAL_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_LINE_FREQUENCY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_CAL_LINE_FREQUENCY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SECURITY_STATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_SECURITY_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DC_CURRENT_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DC_CURRENT_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DC_CURRENT_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DC_CURRENT_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DC_CURRENT_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DC_CURRENT_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DC_VOLTAGE_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DC_VOLTAGE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DC_VOLTAGE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DC_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DC_VOLTAGE_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DC_VOLTAGE_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_AUTO_IMPEDANCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DC_VOLTAGE_AUTO_IMPEDANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GETRELAYCYCLES:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_GETRELAYCYCLES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DISPLAY_ENABLED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DISPLAY_ENABLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DISPLAY_TEXT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DISPLAY_TEXT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MONITOR_DATA:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_MONITOR_DATA\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MONITOR_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_MONITOR_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MONITOR_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_MONITOR_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ENABLE_MONITOR_CHAN:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_ENABLE_MONITOR_CHAN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SELECT_MONITOR_CHAN:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_SELECT_MONITOR_CHAN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_FREQUENCY_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE_AUTO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE_AUTO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_LOW_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_FREQUENCY_LOW_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_FRESISTANCE_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_FRESISTANCE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_FRESISTANCE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_FRESISTANCE_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_FRESISTANCE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_FRESISTANCE_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEASUREMENT_READING_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_MEASUREMENT_READING_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEASUREMENT_FUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_MEASUREMENT_FUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AUTO_RECALL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_AUTO_RECALL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_NUMBER_OF_STATES:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_NUMBER_OF_STATES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEMORY_CATALOG:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_MEMORY_CATALOG\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PERIOD_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_PERIOD_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PERIOD_VOLTAGE_RANGE_AUTO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_PERIOD_VOLTAGE_RANGE_AUTO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PERIOD_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_PERIOD_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_RESISTANCE_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_RESISTANCE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_RESISTANCE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_RESISTANCE_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_RESISTANCE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_RESISTANCE_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_RESISTANCE_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_GAIN:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_SCALE_GAIN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_OFFSET:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_SCALE_OFFSET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_STATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_SCALE_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_UNIT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_SCALE_UNIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_AUTO_DELAY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_CHANNEL_AUTO_DELAY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_DELAY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_CHANNEL_DELAY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_FWIRE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_CHANNEL_FWIRE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ROUTE_DONE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_ROUTE_DONE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_IS_CLOSED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_CHANNEL_IS_CLOSED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_SCAN_SIZE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_CHANNEL_SCAN_SIZE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_SCAN_LIST:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_CHANNEL_SCAN_LIST\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_SCAN_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_CHANNEL_SCAN_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCAN_SWEEP_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_SCAN_SWEEP_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ORDERED_SCAN:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_ORDERED_SCAN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_AVERAGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_STATISTICS_AVERAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_STATISTICS_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MAX_VALUE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_STATISTICS_MAX_VALUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MAX_VALUE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_STATISTICS_MAX_VALUE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MIN_VALUE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_STATISTICS_MIN_VALUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MIN_VALUE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_STATISTICS_MIN_VALUE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_PTPEAK:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_STATISTICS_PTPEAK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SERIAL_POLL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_SERIAL_POLL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ASYNC_EVENTS_ENABLED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_ASYNC_EVENTS_ENABLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SYSTEM_DATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_SYSTEM_DATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DMM_ENABLED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DMM_ENABLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DMM_INSTALLED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DMM_INSTALLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_READING_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_READING_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SERIAL_NUMBER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_SERIAL_NUMBER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SYSTEM_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_SYSTEM_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TIMEOUT_MILLISECONDS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_TIMEOUT_MILLISECONDS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_LOCK_OWNER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_LOCK_OWNER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MODULE_EVENTS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_MODULE_EVENTS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_READING_UNITS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_TEMPERATURE_READING_UNITS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_TEMPERATURE_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_TEMPERATURE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_TRANSDUCERTYPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_TEMPERATURE_TRANSDUCERTYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_RESISTANCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_FRTD_RESISTANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_ALPHA:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_FRTD_ALPHA\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_IS_EXTERNAL_REFERENCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_FRTD_IS_EXTERNAL_REFERENCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_FRTD_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_ALARM_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DATA_FORMAT_ALARM_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_CHANNEL_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DATA_FORMAT_CHANNEL_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_TIME_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DATA_FORMAT_TIME_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_TIME_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DATA_FORMAT_TIME_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_UNIT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DATA_FORMAT_UNIT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_RESISTANCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_RTD_RESISTANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_ALPHA:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_RTD_ALPHA\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_IS_EXTERNAL_REFERENCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_RTD_IS_EXTERNAL_REFERENCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_RTD_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMISTOR_RESISTANCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_THERMISTOR_RESISTANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMISTOR_IS_EXTERNAL_REFERENCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_THERMISTOR_IS_EXTERNAL_REFERENCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_THERMOCOUPLE_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_JUNCTION_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_THERMOCOUPLE_JUNCTION_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_FIXED_REFERENCE_JUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_THERMOCOUPLE_FIXED_REFERENCE_JUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_CHECK:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_THERMOCOUPLE_CHECK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_AUTO_IMPEDANCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_THERMOCOUPLE_AUTO_IMPEDANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_EXTERNAL_REFERENCE_JUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_THERMOCOUPLE_EXTERNAL_REFERENCE_JUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_INTERNAL_REFERENCE_JUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_THERMOCOUPLE_INTERNAL_REFERENCE_JUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_SAMPLE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_TRIGGER_SAMPLE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_TRIGGER_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_SOURCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_TRIGGER_SOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_TIMER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_TRIGGER_TIMER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DELAY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DELAY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DELAY_AUTO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DELAY_AUTO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_CHANNEL_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_DEBOUNCED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_IS_DEBOUNCED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_DMM_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_CAL_DMM_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_DMM_MESSAGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_CAL_DMM_MESSAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_VALUE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_CAL_VALUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_LABEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_CHANNEL_LABEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SEQUENCE_CATALOG:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_SEQUENCE_CATALOG\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GETSEQUENCETRIGGERSOURCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_GETSEQUENCETRIGGERSOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_CONFIGURATION_CHANNEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_IS_CONFIGURATION_CHANNEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_SOURCE_CHANNEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_IS_SOURCE_CHANNEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_AC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_MAX_CARRY_AC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_AC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_MAX_SWITCHING_AC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_AC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_MAX_CARRY_AC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_AC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_MAX_SWITCHING_AC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_AC_VOLTAGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_MAX_AC_VOLTAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_BANDWIDTH:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_BANDWIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_DC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_MAX_CARRY_DC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_DC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_MAX_SWITCHING_DC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_DC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_MAX_CARRY_DC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_DC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_MAX_SWITCHING_DC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_DC_VOLTAGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_MAX_DC_VOLTAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHARACTERISTIC_IMPEDANCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_CHARACTERISTIC_IMPEDANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SETTLING_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_SETTLING_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_WIRE_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_WIRE_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ASYNC_TIMEOUT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_ASYNC_TIMEOUT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_CYCLE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_HANDSHAKE_CYCLE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_HANDSHAKE_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_HANDSHAKE_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_RATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_HANDSHAKE_RATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_STATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_HANDSHAKE_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_SYNC_STROBE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_HANDSHAKE_SYNC_STROBE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_HANDSHAKE_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_DRIVE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_HANDSHAKE_DRIVE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_INPUT_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARE_ACTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_COMPARE_ACTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DATA_FORMAT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_POINTS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DATA_POINTS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ENABLE_INPUT_MEMORY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_ENABLE_INPUT_MEMORY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_INPUT_INTERRUPT_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_INPUT_INTERRUPT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_INPUT_INTERRUPT_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_INPUT_INTERRUPT_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_SAMPLE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_INPUT_SAMPLE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_INPUT_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_DRIVE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_OUTPUT_DRIVE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_VOLT_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_OUTPUT_VOLT_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_CYCLE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_OUTPUT_CYCLE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_OUTPUT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_INTERRUPT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_OUTPUT_INTERRUPT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_INTERRUPT_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_OUTPUT_INTERRUPT_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_INTERRUPT_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_OUTPUT_INTERRUPT_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_TRACE_SELECT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_OUTPUT_TRACE_SELECT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEMORY_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_MEMORY_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_CATALOG_34950A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_TRACE_CATALOG_34950A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_MEMORY_FREE_34950A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_TRACE_MEMORY_FREE_34950A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_FUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GATE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_GATE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GATE_SOURCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_GATE_SOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GATE_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_GATE_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_SLOPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_COUNTER_SLOPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_COUNTER_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_READ_TYPE_34950A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_TOTALIZER_READ_TYPE_34950A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_FREQUENCY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_COUNTER_FREQUENCY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_PERIOD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_COUNTER_PERIOD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_WIDTH:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_PULSE_WIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_DUTY_CYCLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_PULSE_DUTY_CYCLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_TOTALIZE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_COUNTER_TOTALIZE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_COMPARISON_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_COMPARISON_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DIGITAL_DIRECTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DIGITAL_DIRECTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_DATA_BYTE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_COMPARISON_DATA_BYTE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_DATA_WORD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_COMPARISON_DATA_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_DATA_LONG_WORD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_COMPARISON_DATA_LONG_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_ALARM_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_COMPARISON_ALARM_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_MASK_BYTE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_COMPARISON_MASK_BYTE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_MASK_WORD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_COMPARISON_MASK_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_MASK_LONG_WORD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_COMPARISON_MASK_LONG_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DIGITAL_WIDTH:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DIGITAL_WIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DIGITAL_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DIGITAL_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CURRENT_SOURCE_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_CURRENT_SOURCE_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CURRENT_SOURCE_GAIN:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_CURRENT_SOURCE_GAIN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CURRENT_SOURCE_OFFSET:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_CURRENT_SOURCE_OFFSET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_STATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_OUTPUT_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OPERATION_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_OPERATION_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FUNCTION_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_FUNCTION_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_NUM_CYCLES:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_NUM_CYCLES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_START_INDEX:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_START_INDEX\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_NAME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_TRACE_NAME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SOURCE_FREQUENCY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_SOURCE_FREQUENCY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_TRIGGER_SOURCE_34951A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_TRACE_TRIGGER_SOURCE_34951A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_CLOCK_SOURCE_34951A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_TRACE_CLOCK_SOURCE_34951A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_CLOCK_PERIOD_34951A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_TRACE_CLOCK_PERIOD_34951A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VOLTAGE_SOURCE_GAIN:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_VOLTAGE_SOURCE_GAIN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VOLTAGE_SOURCE_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_VOLTAGE_SOURCE_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VOLTAGE_SOURCE_OFFSET:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_VOLTAGE_SOURCE_OFFSET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DAC_VOLTAGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DAC_VOLTAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_MODE_34952A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_TOTALIZER_MODE_34952A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_READ_TYPE_34952A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_TOTALIZER_READ_TYPE_34952A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_SLOPE_34952A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_TOTALIZER_SLOPE_34952A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_STATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DRIVE_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PAIRED_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_PAIRED_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_PULSE_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_WIDTH_34945A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_PULSE_WIDTH_34945A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RECOVERY_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_RECOVERY_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SETTLE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_SETTLE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VERIFICATION_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_VERIFICATION_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VERIFICATION_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_VERIFICATION_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATE_AT_RESET:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_STATE_AT_RESET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_CHANNEL_LIMIT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DRIVE_CHANNEL_LIMIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_SOURCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DRIVE_SOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_SOURCE_BOOT_STATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_DRIVE_SOURCE_BOOT_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_CLOSED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: AG34980A_ATTR_IS_CLOSED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						

		default:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViSession: Invalid Attribute=%d\n"), AttributeID);

			status = IviSession_SetError(Vi, IVIC_ERROR_INVALID_ATTRIBUTE, "Attribute not recognized.");
			status = IVIC_ERROR_INVALID_ATTRIBUTE;
			break;
		}
	}
	
	return status;
}


ViStatus _VI_FUNC  ag34980a_SetAttributeViString ( ViSession Vi, ViConstString RepCapIdentifier, ViAttr AttributeID, ViConstString AttributeValue )
{
	ViStatus status = VI_SUCCESS;

	switch (AttributeID)
	{
		case AG34980A_ATTR_SPECIFIC_DRIVER_DESCRIPTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_SPECIFIC_DRIVER_DESCRIPTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_PREFIX:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_SPECIFIC_DRIVER_PREFIX\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_VENDOR:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_SPECIFIC_DRIVER_VENDOR\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_REVISION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_SPECIFIC_DRIVER_REVISION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MAJOR_VERSION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MAJOR_VERSION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MINOR_VERSION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_SPECIFIC_DRIVER_CLASS_SPEC_MINOR_VERSION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_LOGICAL_NAME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_LOGICAL_NAME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_IO_RESOURCE_DESCRIPTOR:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_IO_RESOURCE_DESCRIPTOR\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_CACHE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_CACHE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INTERCHANGE_CHECK:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_INTERCHANGE_CHECK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_QUERY_INSTRUMENT_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_QUERY_INSTRUMENT_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RANGE_CHECK:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_RANGE_CHECK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RECORD_COERCIONS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_RECORD_COERCIONS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SIMULATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_SIMULATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVER_SETUP:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DRIVER_SETUP\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_INSTRUMENT_MANUFACTURER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_INSTRUMENT_MANUFACTURER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_INSTRUMENT_MODEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_INSTRUMENT_MODEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_INSTRUMENT_FIRMWARE_REVISION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_INSTRUMENT_FIRMWARE_REVISION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_SUPPORTED_INSTRUMENT_MODELS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_SUPPORTED_INSTRUMENT_MODELS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_GROUP_CAPABILITIES:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_GROUP_CAPABILITIES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_ALARM_LOWER_LIMIT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_ALARM_LOWER_LIMIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_LOWER_LIMIT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_ALARM_LOWER_LIMIT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_ALARM_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_QUERYALARMQUEUE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_QUERYALARMQUEUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_ALARM_SLOPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_ALARM_SLOPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_UPPER_LIMIT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_ALARM_UPPER_LIMIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ALARM_UPPER_LIMIT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_ALARM_UPPER_LIMIT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_VOLTAGE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_AC_VOLTAGE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_VOLTAGE_BANDWIDTH:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_AC_VOLTAGE_BANDWIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_AC_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_CURRENT_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_AC_CURRENT_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_CURRENT_BANDWIDTH:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_AC_CURRENT_BANDWIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_AC_CURRENT_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_AC_CURRENT_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SECURITY_PASSWORD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_SECURITY_PASSWORD\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ACalibration* pIAgilent34980ACalibration = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ACalibration);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val(AttributeValue);
					hr = pIAgilent34980ACalibration->put_Code(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ACalibration->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_CAL_MAINFRAME_MESSAGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_CAL_MAINFRAME_MESSAGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ACalibration* pIAgilent34980ACalibration = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ACalibration);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val(AttributeValue);
					hr = pIAgilent34980ACalibration->put_String(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ACalibration->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_CAL_TOTAL_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_CAL_TOTAL_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_LINE_FREQUENCY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_CAL_LINE_FREQUENCY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SECURITY_STATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_SECURITY_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DC_CURRENT_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DC_CURRENT_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DC_CURRENT_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DC_CURRENT_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DC_CURRENT_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_CURRENT_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DC_CURRENT_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DC_VOLTAGE_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DC_VOLTAGE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DC_VOLTAGE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DC_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DC_VOLTAGE_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DC_VOLTAGE_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DC_VOLTAGE_AUTO_IMPEDANCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DC_VOLTAGE_AUTO_IMPEDANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GETRELAYCYCLES:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_GETRELAYCYCLES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DISPLAY_ENABLED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DISPLAY_ENABLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DISPLAY_TEXT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DISPLAY_TEXT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADisplay* pIAgilent34980ADisplay = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADisplay);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val(AttributeValue);
					hr = pIAgilent34980ADisplay->put_DisplayText(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ADisplay->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_MONITOR_DATA:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_MONITOR_DATA\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MONITOR_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_MONITOR_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MONITOR_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_MONITOR_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ENABLE_MONITOR_CHAN:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_ENABLE_MONITOR_CHAN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SELECT_MONITOR_CHAN:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_SELECT_MONITOR_CHAN\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADisplay* pIAgilent34980ADisplay = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADisplay);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val(AttributeValue);
					hr = pIAgilent34980ADisplay->put_SelectMonitorChan(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ADisplay->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_FREQUENCY_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE_AUTO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE_AUTO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_LOW_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_FREQUENCY_LOW_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_FREQUENCY_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_FRESISTANCE_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_FRESISTANCE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_FRESISTANCE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_FRESISTANCE_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_FRESISTANCE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRESISTANCE_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_FRESISTANCE_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEASUREMENT_READING_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_MEASUREMENT_READING_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEASUREMENT_FUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_MEASUREMENT_FUNCTION\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AMeasurement* pIAgilent34980AMeasurement = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AMeasurement);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CBSTR _val(AttributeValue);
					hr = pIAgilent34980AMeasurement->put_MeasurementFunction(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AMeasurement->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_AUTO_RECALL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_AUTO_RECALL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_NUMBER_OF_STATES:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_NUMBER_OF_STATES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MEMORY_CATALOG:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_MEMORY_CATALOG\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_PERIOD_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_PERIOD_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PERIOD_VOLTAGE_RANGE_AUTO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_PERIOD_VOLTAGE_RANGE_AUTO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PERIOD_VOLTAGE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_PERIOD_VOLTAGE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_APERTURE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_RESISTANCE_APERTURE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_AUTORANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_RESISTANCE_AUTORANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_RESISTANCE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_RESISTANCE_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_RANGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_RESISTANCE_RANGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_RESOLUTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_RESISTANCE_RESOLUTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RESISTANCE_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_RESISTANCE_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_GAIN:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_SCALE_GAIN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_OFFSET:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_SCALE_OFFSET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_STATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_SCALE_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SCALE_UNIT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_SCALE_UNIT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AScale* pIAgilent34980AScale = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AScale);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CBSTR _val(AttributeValue);
					hr = pIAgilent34980AScale->put_Unit(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AScale->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_CHANNEL_AUTO_DELAY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_CHANNEL_AUTO_DELAY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_DELAY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_CHANNEL_DELAY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_FWIRE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_CHANNEL_FWIRE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ROUTE_DONE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_ROUTE_DONE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_IS_CLOSED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_CHANNEL_IS_CLOSED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_SCAN_SIZE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_CHANNEL_SCAN_SIZE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_SCAN_LIST:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_CHANNEL_SCAN_LIST\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980AScan* pIAgilent34980AScan = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980AScan);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val(AttributeValue);
					hr = pIAgilent34980AScan->put_ScanList(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980AScan->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_CHANNEL_SCAN_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_CHANNEL_SCAN_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_SCAN_SWEEP_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_SCAN_SWEEP_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ORDERED_SCAN:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_ORDERED_SCAN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_AVERAGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_STATISTICS_AVERAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_STATISTICS_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MAX_VALUE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_STATISTICS_MAX_VALUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MAX_VALUE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_STATISTICS_MAX_VALUE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MIN_VALUE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_STATISTICS_MIN_VALUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_MIN_VALUE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_STATISTICS_MIN_VALUE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_STATISTICS_PTPEAK:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_STATISTICS_PTPEAK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SERIAL_POLL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_SERIAL_POLL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ASYNC_EVENTS_ENABLED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_ASYNC_EVENTS_ENABLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SYSTEM_DATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_SYSTEM_DATE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ASystem* pIAgilent34980ASystem = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ASystem);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val(AttributeValue);
					hr = pIAgilent34980ASystem->put_Date(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ASystem->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_DMM_ENABLED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DMM_ENABLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DMM_INSTALLED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DMM_INSTALLED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_READING_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_READING_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SERIAL_NUMBER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_SERIAL_NUMBER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_SYSTEM_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_SYSTEM_TIME\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ASystem* pIAgilent34980ASystem = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ASystem);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val(AttributeValue);
					hr = pIAgilent34980ASystem->put_Time(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ASystem->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_TIMEOUT_MILLISECONDS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_TIMEOUT_MILLISECONDS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_LOCK_OWNER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_LOCK_OWNER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_MODULE_EVENTS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_MODULE_EVENTS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_READING_UNITS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_TEMPERATURE_READING_UNITS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_AUTOZERO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_TEMPERATURE_AUTOZERO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_NPLC:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_TEMPERATURE_NPLC\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TEMPERATURE_TRANSDUCERTYPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_TEMPERATURE_TRANSDUCERTYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_RESISTANCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_FRTD_RESISTANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_ALPHA:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_FRTD_ALPHA\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_IS_EXTERNAL_REFERENCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_FRTD_IS_EXTERNAL_REFERENCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FRTD_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_FRTD_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_ALARM_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DATA_FORMAT_ALARM_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_CHANNEL_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DATA_FORMAT_CHANNEL_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_TIME_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DATA_FORMAT_TIME_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_TIME_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DATA_FORMAT_TIME_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT_UNIT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DATA_FORMAT_UNIT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_RESISTANCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_RTD_RESISTANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_ALPHA:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_RTD_ALPHA\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_IS_EXTERNAL_REFERENCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_RTD_IS_EXTERNAL_REFERENCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RTD_OCOMPENSATED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_RTD_OCOMPENSATED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMISTOR_RESISTANCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_THERMISTOR_RESISTANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMISTOR_IS_EXTERNAL_REFERENCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_THERMISTOR_IS_EXTERNAL_REFERENCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_THERMOCOUPLE_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_JUNCTION_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_THERMOCOUPLE_JUNCTION_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_FIXED_REFERENCE_JUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_THERMOCOUPLE_FIXED_REFERENCE_JUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_CHECK:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_THERMOCOUPLE_CHECK\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_AUTO_IMPEDANCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_THERMOCOUPLE_AUTO_IMPEDANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_EXTERNAL_REFERENCE_JUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_THERMOCOUPLE_EXTERNAL_REFERENCE_JUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_THERMOCOUPLE_INTERNAL_REFERENCE_JUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_THERMOCOUPLE_INTERNAL_REFERENCE_JUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_SAMPLE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_TRIGGER_SAMPLE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_TRIGGER_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_SOURCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_TRIGGER_SOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRIGGER_TIMER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_TRIGGER_TIMER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DELAY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DELAY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DELAY_AUTO:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DELAY_AUTO\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_CHANNEL_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_DEBOUNCED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_IS_DEBOUNCED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_DMM_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_CAL_DMM_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CAL_DMM_MESSAGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_CAL_DMM_MESSAGE\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ADMM* pIAgilent34980ADMM = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ADMM);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _val(AttributeValue);
					hr = pIAgilent34980ADMM->put_String(_val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ADMM->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_CAL_VALUE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_CAL_VALUE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHANNEL_LABEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_CHANNEL_LABEL\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetDriver(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34980ARoute2* pIAgilent34980ARoute2 = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34980ARoute2);
				status = TranslateHRESULT(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CBSTR _val(AttributeValue);
					hr = pIAgilent34980ARoute2->put_ChannelLabel(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULT(Vi, hr);
					pIAgilent34980ARoute2->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_SEQUENCE_CATALOG:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_SEQUENCE_CATALOG\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_GETSEQUENCETRIGGERSOURCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_GETSEQUENCETRIGGERSOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_CONFIGURATION_CHANNEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_IS_CONFIGURATION_CHANNEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_SOURCE_CHANNEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_IS_SOURCE_CHANNEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_AC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_MAX_CARRY_AC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_AC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_MAX_SWITCHING_AC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_AC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_MAX_CARRY_AC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_AC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_MAX_SWITCHING_AC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_AC_VOLTAGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_MAX_AC_VOLTAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_BANDWIDTH:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_BANDWIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_DC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_MAX_CARRY_DC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_DC_CURRENT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_MAX_SWITCHING_DC_CURRENT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_CARRY_DC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_MAX_CARRY_DC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_SWITCHING_DC_POWER:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_MAX_SWITCHING_DC_POWER\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_MAX_DC_VOLTAGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_MAX_DC_VOLTAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CHARACTERISTIC_IMPEDANCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_CHARACTERISTIC_IMPEDANCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SETTLING_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_SETTLING_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_WIRE_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_WIRE_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ASYNC_TIMEOUT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_ASYNC_TIMEOUT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_CYCLE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_HANDSHAKE_CYCLE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_HANDSHAKE_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_HANDSHAKE_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_RATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_HANDSHAKE_RATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_STATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_HANDSHAKE_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_SYNC_STROBE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_HANDSHAKE_SYNC_STROBE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_HANDSHAKE_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_HANDSHAKE_DRIVE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_HANDSHAKE_DRIVE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_INPUT_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARE_ACTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_COMPARE_ACTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_FORMAT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DATA_FORMAT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DATA_POINTS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DATA_POINTS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_ENABLE_INPUT_MEMORY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_ENABLE_INPUT_MEMORY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_INPUT_INTERRUPT_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_INPUT_INTERRUPT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_INPUT_INTERRUPT_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_INTERRUPT_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_INPUT_INTERRUPT_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_SAMPLE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_INPUT_SAMPLE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_INPUT_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_INPUT_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_DRIVE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_OUTPUT_DRIVE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_VOLT_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_OUTPUT_VOLT_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_CYCLE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_OUTPUT_CYCLE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_OUTPUT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_INTERRUPT_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_OUTPUT_INTERRUPT_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_INTERRUPT_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_OUTPUT_INTERRUPT_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_INTERRUPT_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_OUTPUT_INTERRUPT_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_TRACE_SELECT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_OUTPUT_TRACE_SELECT\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34950A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34950AOutputMemory* pIAgilent34950AOutputMemory = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34950AOutputMemory);
				status = TranslateHRESULTAgilent34950A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CBSTR _val(AttributeValue);
					hr = pIAgilent34950AOutputMemory->put_TraceSelect(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34950A(Vi, hr);
					pIAgilent34950AOutputMemory->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_MEMORY_STATUS:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_MEMORY_STATUS\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_CATALOG_34950A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_TRACE_CATALOG_34950A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_IVI_ATTR_NOT_WRITABLE, "Attribute is read only.");
			status = IVIC_ERROR_IVI_ATTR_NOT_WRITABLE;
			break;
		}						
		case AG34980A_ATTR_TRACE_MEMORY_FREE_34950A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_TRACE_MEMORY_FREE_34950A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FUNCTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_FUNCTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GATE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_GATE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GATE_SOURCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_GATE_SOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_GATE_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_GATE_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_SLOPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_COUNTER_SLOPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_THRESHOLD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_COUNTER_THRESHOLD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_READ_TYPE_34950A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_TOTALIZER_READ_TYPE_34950A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_FREQUENCY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_COUNTER_FREQUENCY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_PERIOD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_COUNTER_PERIOD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_WIDTH:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_PULSE_WIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_DUTY_CYCLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_PULSE_DUTY_CYCLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COUNTER_TOTALIZE_COUNT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_COUNTER_TOTALIZE_COUNT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_COMPARISON_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_COMPARISON_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DIGITAL_DIRECTION:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DIGITAL_DIRECTION\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_DATA_BYTE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_COMPARISON_DATA_BYTE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_DATA_WORD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_COMPARISON_DATA_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_DATA_LONG_WORD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_COMPARISON_DATA_LONG_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_ALARM_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_COMPARISON_ALARM_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_MASK_BYTE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_COMPARISON_MASK_BYTE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_MASK_WORD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_COMPARISON_MASK_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_COMPARISON_MASK_LONG_WORD:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_COMPARISON_MASK_LONG_WORD\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DIGITAL_WIDTH:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DIGITAL_WIDTH\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DIGITAL_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DIGITAL_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CURRENT_SOURCE_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_CURRENT_SOURCE_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CURRENT_SOURCE_GAIN:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_CURRENT_SOURCE_GAIN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_CURRENT_SOURCE_OFFSET:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_CURRENT_SOURCE_OFFSET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OUTPUT_STATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_OUTPUT_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_OPERATION_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_OPERATION_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_FUNCTION_TYPE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_FUNCTION_TYPE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_NUM_CYCLES:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_NUM_CYCLES\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_START_INDEX:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_START_INDEX\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_NAME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_TRACE_NAME\n"));

			HRESULT hr;

			IUnknown* pDriver = NULL;
			status = GetPersonalityAgilent34951A(Vi, &pDriver);
			if (status == VI_SUCCESS)
			{
				IAgilent34951ASource* pIAgilent34951ASource = NULL;
				hr = pDriver->QueryInterface(&pIAgilent34951ASource);
				status = TranslateHRESULTAgilent34951A(Vi, hr);
				ATLASSERT(SUCCEEDED(hr));
				if (SUCCEEDED(hr))
				{
					CBSTR _identifier(RepCapIdentifier);
					CBSTR _val(AttributeValue);
					hr = pIAgilent34951ASource->put_TraceName(_identifier.GetVal(), _val.GetVal());
					status = TranslateHRESULTAgilent34951A(Vi, hr);
					pIAgilent34951ASource->Release();
				}
	
				pDriver->Release();
			}
			break;
		}						
		case AG34980A_ATTR_SOURCE_FREQUENCY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_SOURCE_FREQUENCY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_TRIGGER_SOURCE_34951A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_TRACE_TRIGGER_SOURCE_34951A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_CLOCK_SOURCE_34951A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_TRACE_CLOCK_SOURCE_34951A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TRACE_CLOCK_PERIOD_34951A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_TRACE_CLOCK_PERIOD_34951A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VOLTAGE_SOURCE_GAIN:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_VOLTAGE_SOURCE_GAIN\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VOLTAGE_SOURCE_LEVEL:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_VOLTAGE_SOURCE_LEVEL\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VOLTAGE_SOURCE_OFFSET:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_VOLTAGE_SOURCE_OFFSET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DAC_VOLTAGE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DAC_VOLTAGE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_MODE_34952A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_TOTALIZER_MODE_34952A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_READ_TYPE_34952A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_TOTALIZER_READ_TYPE_34952A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_TOTALIZER_SLOPE_34952A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_TOTALIZER_SLOPE_34952A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_STATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DRIVE_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PAIRED_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_PAIRED_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_MODE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_PULSE_MODE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_PULSE_WIDTH_34945A:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_PULSE_WIDTH_34945A\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_RECOVERY_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_RECOVERY_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_SETTLE_TIME:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_SETTLE_TIME\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VERIFICATION_ENABLE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_VERIFICATION_ENABLE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_VERIFICATION_POLARITY:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_VERIFICATION_POLARITY\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_STATE_AT_RESET:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_STATE_AT_RESET\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_CHANNEL_LIMIT:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DRIVE_CHANNEL_LIMIT\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_SOURCE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DRIVE_SOURCE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_DRIVE_SOURCE_BOOT_STATE:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_DRIVE_SOURCE_BOOT_STATE\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						
		case AG34980A_ATTR_IS_CLOSED:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: AG34980A_ATTR_IS_CLOSED\n"));

			status = IviSession_SetError(Vi, IVIC_ERROR_TYPES_DO_NOT_MATCH, "Incorrect SetAttribute for attribute of this type.");
			status = IVIC_ERROR_TYPES_DO_NOT_MATCH;
			break;
		}						

		default:
		{
			IVIC_TRACE(_T("ag34980a_SetAttributeViString: Invalid Attribute=%d\n"), AttributeID);

			status = IviSession_SetError(Vi, IVIC_ERROR_INVALID_ATTRIBUTE, "Attribute not recognized.");
			status = IVIC_ERROR_INVALID_ATTRIBUTE;
			break;
		}
	}
	
	return status;
}


    /*- Route */

ViStatus _VI_FUNC  ag34980a_CloseChannelsExclusive ( ViSession Vi, ViConstString ChannelList )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_CloseChannelsExclusive\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ARoute* pIAgilent34980ARoute = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ARoute);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			hr = pIAgilent34980ARoute->CloseExclusive(_ChannelList.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ARoute->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_CloseChannels ( ViSession Vi, ViConstString ChannelList )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_CloseChannels\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ARoute* pIAgilent34980ARoute = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ARoute);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			hr = pIAgilent34980ARoute->Close(_ChannelList.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ARoute->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_OpenChannels ( ViSession Vi, ViConstString ChannelList )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_OpenChannels\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ARoute* pIAgilent34980ARoute = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ARoute);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			hr = pIAgilent34980ARoute->Open(_ChannelList.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ARoute->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_WaitForDebounce ( ViSession Vi, ViInt32 MaxTimeMilliseconds )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_WaitForDebounce\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IIviSwtchPath* pIIviSwtchPath = NULL;
		hr = pDriver->QueryInterface(&pIIviSwtchPath);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _MaxTimeMilliseconds(MaxTimeMilliseconds);
			hr = pIIviSwtchPath->WaitForDebounce(_MaxTimeMilliseconds.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIIviSwtchPath->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_DisconnectAll ( ViSession Vi )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_DisconnectAll\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IIviSwtchPath* pIIviSwtchPath = NULL;
		hr = pDriver->QueryInterface(&pIIviSwtchPath);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			hr = pIIviSwtchPath->DisconnectAll();
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIIviSwtchPath->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_Disconnect ( ViSession Vi, ViConstString Channel1, ViConstString Channel2 )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_Disconnect\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IIviSwtchPath* pIIviSwtchPath = NULL;
		hr = pDriver->QueryInterface(&pIIviSwtchPath);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _Channel1(Channel1);
			CBSTR _Channel2(Channel2);
			hr = pIIviSwtchPath->Disconnect(_Channel1.GetVal(), _Channel2.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIIviSwtchPath->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_Connect ( ViSession Vi, ViConstString Channel1, ViConstString Channel2 )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_Connect\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IIviSwtchPath* pIIviSwtchPath = NULL;
		hr = pDriver->QueryInterface(&pIIviSwtchPath);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _Channel1(Channel1);
			CBSTR _Channel2(Channel2);
			hr = pIIviSwtchPath->Connect(_Channel1.GetVal(), _Channel2.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIIviSwtchPath->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_CanConnect ( ViSession Vi, ViConstString Channel1, ViConstString Channel2, ViInt32* PathCapability )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_CanConnect\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IIviSwtchPath* pIIviSwtchPath = NULL;
		hr = pDriver->QueryInterface(&pIIviSwtchPath);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _Channel1(Channel1);
			CBSTR _Channel2(Channel2);
			CLong _returnVal;
			hr = pIIviSwtchPath->CanConnect(_Channel1.GetVal(), _Channel2.GetVal(), (IviSwtchPathCapabilityEnum*)_returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(PathCapability);
			}
			pIIviSwtchPath->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_Close ( ViSession Vi, ViConstString ChannelList )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_Close\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34959A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34959ARoute* pIAgilent34959ARoute = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34959ARoute);
		status = TranslateHRESULTAgilent34959A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			hr = pIAgilent34959ARoute->Close(_ChannelList.GetVal());
			status = TranslateHRESULTAgilent34959A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34959ARoute->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_Open ( ViSession Vi, ViConstString ChannelList )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_Open\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34959A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34959ARoute* pIAgilent34959ARoute = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34959ARoute);
		status = TranslateHRESULTAgilent34959A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			hr = pIAgilent34959ARoute->Open(_ChannelList.GetVal());
			status = TranslateHRESULTAgilent34959A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34959ARoute->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_OpenAll ( ViSession Vi, ViInt32 Slot )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_OpenAll\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34959A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34959ARoute* pIAgilent34959ARoute = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34959ARoute);
		status = TranslateHRESULTAgilent34959A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _Slot(Slot);
			hr = pIAgilent34959ARoute->OpenAll(_Slot.GetVal());
			status = TranslateHRESULTAgilent34959A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34959ARoute->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Paths */

ViStatus _VI_FUNC  ag34980a_SetPath ( ViSession Vi, ViConstString PathList )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_SetPath\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IIviSwtchPath* pIIviSwtchPath = NULL;
		hr = pDriver->QueryInterface(&pIIviSwtchPath);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _PathList(PathList);
			hr = pIIviSwtchPath->SetPath(_PathList.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIIviSwtchPath->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetPath ( ViSession Vi, ViConstString Channel1, ViConstString Channel2, ViInt32 PathListBufferSize, ViChar PathList[] )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetPath\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IIviSwtchPath* pIIviSwtchPath = NULL;
		hr = pDriver->QueryInterface(&pIIviSwtchPath);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _Channel1(Channel1);
			CBSTR _Channel2(Channel2);
			CBSTR _returnVal;
			hr = pIIviSwtchPath->GetPath(_Channel1.GetVal(), _Channel2.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(PathList, PathListBufferSize);
			}
			pIIviSwtchPath->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Action */

ViStatus _VI_FUNC  ag34980a_ClearAlarm ( ViSession Vi, ViBoolean ClearAll, ViInt32 Index )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ClearAlarm\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AAlarm* pIAgilent34980AAlarm = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AAlarm);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CVariantBool _ClearAll(ClearAll);
			CLong _Index(Index);
			hr = pIAgilent34980AAlarm->Clear(_ClearAll.GetVal(), _Index.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980AAlarm->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_RelayCyclesClear ( ViSession Vi, ViConstString ChannelList )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_RelayCyclesClear\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ADiagnostic* pIAgilent34980ADiagnostic = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ADiagnostic);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			hr = pIAgilent34980ADiagnostic->RelayCyclesClear(_ChannelList.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ADiagnostic->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_DMMCyclesClear ( ViSession Vi, ViInt32 Index )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_DMMCyclesClear\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ADiagnostic* pIAgilent34980ADiagnostic = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ADiagnostic);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _Index(Index);
			hr = pIAgilent34980ADiagnostic->DMMCyclesClear(_Index.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ADiagnostic->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_ClearDisplay ( ViSession Vi )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ClearDisplay\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ADisplay* pIAgilent34980ADisplay = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ADisplay);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			hr = pIAgilent34980ADisplay->ClearDisplay();
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ADisplay->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_SequenceTriggerImmediate ( ViSession Vi, ViConstString SequenceName )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_SequenceTriggerImmediate\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ARoute2* pIAgilent34980ARoute2 = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ARoute2);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _SequenceName(SequenceName);
			hr = pIAgilent34980ARoute2->SequenceTriggerImmediate(_SequenceName.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ARoute2->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Monitor */

ViStatus _VI_FUNC  ag34980a_MonitorDMM ( ViSession Vi )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_MonitorDMM\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ADisplay* pIAgilent34980ADisplay = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ADisplay);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			hr = pIAgilent34980ADisplay->MonitorDMM();
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ADisplay->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_MonitorChannel ( ViSession Vi, ViConstString Channel )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_MonitorChannel\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ADisplay* pIAgilent34980ADisplay = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ADisplay);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _Channel(Channel);
			hr = pIAgilent34980ADisplay->MonitorChannel(_Channel.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ADisplay->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Memory */

ViStatus _VI_FUNC  ag34980a_SaveState ( ViSession Vi, ViConstString Identifier )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_SaveState\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AMemory* pIAgilent34980AMemory = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AMemory);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _Identifier(Identifier);
			hr = pIAgilent34980AMemory->SaveState(_Identifier.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980AMemory->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_RecallState ( ViSession Vi, ViConstString Identifier )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_RecallState\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AMemory* pIAgilent34980AMemory = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AMemory);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _Identifier(Identifier);
			hr = pIAgilent34980AMemory->RecallState(_Identifier.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980AMemory->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_DeleteLocation ( ViSession Vi, ViInt32 LocationNum, ViBoolean DeleteAll )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_DeleteLocation\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AMemory* pIAgilent34980AMemory = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AMemory);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _LocationNum(LocationNum);
			CVariantBool _DeleteAll(DeleteAll);
			hr = pIAgilent34980AMemory->DeleteLocation(_LocationNum.GetVal(), _DeleteAll.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980AMemory->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Low-Level Operations */

ViStatus _VI_FUNC  ag34980a_StatusPreset ( ViSession Vi )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_StatusPreset\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AStatus* pIAgilent34980AStatus = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AStatus);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			hr = pIAgilent34980AStatus->Preset();
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980AStatus->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_ConfigureServiceRequest ( ViSession Vi, ViInt32 Reason )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigureServiceRequest\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AStatus* pIAgilent34980AStatus = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AStatus);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _Reason(Reason);
			hr = pIAgilent34980AStatus->ConfigureServiceRequest((Agilent34980ASRQReasonEnum)_Reason.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980AStatus->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_ClearStatus ( ViSession Vi )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ClearStatus\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AStatus* pIAgilent34980AStatus = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AStatus);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			hr = pIAgilent34980AStatus->Clear();
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980AStatus->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetRegister ( ViSession Vi, ViInt32 Register, ViInt32 SubRegister, ViInt32* retVal )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetRegister\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AStatus* pIAgilent34980AStatus = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AStatus);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _Register(Register);
			CLong _SubRegister(SubRegister);
			CLong _returnVal;
			hr = pIAgilent34980AStatus->get_Register((Agilent34980AStatusRegisterEnum)_Register.GetVal(), (Agilent34980AStatusSubRegisterEnum)_SubRegister.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal);
			}
			pIAgilent34980AStatus->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_SetRegister ( ViSession Vi, ViInt32 Register, ViInt32 SubRegister, ViInt32 val )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_SetRegister\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AStatus* pIAgilent34980AStatus = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AStatus);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _Register(Register);
			CLong _SubRegister(SubRegister);
			CLong _val(val);
			hr = pIAgilent34980AStatus->put_Register((Agilent34980AStatusRegisterEnum)_Register.GetVal(), (Agilent34980AStatusSubRegisterEnum)_SubRegister.GetVal(), _val.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980AStatus->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetModuleRegister ( ViSession Vi, ViInt32 Slot, ViInt32 SubRegister, ViInt32* retVal )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetModuleRegister\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AStatus2* pIAgilent34980AStatus2 = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AStatus2);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _Slot(Slot);
			CLong _SubRegister(SubRegister);
			CLong _returnVal;
			hr = pIAgilent34980AStatus2->get_ModuleRegister(_Slot.GetVal(), (Agilent34980AStatusSubRegisterEnum)_SubRegister.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal);
			}
			pIAgilent34980AStatus2->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_SetModuleRegister ( ViSession Vi, ViInt32 Slot, ViInt32 SubRegister, ViInt32 val )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_SetModuleRegister\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AStatus2* pIAgilent34980AStatus2 = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AStatus2);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _Slot(Slot);
			CLong _SubRegister(SubRegister);
			CLong _val(val);
			hr = pIAgilent34980AStatus2->put_ModuleRegister(_Slot.GetVal(), (Agilent34980AStatusSubRegisterEnum)_SubRegister.GetVal(), _val.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980AStatus2->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- InputMemory */

ViStatus _VI_FUNC  ag34980a_ReadAllData ( ViSession Vi, ViConstString Channel, ViInt32 retValBufferSize, ViInt32 retVal[], ViInt32* retValActualSize )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ReadAllData\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950AInputMemory* pIAgilent34950AInputMemory = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950AInputMemory);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _Channel(Channel);
			CSAFEARRAY<long> _returnVal;
			hr = pIAgilent34950AInputMemory->ReadAllData(_Channel.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal, retValBufferSize);
				_returnVal.LengthToViDataType(retValActualSize);
			}
			pIAgilent34950AInputMemory->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_ReadSelectedData ( ViSession Vi, ViConstString Channel, ViInt32 Index, ViInt32 Count, ViInt32 retValBufferSize, ViInt32 retVal[], ViInt32* retValActualSize )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ReadSelectedData\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950AInputMemory* pIAgilent34950AInputMemory = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950AInputMemory);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _Channel(Channel);
			CLong _Index(Index);
			CLong _Count(Count);
			CSAFEARRAY<long> _returnVal;
			hr = pIAgilent34950AInputMemory->ReadSelectedData(_Channel.GetVal(), _Index.GetVal(), _Count.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal, retValBufferSize);
				_returnVal.LengthToViDataType(retValActualSize);
			}
			pIAgilent34950AInputMemory->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_StartInput ( ViSession Vi, ViConstString ChannelList )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_StartInput\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950AInputMemory* pIAgilent34950AInputMemory = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950AInputMemory);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			hr = pIAgilent34950AInputMemory->Start(_ChannelList.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950AInputMemory->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_StepInput ( ViSession Vi, ViConstString ChannelList )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_StepInput\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950AInputMemory* pIAgilent34950AInputMemory = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950AInputMemory);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			hr = pIAgilent34950AInputMemory->Step(_ChannelList.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950AInputMemory->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_StopInput ( ViSession Vi, ViConstString ChannelList )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_StopInput\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950AInputMemory* pIAgilent34950AInputMemory = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950AInputMemory);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			hr = pIAgilent34950AInputMemory->Stop(_ChannelList.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950AInputMemory->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- OutputMemory */

ViStatus _VI_FUNC  ag34980a_OutputMemoryAbort ( ViSession Vi, ViConstString ChannelList )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_OutputMemoryAbort\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950AOutputMemory* pIAgilent34950AOutputMemory = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950AOutputMemory);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			hr = pIAgilent34950AOutputMemory->Abort(_ChannelList.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950AOutputMemory->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_StartOutput ( ViSession Vi, ViConstString ChannelList )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_StartOutput\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950AOutputMemory* pIAgilent34950AOutputMemory = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950AOutputMemory);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			hr = pIAgilent34950AOutputMemory->Start(_ChannelList.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950AOutputMemory->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_StepOutput ( ViSession Vi, ViConstString ChannelList )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_StepOutput\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950AOutputMemory* pIAgilent34950AOutputMemory = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950AOutputMemory);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			hr = pIAgilent34950AOutputMemory->Step(_ChannelList.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950AOutputMemory->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_StopOutput ( ViSession Vi, ViConstString ChannelList )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_StopOutput\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950AOutputMemory* pIAgilent34950AOutputMemory = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950AOutputMemory);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			hr = pIAgilent34950AOutputMemory->Stop(_ChannelList.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950AOutputMemory->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Totalizer */

ViStatus _VI_FUNC  ag34980a_ClearTotalizer34950A ( ViSession Vi, ViConstString ChannelList )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ClearTotalizer34950A\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950ATotalizer* pIAgilent34950ATotalizer = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950ATotalizer);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			hr = pIAgilent34950ATotalizer->Clear(_ChannelList.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950ATotalizer->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_ReadTotalizerData34950A ( ViSession Vi, ViConstString ChannelList, ViInt32* retVal )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ReadTotalizerData34950A\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950ATotalizer* pIAgilent34950ATotalizer = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950ATotalizer);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _returnVal;
			hr = pIAgilent34950ATotalizer->ReadData(_ChannelList.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal);
			}
			pIAgilent34950ATotalizer->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Digital Generic */

ViStatus _VI_FUNC  ag34980a_WriteBit ( ViSession Vi, ViConstString ChannelList, ViInt32 Data, ViInt32 BitNumber )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_WriteBit\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _Data(Data);
			CLong _BitNumber(BitNumber);
			hr = pIAgilent34950ADigital->WriteBit(_ChannelList.GetVal(), _Data.GetVal(), _BitNumber.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950ADigital->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_WriteByte ( ViSession Vi, ViConstString ChannelList, ViInt32 Data )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_WriteByte\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _Data(Data);
			hr = pIAgilent34950ADigital->WriteByte(_ChannelList.GetVal(), _Data.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950ADigital->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_WriteWord ( ViSession Vi, ViConstString ChannelList, ViInt32 Data )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_WriteWord\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _Data(Data);
			hr = pIAgilent34950ADigital->WriteWord(_ChannelList.GetVal(), _Data.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950ADigital->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_WriteLongWord ( ViSession Vi, ViConstString ChannelList, ViInt32 Data )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_WriteLongWord\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950ADigital* pIAgilent34950ADigital = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950ADigital);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _Data(Data);
			hr = pIAgilent34950ADigital->WriteLongWord(_ChannelList.GetVal(), _Data.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950ADigital->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- DAC 34951 */

ViStatus _VI_FUNC  ag34980a_ApplyLevel ( ViSession Vi, ViConstString ChannelList, ViInt32 Function, ViReal64 Level )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ApplyLevel\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34951A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34951ASource* pIAgilent34951ASource = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34951ASource);
		status = TranslateHRESULTAgilent34951A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _Function(Function);
			CDouble _Level(Level);
			hr = pIAgilent34951ASource->ApplyLevel(_ChannelList.GetVal(), (Agilent34951AFunctionTypeEnum)_Function.GetVal(), _Level.GetVal());
			status = TranslateHRESULTAgilent34951A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34951ASource->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_ApplyTrace ( ViSession Vi, ViConstString ChannelList, ViConstString TraceName, ViInt32 Function, ViReal64 Gain, ViReal64 Offset, ViReal64 Frequency )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ApplyTrace\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34951A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34951ASource* pIAgilent34951ASource = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34951ASource);
		status = TranslateHRESULTAgilent34951A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CBSTR _TraceName(TraceName);
			CLong _Function(Function);
			CDouble _Gain(Gain);
			CDouble _Offset(Offset);
			CDouble _Frequency(Frequency);
			hr = pIAgilent34951ASource->ApplyTrace(_ChannelList.GetVal(), _TraceName.GetVal(), (Agilent34951AFunctionTypeEnum)_Function.GetVal(), _Gain.GetVal(), _Offset.GetVal(), _Frequency.GetVal());
			status = TranslateHRESULTAgilent34951A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34951ASource->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_StartTrace ( ViSession Vi, ViConstString ChannelList, ViInt32 NumCycles, ViInt32 StartIndex )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_StartTrace\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34951A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34951ASource* pIAgilent34951ASource = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34951ASource);
		status = TranslateHRESULTAgilent34951A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _NumCycles(NumCycles);
			CLong _StartIndex(StartIndex);
			hr = pIAgilent34951ASource->StartTrace(_ChannelList.GetVal(), _NumCycles.GetVal(), _StartIndex.GetVal());
			status = TranslateHRESULTAgilent34951A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34951ASource->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_HaltTrace ( ViSession Vi, ViConstString ChannelList )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_HaltTrace\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34951A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34951ASource* pIAgilent34951ASource = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34951ASource);
		status = TranslateHRESULTAgilent34951A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			hr = pIAgilent34951ASource->HaltTrace(_ChannelList.GetVal());
			status = TranslateHRESULTAgilent34951A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34951ASource->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_TriggerImmediate ( ViSession Vi, ViConstString ChannelList )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_TriggerImmediate\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34951A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34951ATrigger* pIAgilent34951ATrigger = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34951ATrigger);
		status = TranslateHRESULTAgilent34951A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			hr = pIAgilent34951ATrigger->TriggerImmediate(_ChannelList.GetVal());
			status = TranslateHRESULTAgilent34951A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34951ATrigger->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Totalizer */

ViStatus _VI_FUNC  ag34980a_ClearTotal34952A ( ViSession Vi, ViConstString ChannelList )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ClearTotal34952A\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34952A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34952ATotalize* pIAgilent34952ATotalize = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34952ATotalize);
		status = TranslateHRESULTAgilent34952A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			hr = pIAgilent34952ATotalize->ClearTotal(_ChannelList.GetVal());
			status = TranslateHRESULTAgilent34952A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34952ATotalize->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Module */

ViStatus _VI_FUNC  ag34980a_RemoteModuleReset ( ViSession Vi, ViInt32 Slot )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_RemoteModuleReset\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34945A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34945ASystem* pIAgilent34945ASystem = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34945ASystem);
		status = TranslateHRESULTAgilent34945A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _Slot(Slot);
			hr = pIAgilent34945ASystem->RemoteModuleReset(_Slot.GetVal());
			status = TranslateHRESULTAgilent34945A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34945ASystem->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Alarm */

ViStatus _VI_FUNC  ag34980a_AlarmScanSetup ( ViSession Vi, ViConstString ChannelList, ViInt32 Channel, ViInt32 AlarmIndex, ViInt32 NumSweeps, ViReal64 UpperLimit )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_AlarmScanSetup\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AAlarm* pIAgilent34980AAlarm = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AAlarm);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _Channel(Channel);
			CLong _AlarmIndex(AlarmIndex);
			CLong _NumSweeps(NumSweeps);
			CDouble _UpperLimit(UpperLimit);
			hr = pIAgilent34980AAlarm->AlarmScanSetup(_ChannelList.GetVal(), _Channel.GetVal(), _AlarmIndex.GetVal(), _NumSweeps.GetVal(), _UpperLimit.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980AAlarm->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetAlarmSource ( ViSession Vi, ViInt32 Index, ViInt32 retValBufferSize, ViChar retVal[] )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetAlarmSource\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AAlarm* pIAgilent34980AAlarm = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AAlarm);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _Index(Index);
			CBSTR _returnVal;
			hr = pIAgilent34980AAlarm->get_Source(_Index.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal, retValBufferSize);
			}
			pIAgilent34980AAlarm->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_SetAlarmSource ( ViSession Vi, ViInt32 Index, ViConstString val )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_SetAlarmSource\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AAlarm* pIAgilent34980AAlarm = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AAlarm);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _Index(Index);
			CBSTR _val(val);
			hr = pIAgilent34980AAlarm->put_Source(_Index.GetVal(), _val.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980AAlarm->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetAlarmSequence ( ViSession Vi, ViInt32 Index, ViInt32 retValBufferSize, ViChar retVal[] )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetAlarmSequence\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AAlarm2* pIAgilent34980AAlarm2 = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AAlarm2);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _Index(Index);
			CBSTR _returnVal;
			hr = pIAgilent34980AAlarm2->get_AlarmSequence(_Index.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal, retValBufferSize);
			}
			pIAgilent34980AAlarm2->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- AC */

ViStatus _VI_FUNC  ag34980a_ConfigureACVoltage ( ViSession Vi, ViConstString ChannelList, ViReal64 Range, ViInt32 Resolution )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigureACVoltage\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AACVoltage* pIAgilent34980AACVoltage = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AACVoltage);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CDouble _Range(Range);
			CLong _Resolution(Resolution);
			hr = pIAgilent34980AACVoltage->Configure(_ChannelList.GetVal(), _Range.GetVal(), (Agilent34980AResolutionEnum)_Resolution.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980AACVoltage->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- DC */

ViStatus _VI_FUNC  ag34980a_ConfigureDCVoltage ( ViSession Vi, ViConstString ChannelList, ViReal64 Range, ViInt32 Resolution )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigureDCVoltage\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ADCVoltage* pIAgilent34980ADCVoltage = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ADCVoltage);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CDouble _Range(Range);
			CLong _Resolution(Resolution);
			hr = pIAgilent34980ADCVoltage->Configure(_ChannelList.GetVal(), _Range.GetVal(), (Agilent34980AResolutionEnum)_Resolution.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ADCVoltage->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- AC */

ViStatus _VI_FUNC  ag34980a_ConfigureACCurrent ( ViSession Vi, ViConstString ChannelList, ViReal64 Range, ViInt32 Resolution )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigureACCurrent\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AACCurrent* pIAgilent34980AACCurrent = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AACCurrent);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CDouble _Range(Range);
			CLong _Resolution(Resolution);
			hr = pIAgilent34980AACCurrent->Configure(_ChannelList.GetVal(), _Range.GetVal(), (Agilent34980AResolutionEnum)_Resolution.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980AACCurrent->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- DC */

ViStatus _VI_FUNC  ag34980a_ConfigureDCCurrent ( ViSession Vi, ViConstString ChannelList, ViReal64 Range, ViInt32 Resolution )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigureDCCurrent\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ADCCurrent* pIAgilent34980ADCCurrent = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ADCCurrent);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CDouble _Range(Range);
			CLong _Resolution(Resolution);
			hr = pIAgilent34980ADCCurrent->Configure(_ChannelList.GetVal(), _Range.GetVal(), (Agilent34980AResolutionEnum)_Resolution.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ADCCurrent->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Frequency */

ViStatus _VI_FUNC  ag34980a_ConfigureFrequency ( ViSession Vi, ViConstString ChannelList, ViReal64 Range, ViInt32 Resolution )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigureFrequency\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AFrequency* pIAgilent34980AFrequency = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AFrequency);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CDouble _Range(Range);
			CLong _Resolution(Resolution);
			hr = pIAgilent34980AFrequency->Configure(_ChannelList.GetVal(), _Range.GetVal(), (Agilent34980AResolutionEnum)_Resolution.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980AFrequency->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Resistance 4-Wire */

ViStatus _VI_FUNC  ag34980a_ConfigureFResistance ( ViSession Vi, ViConstString ChannelList, ViReal64 Range, ViInt32 Resolution )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigureFResistance\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AFResistance* pIAgilent34980AFResistance = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AFResistance);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CDouble _Range(Range);
			CLong _Resolution(Resolution);
			hr = pIAgilent34980AFResistance->Configure(_ChannelList.GetVal(), _Range.GetVal(), (Agilent34980AResolutionEnum)_Resolution.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980AFResistance->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Memory */

ViStatus _VI_FUNC  ag34980a_GetStateName ( ViSession Vi, ViInt32 LocationNum, ViInt32 retValBufferSize, ViChar retVal[] )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetStateName\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AMemory* pIAgilent34980AMemory = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AMemory);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _LocationNum(LocationNum);
			CBSTR _returnVal;
			hr = pIAgilent34980AMemory->get_StateName(_LocationNum.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal, retValBufferSize);
			}
			pIAgilent34980AMemory->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_SetStateName ( ViSession Vi, ViInt32 LocationNum, ViConstString val )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_SetStateName\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AMemory* pIAgilent34980AMemory = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AMemory);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _LocationNum(LocationNum);
			CBSTR _val(val);
			hr = pIAgilent34980AMemory->put_StateName(_LocationNum.GetVal(), _val.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980AMemory->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetValidState ( ViSession Vi, ViInt32 LocationNum, ViBoolean* retVal )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetValidState\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AMemory* pIAgilent34980AMemory = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AMemory);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _LocationNum(LocationNum);
			CVariantBool _returnVal;
			hr = pIAgilent34980AMemory->get_ValidState(_LocationNum.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal);
			}
			pIAgilent34980AMemory->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Period */

ViStatus _VI_FUNC  ag34980a_ConfigurePeriod ( ViSession Vi, ViConstString ChannelList, ViReal64 Range, ViInt32 Resolution )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigurePeriod\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980APeriod* pIAgilent34980APeriod = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980APeriod);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CDouble _Range(Range);
			CLong _Resolution(Resolution);
			hr = pIAgilent34980APeriod->Configure(_ChannelList.GetVal(), _Range.GetVal(), (Agilent34980AResolutionEnum)_Resolution.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980APeriod->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Resistance 2-Wire */

ViStatus _VI_FUNC  ag34980a_ConfigureResistance ( ViSession Vi, ViConstString ChannelList, ViReal64 Range, ViInt32 Resolution )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigureResistance\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AResistance* pIAgilent34980AResistance = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AResistance);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CDouble _Range(Range);
			CLong _Resolution(Resolution);
			hr = pIAgilent34980AResistance->Configure(_ChannelList.GetVal(), _Range.GetVal(), (Agilent34980AResolutionEnum)_Resolution.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980AResistance->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Scale */

ViStatus _VI_FUNC  ag34980a_OffsetNull ( ViSession Vi, ViConstString ChannelList )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_OffsetNull\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AScale* pIAgilent34980AScale = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AScale);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			hr = pIAgilent34980AScale->OffsetNull(_ChannelList.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980AScale->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Scan */

ViStatus _VI_FUNC  ag34980a_ConfigureScan ( ViSession Vi, ViConstString ChannelList, ViInt32 SweepCount, ViBoolean Ordered )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigureScan\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AScan* pIAgilent34980AScan = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AScan);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _SweepCount(SweepCount);
			CVariantBool _Ordered(Ordered);
			hr = pIAgilent34980AScan->ConfigureScan(_ChannelList.GetVal(), _SweepCount.GetVal(), _Ordered.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980AScan->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- FRTD */

ViStatus _VI_FUNC  ag34980a_ConfigureFRTD ( ViSession Vi, ViConstString ChannelList, ViInt32 Resolution, ViInt32 Type )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigureFRTD\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AFRTD* pIAgilent34980AFRTD = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AFRTD);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _Resolution(Resolution);
			CLong _Type(Type);
			hr = pIAgilent34980AFRTD->Configure(_ChannelList.GetVal(), (Agilent34980AResolutionEnum)_Resolution.GetVal(), (Agilent34980AFRTDAlphaEnum)_Type.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980AFRTD->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- RTD */

ViStatus _VI_FUNC  ag34980a_ConfigureRTD ( ViSession Vi, ViConstString ChannelList, ViInt32 Resolution, ViInt32 Type )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigureRTD\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ARTD* pIAgilent34980ARTD = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ARTD);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _Resolution(Resolution);
			CLong _Type(Type);
			hr = pIAgilent34980ARTD->Configure(_ChannelList.GetVal(), (Agilent34980AResolutionEnum)_Resolution.GetVal(), (Agilent34980ARTDAlphaEnum)_Type.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ARTD->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Thermistor */

ViStatus _VI_FUNC  ag34980a_ConfigureThermistor ( ViSession Vi, ViConstString ChannelList, ViInt32 Resolution, ViInt32 Type )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigureThermistor\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AThermistor* pIAgilent34980AThermistor = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AThermistor);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _Resolution(Resolution);
			CLong _Type(Type);
			hr = pIAgilent34980AThermistor->Configure(_ChannelList.GetVal(), (Agilent34980AResolutionEnum)_Resolution.GetVal(), (Agilent34980AThermistorEnum)_Type.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980AThermistor->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Thermocouple */

ViStatus _VI_FUNC  ag34980a_ConfigureThermocouple ( ViSession Vi, ViConstString ChannelList, ViInt32 Resolution, ViInt32 Type )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigureThermocouple\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980AThermocouple* pIAgilent34980AThermocouple = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980AThermocouple);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _Resolution(Resolution);
			CLong _Type(Type);
			hr = pIAgilent34980AThermocouple->Configure(_ChannelList.GetVal(), (Agilent34980AResolutionEnum)_Resolution.GetVal(), (Agilent34980AThermocoupleEnum)_Type.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980AThermocouple->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Data Format */

ViStatus _VI_FUNC  ag34980a_ConfigureDataFormat ( ViSession Vi, ViBoolean EnableAlarm, ViBoolean EnableChannel, ViBoolean EnableTime, ViInt32 TimeType, ViBoolean EnableUnit )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigureDataFormat\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ADataFormat* pIAgilent34980ADataFormat = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ADataFormat);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CVariantBool _EnableAlarm(EnableAlarm);
			CVariantBool _EnableChannel(EnableChannel);
			CVariantBool _EnableTime(EnableTime);
			CLong _TimeType(TimeType);
			CVariantBool _EnableUnit(EnableUnit);
			hr = pIAgilent34980ADataFormat->Configure(_EnableAlarm.GetVal(), _EnableChannel.GetVal(), _EnableTime.GetVal(), (Agilent34980ATimeOffsetEnum)_TimeType.GetVal(), _EnableUnit.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ADataFormat->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Trigger */

ViStatus _VI_FUNC  ag34980a_ConfigureTrigger ( ViSession Vi, ViInt32 Source, ViInt32 TriggerCount, ViReal64 Timer, ViInt32 SampleCount )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigureTrigger\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ATrigger* pIAgilent34980ATrigger = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ATrigger);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _Source(Source);
			CLong _TriggerCount(TriggerCount);
			CDouble _Timer(Timer);
			CLong _SampleCount(SampleCount);
			hr = pIAgilent34980ATrigger->Configure((Agilent34980ATriggerSourceEnum)_Source.GetVal(), _TriggerCount.GetVal(), _Timer.GetVal(), _SampleCount.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ATrigger->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Sequence */

ViStatus _VI_FUNC  ag34980a_SequenceDefine ( ViSession Vi, ViConstString SequenceName, ViConstString CommandString )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_SequenceDefine\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ARoute2* pIAgilent34980ARoute2 = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ARoute2);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _SequenceName(SequenceName);
			CBSTR _CommandString(CommandString);
			hr = pIAgilent34980ARoute2->SequenceDefine(_SequenceName.GetVal(), _CommandString.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ARoute2->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_SequenceDelete ( ViSession Vi, ViConstString SequenceName )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_SequenceDelete\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ARoute2* pIAgilent34980ARoute2 = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ARoute2);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _SequenceName(SequenceName);
			hr = pIAgilent34980ARoute2->SequenceDelete(_SequenceName.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ARoute2->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_SequenceDeleteAll ( ViSession Vi )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_SequenceDeleteAll\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ARoute2* pIAgilent34980ARoute2 = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ARoute2);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			hr = pIAgilent34980ARoute2->SequenceDeleteAll();
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ARoute2->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Handshake */

ViStatus _VI_FUNC  ag34980a_ConfigureHandshake ( ViSession Vi, ViConstString ChannelList, ViInt32 Mode, ViReal64 Threshold, ViReal64 Level )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigureHandshake\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950AHandshake* pIAgilent34950AHandshake = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950AHandshake);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _Mode(Mode);
			CDouble _Threshold(Threshold);
			CDouble _Level(Level);
			hr = pIAgilent34950AHandshake->Configure(_ChannelList.GetVal(), (Agilent34950AHandshakeModeEnum)_Mode.GetVal(), _Threshold.GetVal(), _Level.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950AHandshake->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetPolarity ( ViSession Vi, ViConstString ChannelList, ViInt32 Mode, ViInt32* retVal )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetPolarity\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950AHandshake* pIAgilent34950AHandshake = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950AHandshake);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _Mode(Mode);
			CLong _returnVal;
			hr = pIAgilent34950AHandshake->GetPolarity(_ChannelList.GetVal(), (Agilent34950AHandshakeLineIDEnum)_Mode.GetVal(), (Agilent34950APolarityEnum*)_returnVal.GetPtr());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal);
			}
			pIAgilent34950AHandshake->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_SetPolarity ( ViSession Vi, ViConstString ChannelList, ViInt32 Mode, ViInt32 Polarity )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_SetPolarity\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950AHandshake* pIAgilent34950AHandshake = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950AHandshake);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _Mode(Mode);
			CLong _Polarity(Polarity);
			hr = pIAgilent34950AHandshake->SetPolarity(_ChannelList.GetVal(), (Agilent34950AHandshakeLineIDEnum)_Mode.GetVal(), (Agilent34950APolarityEnum)_Polarity.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950AHandshake->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Input */

ViStatus _VI_FUNC  ag34980a_ConfigureInput ( ViSession Vi, ViConstString ChannelList, ViInt32 Width, ViReal64 Threshold )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigureInput\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950AInput* pIAgilent34950AInput = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950AInput);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _Width(Width);
			CDouble _Threshold(Threshold);
			hr = pIAgilent34950AInput->Configure(_ChannelList.GetVal(), (Agilent34950AChannelWidthEnum)_Width.GetVal(), _Threshold.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950AInput->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- InputMemory */

ViStatus _VI_FUNC  ag34980a_ConfigureInputMemory ( ViSession Vi, ViConstString ChannelList, ViInt32 Action, ViInt32 Count )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigureInputMemory\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950AInputMemory* pIAgilent34950AInputMemory = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950AInputMemory);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _Action(Action);
			CLong _Count(Count);
			hr = pIAgilent34950AInputMemory->Configure(_ChannelList.GetVal(), (Agilent34950AActionEnum)_Action.GetVal(), _Count.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950AInputMemory->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_ClearInputMemory ( ViSession Vi, ViConstString ChannelList )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ClearInputMemory\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950AInputMemory* pIAgilent34950AInputMemory = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950AInputMemory);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			hr = pIAgilent34950AInputMemory->Clear(_ChannelList.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950AInputMemory->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_InterruptSettings ( ViSession Vi, ViConstString ChannelList, ViBoolean State, ViInt32 Mode, ViInt32 Drive )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_InterruptSettings\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950AInputMemory* pIAgilent34950AInputMemory = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950AInputMemory);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CVariantBool _State(State);
			CLong _Mode(Mode);
			CLong _Drive(Drive);
			hr = pIAgilent34950AInputMemory->InterruptSettings(_ChannelList.GetVal(), _State.GetVal(), (Agilent34950AReportConditionEnum)_Mode.GetVal(), (Agilent34950AHandshakeLineTypeEnum)_Drive.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950AInputMemory->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Output */

ViStatus _VI_FUNC  ag34980a_ConfigureOutput ( ViSession Vi, ViConstString ChannelList, ViInt32 Width, ViReal64 VoltageLevel )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigureOutput\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950AOutput* pIAgilent34950AOutput = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950AOutput);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _Width(Width);
			CDouble _VoltageLevel(VoltageLevel);
			hr = pIAgilent34950AOutput->Configure(_ChannelList.GetVal(), (Agilent34950AChannelWidthEnum)_Width.GetVal(), _VoltageLevel.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950AOutput->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- OutputMemory */

ViStatus _VI_FUNC  ag34980a_ConfigureOutputMemory ( ViSession Vi, ViConstString Channel, ViConstString TraceName, ViInt32 Cycles )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigureOutputMemory\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950AOutputMemory* pIAgilent34950AOutputMemory = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950AOutputMemory);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _Channel(Channel);
			CBSTR _TraceName(TraceName);
			CLong _Cycles(Cycles);
			hr = pIAgilent34950AOutputMemory->Configure(_Channel.GetVal(), _TraceName.GetVal(), _Cycles.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950AOutputMemory->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_OutputMemoryInterruptSettings ( ViSession Vi, ViConstString ChannelList, ViBoolean State, ViInt32 Mode )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_OutputMemoryInterruptSettings\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950AOutputMemory* pIAgilent34950AOutputMemory = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950AOutputMemory);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CVariantBool _State(State);
			CLong _Mode(Mode);
			hr = pIAgilent34950AOutputMemory->InterruptSettings(_ChannelList.GetVal(), _State.GetVal(), (Agilent34950AOutputModeEnum)_Mode.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950AOutputMemory->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Trace */

ViStatus _VI_FUNC  ag34980a_CreateCustomTrace34950A ( ViSession Vi, ViConstString Channel, ViConstString Name, ViInt32 DataBufferSize, ViInt32 Data[], ViInt32 Width, ViInt32 Points )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_CreateCustomTrace34950A\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950ATrace* pIAgilent34950ATrace = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950ATrace);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _Channel(Channel);
			CBSTR _Name(Name);
			CSAFEARRAY<long> _Data(Data, DataBufferSize);
			CLong _Width(Width);
			CLong _Points(Points);
			hr = pIAgilent34950ATrace->CreateCustom(_Channel.GetVal(), _Name.GetVal(), _Data.GetVal(), (Agilent34950AChannelWidthEnum)_Width.GetVal(), _Points.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950ATrace->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_CreateStandardTrace34950A ( ViSession Vi, ViConstString Channel, ViInt32 Type, ViConstString Name, ViInt32 Points )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_CreateStandardTrace34950A\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950ATrace* pIAgilent34950ATrace = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950ATrace);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _Channel(Channel);
			CLong _Type(Type);
			CBSTR _Name(Name);
			CLong _Points(Points);
			hr = pIAgilent34950ATrace->CreateStandard(_Channel.GetVal(), (Agilent34950ATraceTypeEnum)_Type.GetVal(), _Name.GetVal(), _Points.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950ATrace->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_DeleteTrace34950A ( ViSession Vi, ViConstString Channel, ViConstString Name )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_DeleteTrace34950A\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950ATrace* pIAgilent34950ATrace = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950ATrace);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _Channel(Channel);
			CBSTR _Name(Name);
			hr = pIAgilent34950ATrace->Delete(_Channel.GetVal(), _Name.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950ATrace->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_DeleteAllTraces34950A ( ViSession Vi, ViConstString Channel )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_DeleteAllTraces34950A\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950ATrace* pIAgilent34950ATrace = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950ATrace);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _Channel(Channel);
			hr = pIAgilent34950ATrace->DeleteAll(_Channel.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950ATrace->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetTracePoints34950A ( ViSession Vi, ViConstString Channel, ViConstString TraceName, ViInt32* retVal )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetTracePoints34950A\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950ATrace* pIAgilent34950ATrace = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950ATrace);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _Channel(Channel);
			CBSTR _TraceName(TraceName);
			CLong _returnVal;
			hr = pIAgilent34950ATrace->GetPoints(_Channel.GetVal(), _TraceName.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal);
			}
			pIAgilent34950ATrace->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Counter 34950A */

ViStatus _VI_FUNC  ag34980a_ConfigureCounter ( ViSession Vi, ViConstString ChannelList, ViInt32 Function, ViReal64 GateTime )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigureCounter\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950ACounter* pIAgilent34950ACounter = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950ACounter);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _Function(Function);
			CDouble _GateTime(GateTime);
			hr = pIAgilent34950ACounter->Configure(_ChannelList.GetVal(), (Agilent34950AFunctionEnum)_Function.GetVal(), _GateTime.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950ACounter->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetGateThreshold ( ViSession Vi, ViInt32 SlotNumber, ViReal64* retVal )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetGateThreshold\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950ACounter* pIAgilent34950ACounter = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950ACounter);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _SlotNumber(SlotNumber);
			CDouble _returnVal;
			hr = pIAgilent34950ACounter->get_GateThreshold(_SlotNumber.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal);
			}
			pIAgilent34950ACounter->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_SetGateThreshold ( ViSession Vi, ViInt32 SlotNumber, ViReal64 val )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_SetGateThreshold\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950ACounter* pIAgilent34950ACounter = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950ACounter);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _SlotNumber(SlotNumber);
			CDouble _val(val);
			hr = pIAgilent34950ACounter->put_GateThreshold(_SlotNumber.GetVal(), _val.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950ACounter->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Totalizer */

ViStatus _VI_FUNC  ag34980a_ConfigureTotalizer34950A ( ViSession Vi, ViConstString ChannelList, ViInt32 GateSource, ViInt32 ReadType )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigureTotalizer34950A\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950ATotalizer* pIAgilent34950ATotalizer = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950ATotalizer);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _GateSource(GateSource);
			CLong _ReadType(ReadType);
			hr = pIAgilent34950ATotalizer->Configure(_ChannelList.GetVal(), (Agilent34950AGateSourceEnum)_GateSource.GetVal(), (Agilent34950ATotalizeTypeEnum)_ReadType.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950ATotalizer->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- OutputClock 34950A */

ViStatus _VI_FUNC  ag34980a_ConfigureOutputClock ( ViSession Vi, ViReal64 Frequency, ViInt32 Slot, ViReal64 Voltage )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigureOutputClock\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950AOutputClock* pIAgilent34950AOutputClock = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950AOutputClock);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CDouble _Frequency(Frequency);
			CLong _Slot(Slot);
			CDouble _Voltage(Voltage);
			hr = pIAgilent34950AOutputClock->Configure(_Frequency.GetVal(), _Slot.GetVal(), _Voltage.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950AOutputClock->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetFrequency ( ViSession Vi, ViInt32 Slot, ViReal64* retVal )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetFrequency\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950AOutputClock* pIAgilent34950AOutputClock = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950AOutputClock);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _Slot(Slot);
			CDouble _returnVal;
			hr = pIAgilent34950AOutputClock->get_Frequency(_Slot.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal);
			}
			pIAgilent34950AOutputClock->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_SetFrequency ( ViSession Vi, ViInt32 Slot, ViReal64 val )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_SetFrequency\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950AOutputClock* pIAgilent34950AOutputClock = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950AOutputClock);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _Slot(Slot);
			CDouble _val(val);
			hr = pIAgilent34950AOutputClock->put_Frequency(_Slot.GetVal(), _val.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950AOutputClock->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetOutputClockState ( ViSession Vi, ViInt32 Slot, ViBoolean* retVal )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetOutputClockState\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950AOutputClock* pIAgilent34950AOutputClock = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950AOutputClock);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _Slot(Slot);
			CVariantBool _returnVal;
			hr = pIAgilent34950AOutputClock->get_State(_Slot.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal);
			}
			pIAgilent34950AOutputClock->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_SetOutputClockState ( ViSession Vi, ViInt32 Slot, ViBoolean val )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_SetOutputClockState\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950AOutputClock* pIAgilent34950AOutputClock = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950AOutputClock);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _Slot(Slot);
			CVariantBool _val(val);
			hr = pIAgilent34950AOutputClock->put_State(_Slot.GetVal(), _val.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950AOutputClock->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetOutputClockLevel ( ViSession Vi, ViInt32 Slot, ViReal64* retVal )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetOutputClockLevel\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950AOutputClock* pIAgilent34950AOutputClock = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950AOutputClock);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _Slot(Slot);
			CDouble _returnVal;
			hr = pIAgilent34950AOutputClock->get_Level(_Slot.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal);
			}
			pIAgilent34950AOutputClock->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_SetOutputClockLevel ( ViSession Vi, ViInt32 Slot, ViReal64 val )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_SetOutputClockLevel\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34950A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34950AOutputClock* pIAgilent34950AOutputClock = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34950AOutputClock);
		status = TranslateHRESULTAgilent34950A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _Slot(Slot);
			CDouble _val(val);
			hr = pIAgilent34950AOutputClock->put_Level(_Slot.GetVal(), _val.GetVal());
			status = TranslateHRESULTAgilent34950A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34950AOutputClock->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- DAC 34951 */

ViStatus _VI_FUNC  ag34980a_ConfigureTrace ( ViSession Vi, ViConstString ChannelList, ViInt32 Function, ViConstString TraceName, ViReal64 Gain, ViReal64 Offset )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigureTrace\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34951A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34951ASource* pIAgilent34951ASource = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34951ASource);
		status = TranslateHRESULTAgilent34951A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _Function(Function);
			CBSTR _TraceName(TraceName);
			CDouble _Gain(Gain);
			CDouble _Offset(Offset);
			hr = pIAgilent34951ASource->ConfigureTrace(_ChannelList.GetVal(), (Agilent34951AFunctionTypeEnum)_Function.GetVal(), _TraceName.GetVal(), _Gain.GetVal(), _Offset.GetVal());
			status = TranslateHRESULTAgilent34951A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34951ASource->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Current */

ViStatus _VI_FUNC  ag34980a_ConfigureSourceCurrent ( ViSession Vi, ViConstString ChannelList, ViReal64 Level )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigureSourceCurrent\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34951A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34951ACurrent* pIAgilent34951ACurrent = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34951ACurrent);
		status = TranslateHRESULTAgilent34951A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CDouble _Level(Level);
			hr = pIAgilent34951ACurrent->Configure(_ChannelList.GetVal(), _Level.GetVal());
			status = TranslateHRESULTAgilent34951A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34951ACurrent->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Trace */

ViStatus _VI_FUNC  ag34980a_CreateCustomIntegerTrace34951A ( ViSession Vi, ViInt32 SlotNumber, ViConstString Name, ViInt32 Points, ViInt32 DataArrayBufferSize, ViInt32 DataArray[] )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_CreateCustomIntegerTrace34951A\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34951A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34951ATrace* pIAgilent34951ATrace = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34951ATrace);
		status = TranslateHRESULTAgilent34951A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _SlotNumber(SlotNumber);
			CBSTR _Name(Name);
			CLong _Points(Points);
			CSAFEARRAY<long> _DataArray(DataArray, DataArrayBufferSize);
			hr = pIAgilent34951ATrace->CreateCustomInteger(_SlotNumber.GetVal(), _Name.GetVal(), _Points.GetVal(), _DataArray.GetVal());
			status = TranslateHRESULTAgilent34951A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34951ATrace->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_CreateCustomFloatTrace34951A ( ViSession Vi, ViInt32 SlotNumber, ViConstString Name, ViInt32 NumPoints, ViInt32 DataArrayBufferSize, ViReal64 DataArray[] )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_CreateCustomFloatTrace34951A\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34951A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34951ATrace* pIAgilent34951ATrace = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34951ATrace);
		status = TranslateHRESULTAgilent34951A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _SlotNumber(SlotNumber);
			CBSTR _Name(Name);
			CLong _NumPoints(NumPoints);
			CSAFEARRAY<double> _DataArray(DataArray, DataArrayBufferSize);
			hr = pIAgilent34951ATrace->CreateCustomFloat(_SlotNumber.GetVal(), _Name.GetVal(), _NumPoints.GetVal(), _DataArray.GetVal());
			status = TranslateHRESULTAgilent34951A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34951ATrace->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_CreateStandardTrace34951A ( ViSession Vi, ViInt32 SlotNumber, ViConstString Name, ViInt32 Points, ViInt32 Type )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_CreateStandardTrace34951A\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34951A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34951ATrace* pIAgilent34951ATrace = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34951ATrace);
		status = TranslateHRESULTAgilent34951A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _SlotNumber(SlotNumber);
			CBSTR _Name(Name);
			CLong _Points(Points);
			CLong _Type(Type);
			hr = pIAgilent34951ATrace->CreateStandard(_SlotNumber.GetVal(), _Name.GetVal(), _Points.GetVal(), (Agilent34951ATraceWaveformEnum)_Type.GetVal());
			status = TranslateHRESULTAgilent34951A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34951ATrace->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_DeleteTrace34951A ( ViSession Vi, ViInt32 SlotNumber, ViConstString TraceName )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_DeleteTrace34951A\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34951A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34951ATrace* pIAgilent34951ATrace = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34951ATrace);
		status = TranslateHRESULTAgilent34951A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _SlotNumber(SlotNumber);
			CBSTR _TraceName(TraceName);
			hr = pIAgilent34951ATrace->Delete(_SlotNumber.GetVal(), _TraceName.GetVal());
			status = TranslateHRESULTAgilent34951A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34951ATrace->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_DeleteAllTraces34951A ( ViSession Vi, ViInt32 SlotNumber )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_DeleteAllTraces34951A\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34951A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34951ATrace* pIAgilent34951ATrace = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34951ATrace);
		status = TranslateHRESULTAgilent34951A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _SlotNumber(SlotNumber);
			hr = pIAgilent34951ATrace->DeleteAll(_SlotNumber.GetVal());
			status = TranslateHRESULTAgilent34951A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34951ATrace->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_CreateCustomTraceFromFile34951A ( ViSession Vi, ViInt32 SlotNumber, ViConstString Name, ViConstString SourceFile )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_CreateCustomTraceFromFile34951A\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34951A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34951ATrace* pIAgilent34951ATrace = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34951ATrace);
		status = TranslateHRESULTAgilent34951A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _SlotNumber(SlotNumber);
			CBSTR _Name(Name);
			CBSTR _SourceFile(SourceFile);
			hr = pIAgilent34951ATrace->CreateCustomFromFile(_SlotNumber.GetVal(), _Name.GetVal(), _SourceFile.GetVal());
			status = TranslateHRESULTAgilent34951A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34951ATrace->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetTracePoints34951A ( ViSession Vi, ViInt32 SlotNumber, ViConstString Name, ViInt32* retVal )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetTracePoints34951A\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34951A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34951ATrace* pIAgilent34951ATrace = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34951ATrace);
		status = TranslateHRESULTAgilent34951A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _SlotNumber(SlotNumber);
			CBSTR _Name(Name);
			CLong _returnVal;
			hr = pIAgilent34951ATrace->get_Points(_SlotNumber.GetVal(), _Name.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULTAgilent34951A(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal);
			}
			pIAgilent34951ATrace->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetTraceMemoryFree34951A ( ViSession Vi, ViInt32 SlotNumber, ViInt32* retVal )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetTraceMemoryFree34951A\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34951A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34951ATrace* pIAgilent34951ATrace = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34951ATrace);
		status = TranslateHRESULTAgilent34951A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _SlotNumber(SlotNumber);
			CLong _returnVal;
			hr = pIAgilent34951ATrace->get_MemoryFree(_SlotNumber.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULTAgilent34951A(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal);
			}
			pIAgilent34951ATrace->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetTraceCatalog34951A ( ViSession Vi, ViInt32 SlotNumber, ViInt32 retValBufferSize, ViChar retVal[] )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetTraceCatalog34951A\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34951A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34951ATrace* pIAgilent34951ATrace = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34951ATrace);
		status = TranslateHRESULTAgilent34951A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _SlotNumber(SlotNumber);
			CBSTR _returnVal;
			hr = pIAgilent34951ATrace->get_Catalog(_SlotNumber.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULTAgilent34951A(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal, retValBufferSize);
			}
			pIAgilent34951ATrace->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_ConfigureInternalPacing34951A ( ViSession Vi, ViConstString ChannelList, ViInt32 TriggerSource, ViReal64 Period )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigureInternalPacing34951A\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34951A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34951ATrigger* pIAgilent34951ATrigger = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34951ATrigger);
		status = TranslateHRESULTAgilent34951A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _TriggerSource(TriggerSource);
			CDouble _Period(Period);
			hr = pIAgilent34951ATrigger->ConfigureInternalPacing(_ChannelList.GetVal(), (Agilent34951ATraceTriggerSourceEnum)_TriggerSource.GetVal(), _Period.GetVal());
			status = TranslateHRESULTAgilent34951A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34951ATrigger->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_ConfigureExternalPacing34951A ( ViSession Vi, ViConstString ChannelList, ViInt32 TriggerSource, ViInt32 Divisor )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigureExternalPacing34951A\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34951A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34951ATrigger* pIAgilent34951ATrigger = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34951ATrigger);
		status = TranslateHRESULTAgilent34951A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _TriggerSource(TriggerSource);
			CLong _Divisor(Divisor);
			hr = pIAgilent34951ATrigger->ConfigureExternalPacing(_ChannelList.GetVal(), (Agilent34951ATraceTriggerSourceEnum)_TriggerSource.GetVal(), _Divisor.GetVal());
			status = TranslateHRESULTAgilent34951A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34951ATrigger->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Voltage */

ViStatus _VI_FUNC  ag34980a_ConfigureSourceVoltage ( ViSession Vi, ViConstString ChannelList, ViReal64 Level )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigureSourceVoltage\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34951A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34951AVoltage* pIAgilent34951AVoltage = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34951AVoltage);
		status = TranslateHRESULTAgilent34951A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CDouble _Level(Level);
			hr = pIAgilent34951AVoltage->Configure(_ChannelList.GetVal(), _Level.GetVal());
			status = TranslateHRESULTAgilent34951A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34951AVoltage->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Digital */

ViStatus _VI_FUNC  ag34980a_ConfigureDigital34952A ( ViSession Vi, ViConstString ChannelList, ViInt32 Mode, ViInt32 Direction )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigureDigital34952A\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34952A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34952ADigital* pIAgilent34952ADigital = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34952ADigital);
		status = TranslateHRESULTAgilent34952A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _Mode(Mode);
			CLong _Direction(Direction);
			hr = pIAgilent34952ADigital->Configure(_ChannelList.GetVal(), (Agilent34952ADigitalModeEnum)_Mode.GetVal(), (Agilent34952ADirectionEnum)_Direction.GetVal());
			status = TranslateHRESULTAgilent34952A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34952ADigital->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Totalizer */

ViStatus _VI_FUNC  ag34980a_ConfigureTotalizer34952A ( ViSession Vi, ViConstString ChannelList, ViInt32 Type, ViInt32 Mode, ViInt32 Slope )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigureTotalizer34952A\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34952A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34952ATotalize* pIAgilent34952ATotalize = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34952ATotalize);
		status = TranslateHRESULTAgilent34952A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CLong _Type(Type);
			CLong _Mode(Mode);
			CLong _Slope(Slope);
			hr = pIAgilent34952ATotalize->Configure(_ChannelList.GetVal(), (Agilent34952ATotalizeTypeEnum)_Type.GetVal(), (Agilent34952ATotalizeThresholdModeEnum)_Mode.GetVal(), (Agilent34952ATotalizeSlopeEnum)_Slope.GetVal());
			status = TranslateHRESULTAgilent34952A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34952ATotalize->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Channel 34945A */

ViStatus _VI_FUNC  ag34980a_ConfigureChan34945A ( ViSession Vi, ViConstString ChannelList, ViBoolean Paired, ViBoolean PulseMode, ViReal64 PulseWidth, ViReal64 RecoveryTime, ViReal64 SettleTime )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_ConfigureChan34945A\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34945A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34945AChannel* pIAgilent34945AChannel = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34945AChannel);
		status = TranslateHRESULTAgilent34945A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CVariantBool _Paired(Paired);
			CVariantBool _PulseMode(PulseMode);
			CDouble _PulseWidth(PulseWidth);
			CDouble _RecoveryTime(RecoveryTime);
			CDouble _SettleTime(SettleTime);
			hr = pIAgilent34945AChannel->Configure(_ChannelList.GetVal(), _Paired.GetVal(), _PulseMode.GetVal(), _PulseWidth.GetVal(), _RecoveryTime.GetVal(), _SettleTime.GetVal());
			status = TranslateHRESULTAgilent34945A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34945AChannel->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Module 34945A */

ViStatus _VI_FUNC  ag34980a_BankPreset ( ViSession Vi, ViConstString RemoteModuleList, ViInt32 Bank )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_BankPreset\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34945A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34945AModule* pIAgilent34945AModule = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34945AModule);
		status = TranslateHRESULTAgilent34945A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _RemoteModuleList(RemoteModuleList);
			CLong _Bank(Bank);
			hr = pIAgilent34945AModule->BankPreset(_RemoteModuleList.GetVal(), _Bank.GetVal());
			status = TranslateHRESULTAgilent34945A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34945AModule->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetBankDriveType ( ViSession Vi, ViConstString RemoteModuleList, ViInt32 Bank, ViInt32* retVal )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetBankDriveType\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34945A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34945AModule* pIAgilent34945AModule = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34945AModule);
		status = TranslateHRESULTAgilent34945A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _RemoteModuleList(RemoteModuleList);
			CLong _Bank(Bank);
			CLong _returnVal;
			hr = pIAgilent34945AModule->get_BankDriveType(_RemoteModuleList.GetVal(), _Bank.GetVal(), (Agilent34945ADriveTypeEnum*)_returnVal.GetPtr());
			status = TranslateHRESULTAgilent34945A(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal);
			}
			pIAgilent34945AModule->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_SetBankDriveType ( ViSession Vi, ViConstString RemoteModuleList, ViInt32 Bank, ViInt32 val )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_SetBankDriveType\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34945A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34945AModule* pIAgilent34945AModule = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34945AModule);
		status = TranslateHRESULTAgilent34945A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _RemoteModuleList(RemoteModuleList);
			CLong _Bank(Bank);
			CLong _val(val);
			hr = pIAgilent34945AModule->put_BankDriveType(_RemoteModuleList.GetVal(), _Bank.GetVal(), (Agilent34945ADriveTypeEnum)_val.GetVal());
			status = TranslateHRESULTAgilent34945A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34945AModule->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetBankLEDEnable ( ViSession Vi, ViConstString RemoteModuleList, ViInt32 Bank, ViBoolean* retVal )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetBankLEDEnable\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34945A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34945AModule* pIAgilent34945AModule = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34945AModule);
		status = TranslateHRESULTAgilent34945A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _RemoteModuleList(RemoteModuleList);
			CLong _Bank(Bank);
			CVariantBool _returnVal;
			hr = pIAgilent34945AModule->get_BankLEDEnable(_RemoteModuleList.GetVal(), _Bank.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULTAgilent34945A(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal);
			}
			pIAgilent34945AModule->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_SetBankLEDEnable ( ViSession Vi, ViConstString RemoteModuleList, ViInt32 Bank, ViBoolean val )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_SetBankLEDEnable\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34945A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34945AModule* pIAgilent34945AModule = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34945AModule);
		status = TranslateHRESULTAgilent34945A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _RemoteModuleList(RemoteModuleList);
			CLong _Bank(Bank);
			CVariantBool _val(val);
			hr = pIAgilent34945AModule->put_BankLEDEnable(_RemoteModuleList.GetVal(), _Bank.GetVal(), _val.GetVal());
			status = TranslateHRESULTAgilent34945A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34945AModule->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetBankLEDDriveLevel ( ViSession Vi, ViConstString RemoteModuleList, ViInt32 Bank, ViReal64* retVal )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetBankLEDDriveLevel\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34945A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34945AModule* pIAgilent34945AModule = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34945AModule);
		status = TranslateHRESULTAgilent34945A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _RemoteModuleList(RemoteModuleList);
			CLong _Bank(Bank);
			CDouble _returnVal;
			hr = pIAgilent34945AModule->get_BankLEDDriveLevel(_RemoteModuleList.GetVal(), _Bank.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULTAgilent34945A(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal);
			}
			pIAgilent34945AModule->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_SetBankLEDDriveLevel ( ViSession Vi, ViConstString RemoteModuleList, ViInt32 Bank, ViReal64 val )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_SetBankLEDDriveLevel\n"));

	IUnknown* pDriver = NULL;
	status = GetPersonalityAgilent34945A(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34945AModule* pIAgilent34945AModule = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34945AModule);
		status = TranslateHRESULTAgilent34945A(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _RemoteModuleList(RemoteModuleList);
			CLong _Bank(Bank);
			CDouble _val(val);
			hr = pIAgilent34945AModule->put_BankLEDDriveLevel(_RemoteModuleList.GetVal(), _Bank.GetVal(), _val.GetVal());
			status = TranslateHRESULTAgilent34945A(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34945AModule->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Calibration */

ViStatus _VI_FUNC  ag34980a_SetSecurityState ( ViSession Vi, ViBoolean Enable, ViConstString Code )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_SetSecurityState\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ACalibration* pIAgilent34980ACalibration = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ACalibration);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CVariantBool _Enable(Enable);
			CBSTR _Code(Code);
			hr = pIAgilent34980ACalibration->SecurityEnable(_Enable.GetVal(), _Code.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ACalibration->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- DMM */

ViStatus _VI_FUNC  ag34980a_PerformDMMCalibration ( ViSession Vi )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_PerformDMMCalibration\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ADMM* pIAgilent34980ADMM = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ADMM);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			hr = pIAgilent34980ADMM->PerformCalibration();
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ADMM->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- DAC */

ViStatus _VI_FUNC  ag34980a_AutoCalibrateDAC ( ViSession Vi, ViInt16 SlotNumber, ViBoolean All )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_AutoCalibrateDAC\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ADAC* pIAgilent34980ADAC = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ADAC);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CShort _SlotNumber(SlotNumber);
			CVariantBool _All(All);
			hr = pIAgilent34980ADAC->AutoCalibrate(_SlotNumber.GetVal(), _All.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ADAC->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_AbortManualCalibration ( ViSession Vi )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_AbortManualCalibration\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ADAC* pIAgilent34980ADAC = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ADAC);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			hr = pIAgilent34980ADAC->Abort();
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ADAC->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_BeginVoltageCalibration ( ViSession Vi, ViConstString ChannelList, ViInt16 SetupNumber )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_BeginVoltageCalibration\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ADAC* pIAgilent34980ADAC = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ADAC);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CBSTR _ChannelList(ChannelList);
			CShort _SetupNumber(SetupNumber);
			hr = pIAgilent34980ADAC->BeginVoltageCal(_ChannelList.GetVal(), _SetupNumber.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ADAC->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_CalibrationPointData ( ViSession Vi, ViReal64 PointData )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_CalibrationPointData\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ADAC* pIAgilent34980ADAC = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ADAC);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CDouble _PointData(PointData);
			hr = pIAgilent34980ADAC->Point(_PointData.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ADAC->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetDACCalibrationCount ( ViSession Vi, ViInt16 SlotNumber, ViInt32* retVal )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetDACCalibrationCount\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ADAC* pIAgilent34980ADAC = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ADAC);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CShort _SlotNumber(SlotNumber);
			CLong _returnVal;
			hr = pIAgilent34980ADAC->get_Count(_SlotNumber.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal);
			}
			pIAgilent34980ADAC->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_GetDACCalibrationMessage ( ViSession Vi, ViInt16 SlotNumber, ViInt32 retValBufferSize, ViChar retVal[] )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetDACCalibrationMessage\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ADAC* pIAgilent34980ADAC = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ADAC);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CShort _SlotNumber(SlotNumber);
			CBSTR _returnVal;
			hr = pIAgilent34980ADAC->get_String(_SlotNumber.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal, retValBufferSize);
			}
			pIAgilent34980ADAC->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


ViStatus _VI_FUNC  ag34980a_SetDACCalibrationMessage ( ViSession Vi, ViInt16 SlotNumber, ViConstString val )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_SetDACCalibrationMessage\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ADAC* pIAgilent34980ADAC = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ADAC);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CShort _SlotNumber(SlotNumber);
			CBSTR _val(val);
			hr = pIAgilent34980ADAC->put_String(_SlotNumber.GetVal(), _val.GetVal());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
			}
			pIAgilent34980ADAC->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


    /*- Diagnostic */

ViStatus _VI_FUNC  ag34980a_GetDMMCycles ( ViSession Vi, ViInt32 Index, ViInt32* retVal )
{
	ViStatus status = VI_SUCCESS;

	IVIC_TRACE(_T("ag34980a_GetDMMCycles\n"));

	IUnknown* pDriver = NULL;
	status = GetDriver(Vi, &pDriver);
	if (status == VI_SUCCESS)
	{
		HRESULT hr;

		IAgilent34980ADiagnostic* pIAgilent34980ADiagnostic = NULL;
		hr = pDriver->QueryInterface(&pIAgilent34980ADiagnostic);
		status = TranslateHRESULT(Vi, hr);
		ATLASSERT(SUCCEEDED(hr));
		if (SUCCEEDED(hr))
		{
			CLong _Index(Index);
			CLong _returnVal;
			hr = pIAgilent34980ADiagnostic->get_DMMCycles(_Index.GetVal(), _returnVal.GetPtr());
			status = TranslateHRESULT(Vi, hr);
			if (SUCCEEDED(hr))
			{
				status = _returnVal.ToViDataType(retVal);
			}
			pIAgilent34980ADiagnostic->Release();
		}
	
		pDriver->Release();
	}
	return status;
}


const CIviCErrorMap* GetIviCDriverErrorMap()
{
	static const CIviCErrorMap _errorMap(
		new CIviCDriverErrorInfo(S_IVI_SUCCESS, AG34980A_SUCCESS),
		new CIviCDriverErrorInfo(S_IVI_NSUP_ID_QUERY, AG34980A_WARN_NSUP_ID_QUERY),
		new CIviCDriverErrorInfo(S_IVI_NSUP_RESET, AG34980A_WARN_NSUP_RESET),
		new CIviCDriverErrorInfo(S_IVI_NSUP_SELF_TEST, AG34980A_WARN_NSUP_SELF_TEST),
		new CIviCDriverErrorInfo(S_IVI_NSUP_ERROR_QUERY, AG34980A_WARN_NSUP_ERROR_QUERY),
		new CIviCDriverErrorInfo(S_IVI_NSUP_REV_QUERY, AG34980A_WARN_NSUP_REV_QUERY),
		new CIviCDriverErrorInfo(E_IVI_CANNOT_RECOVER, AG34980A_ERROR_CANNOT_RECOVER),
		new CIviCDriverErrorInfo(E_IVI_INSTRUMENT_STATUS, AG34980A_ERROR_INSTRUMENT_STATUS),
		new CIviCDriverErrorInfo(E_IVI_CANNOT_OPEN_FILE, AG34980A_ERROR_CANNOT_OPEN_FILE),
		new CIviCDriverErrorInfo(E_IVI_READING_FILE, AG34980A_ERROR_READING_FILE),
		new CIviCDriverErrorInfo(E_IVI_WRITING_FILE, AG34980A_ERROR_WRITING_FILE),
		new CIviCDriverErrorInfo(E_IVI_INVALID_PATHNAME, AG34980A_ERROR_INVALID_PATHNAME),
		new CIviCDriverErrorInfo(E_IVI_INVALID_VALUE, AG34980A_ERROR_INVALID_VALUE),
		new CIviCDriverErrorInfo(E_IVI_METHOD_NOT_SUPPORTED, AG34980A_ERROR_FUNCTION_NOT_SUPPORTED),
		new CIviCDriverErrorInfo(E_IVI_PROPERTY_NOT_SUPPORTED, AG34980A_ERROR_ATTRIBUTE_NOT_SUPPORTED),
		new CIviCDriverErrorInfo(E_IVI_VALUE_NOT_SUPPORTED, AG34980A_ERROR_VALUE_NOT_SUPPORTED),
		new CIviCDriverErrorInfo(E_IVI_NOT_INITIALIZED, AG34980A_ERROR_NOT_INITIALIZED),
		new CIviCDriverErrorInfo(E_IVI_UNKNOWN_CHANNEL_NAME, AG34980A_ERROR_UNKNOWN_CHANNEL_NAME),
		new CIviCDriverErrorInfo(E_IVI_TOO_MANY_OPEN_FILES, AG34980A_ERROR_TOO_MANY_OPEN_FILES),
		new CIviCDriverErrorInfo(E_IVI_CHANNEL_NAME_REQUIRED, AG34980A_ERROR_CHANNEL_NAME_REQUIRED),
		new CIviCDriverErrorInfo(E_IVI_MISSING_OPTION_NAME, AG34980A_ERROR_MISSING_OPTION_NAME),
		new CIviCDriverErrorInfo(E_IVI_MISSING_OPTION_VALUE, AG34980A_ERROR_MISSING_OPTION_VALUE),
		new CIviCDriverErrorInfo(E_IVI_BAD_OPTION_NAME, AG34980A_ERROR_BAD_OPTION_NAME),
		new CIviCDriverErrorInfo(E_IVI_BAD_OPTION_VALUE, AG34980A_ERROR_BAD_OPTION_VALUE),
		new CIviCDriverErrorInfo(E_IVI_OUT_OF_MEMORY, AG34980A_ERROR_OUT_OF_MEMORY),
		new CIviCDriverErrorInfo(E_IVI_OPERATION_PENDING, AG34980A_ERROR_OPERATION_PENDING),
		new CIviCDriverErrorInfo(E_IVI_NULL_POINTER, AG34980A_ERROR_NULL_POINTER),
		new CIviCDriverErrorInfo(E_IVI_UNEXPECTED_RESPONSE, AG34980A_ERROR_UNEXPECTED_RESPONSE),
		new CIviCDriverErrorInfo(E_IVI_FILE_NOT_FOUND, AG34980A_ERROR_FILE_NOT_FOUND),
		new CIviCDriverErrorInfo(E_IVI_INVALID_FILE_FORMAT, AG34980A_ERROR_INVALID_FILE_FORMAT),
		new CIviCDriverErrorInfo(E_IVI_STATUS_NOT_AVAILABLE, AG34980A_ERROR_STATUS_NOT_AVAILABLE),
		new CIviCDriverErrorInfo(E_IVI_ID_QUERY_FAILED, AG34980A_ERROR_ID_QUERY_FAILED),
		new CIviCDriverErrorInfo(E_IVI_RESET_FAILED, AG34980A_ERROR_RESET_FAILED),
		new CIviCDriverErrorInfo(E_IVI_RESOURCE_UNKNOWN, AG34980A_ERROR_RESOURCE_UNKNOWN),
		new CIviCDriverErrorInfo(E_IVI_ALREADY_INITIALIZED, AG34980A_ERROR_ALREADY_INITIALIZED),
		new CIviCDriverErrorInfo(E_IVI_CANNOT_CHANGE_SIMULATION_STATE, AG34980A_ERROR_CANNOT_CHANGE_SIMULATION_STATE),
		new CIviCDriverErrorInfo(E_IVI_INVALID_NUMBER_OF_LEVELS_IN_SELECTOR, AG34980A_ERROR_INVALID_NUMBER_OF_LEVELS_IN_SELECTOR),
		new CIviCDriverErrorInfo(E_IVI_INVALID_RANGE_IN_SELECTOR, AG34980A_ERROR_INVALID_RANGE_IN_SELECTOR),
		new CIviCDriverErrorInfo(E_IVI_UNKNOWN_NAME_IN_SELECTOR, AG34980A_ERROR_UNKOWN_NAME_IN_SELECTOR),
		new CIviCDriverErrorInfo(E_IVI_BADLY_FORMED_SELECTOR, AG34980A_ERROR_BADLY_FORMED_SELECTOR),
		new CIviCDriverErrorInfo(E_IVI_UNKNOWN_PHYSICAL_IDENTIFIER, AG34980A_ERROR_UNKNOWN_PHYSICAL_IDENTIFIER),
		new CIviCDriverErrorInfo(E_IVIDMM_MAX_TIME_EXCEEDED, AG34980A_IVIDMM_ERROR_MAX_TIME_EXCEEDED),
		new CIviCDriverErrorInfo(E_IVIDMM_TRIGGER_NOT_SOFTWARE, AG34980A_IVIDMM_ERROR_TRIGGER_NOT_SOFTWARE),
		new CIviCDriverErrorInfo(S_IVIDMM_OVER_RANGE, AG34980A_IVIDMM_WARN_OVER_RANGE),
		new CIviCDriverErrorInfo(S_IVISWTCH_PATH_REMAINS, AG34980A_WARN_PATH_REMAINS),
		new CIviCDriverErrorInfo(S_IVISWTCH_IMPLICIT_CONNECTION_EXISTS, AG34980A_WARN_IMPLICIT_CONNECTION_EXISTS),
		new CIviCDriverErrorInfo(E_IVISWTCH_TRIGGER_NOT_SOFTWARE, AG34980A_ERROR_TRIGGER_NOT_SOFTWARE),
		new CIviCDriverErrorInfo(E_IVISWTCH_INVALID_SWITCH_PATH, AG34980A_ERROR_INVALID_SWITCH_PATH),
		new CIviCDriverErrorInfo(E_IVISWTCH_INVALID_SCAN_LIST, AG34980A_ERROR_INVALID_SCAN_LIST),
		new CIviCDriverErrorInfo(E_IVISWTCH_RSRC_IN_USE, AG34980A_ERROR_RSRC_IN_USE),
		new CIviCDriverErrorInfo(E_IVISWTCH_EMPTY_SCAN_LIST, AG34980A_ERROR_EMPTY_SCAN_LIST),
		new CIviCDriverErrorInfo(E_IVISWTCH_EMPTY_SWITCH_PATH, AG34980A_ERROR_EMPTY_SWITCH_PATH),
		new CIviCDriverErrorInfo(E_IVISWTCH_SCAN_IN_PROGRESS, AG34980A_ERROR_SCAN_IN_PROGRESS),
		new CIviCDriverErrorInfo(E_IVISWTCH_NO_SCAN_IN_PROGRESS, AG34980A_ERROR_NO_SCAN_IN_PROGRESS),
		new CIviCDriverErrorInfo(E_IVISWTCH_NO_SUCH_PATH, AG34980A_ERROR_NO_SUCH_PATH),
		new CIviCDriverErrorInfo(E_IVISWTCH_IS_CONFIGURATION_CHANNEL, AG34980A_ERROR_IS_CONFIGURATION_CHANNEL),
		new CIviCDriverErrorInfo(E_IVISWTCH_NOT_A_CONFIGURATION_CHANNEL, AG34980A_ERROR_NOT_A_CONFIGURATION_CHANNEL),
		new CIviCDriverErrorInfo(E_IVISWTCH_ATTEMPT_TO_CONNECT_SOURCES, AG34980A_ERROR_ATTEMPT_TO_CONNECT_SOURCES),
		new CIviCDriverErrorInfo(E_IVISWTCH_EXPLICIT_CONNECTION_EXISTS, AG34980A_ERROR_EXPLICIT_CONNECTION_EXISTS),
		new CIviCDriverErrorInfo(E_IVISWTCH_LEG_MISSING_FIRST_CHANNEL, AG34980A_ERROR_LEG_MISSING_FIRST_CHANNEL),
		new CIviCDriverErrorInfo(E_IVISWTCH_LEG_MISSING_SECOND_CHANNEL, AG34980A_ERROR_LEG_MISSING_SECOND_CHANNEL),
		new CIviCDriverErrorInfo(E_IVISWTCH_CHANNEL_DUPLICATED_IN_LEG, AG34980A_ERROR_CHANNEL_DUPLICATED_IN_LEG),
		new CIviCDriverErrorInfo(E_IVISWTCH_CHANNEL_DUPLICATED_IN_PATH, AG34980A_ERROR_CHANNEL_DUPLICATED_IN_PATH),
		new CIviCDriverErrorInfo(E_IVISWTCH_PATH_NOT_FOUND, AG34980A_ERROR_PATH_NOT_FOUND),
		new CIviCDriverErrorInfo(E_IVISWTCH_DISCONTINUOUS_PATH, AG34980A_ERROR_DISCONTINUOUS_PATH),
		new CIviCDriverErrorInfo(E_IVISWTCH_CANNOT_CONNECT_DIRECTLY, AG34980A_ERROR_CANNOT_CONNECT_DIRECTLY),
		new CIviCDriverErrorInfo(E_IVISWTCH_CHANNELS_ALREADY_CONNECTED, AG34980A_ERROR_CHANNELS_ALREADY_CONNECTED),
		new CIviCDriverErrorInfo(E_IVISWTCH_CANNOT_CONNECT_TO_ITSELF, AG34980A_ERROR_CANNOT_CONNECT_TO_ITSELF),
		new CIviCDriverErrorInfo(E_IVISWTCH_MAX_TIME_EXCEEDED, AG34980A_ERROR_MAX_TIME_EXCEEDED),
		new CIviCDriverErrorInfo(E_AGILENT34980A_UNEXPECTED, AG34980A_ERROR_UNEXPECTED),
		new CIviCDriverErrorInfo(E_AGILENT34980A_PERSONALITY_NOT_ACTIVE, AG34980A_ERROR_PERSONALITY_NOT_ACTIVE),
		new CIviCDriverErrorInfo(E_AGILENT34980A_PERSONALITY_NOT_INSTALLED, AG34980A_ERROR_PERSONALITY_NOT_INSTALLED),
		new CIviCDriverErrorInfo(E_AGILENT34980A_PERSONALITY_NOT_LICENSED, AG34980A_ERROR_PERSONALITY_NOT_LICENSED),
		new CIviCDriverErrorInfo(E_AGILENT34980A_IO_GENERAL, AG34980A_ERROR_IO_GENERAL),
		new CIviCDriverErrorInfo(E_AGILENT34980A_IO_TIMEOUT, AG34980A_ERROR_IO_TIMEOUT),
		new CIviCDriverErrorInfo(E_AGILENT34980A_MODEL_NOT_SUPPORTED, AG34980A_ERROR_MODEL_NOT_SUPPORTED),
		new CIviCDriverErrorInfo(E_AGILENT34980A_VALUE_OUT_OF_RANGE, AG34980A_ERROR_VALUE_OUT_OF_RANGE),
		new CIviCDriverErrorInfo(E_AGILENT34980A_WRAPPED_DRIVER_ERROR, AG34980A_ERROR_WRAPPED_DRIVER_ERROR),
		new CIviCDriverErrorInfo(E_AGILENT34980A_LOCATIONS_BUSY, AG34980A_ERROR_LOCATIONS_BUSY),
		new CIviCDriverErrorInfo(E_AGILENT34980A_MULTIPLE_CHANNELS_IN_GET, AG34980A_ERROR_MULTIPLE_CHANNELS_IN_GET),
		new CIviCDriverErrorInfo(E_AGILENT34980A_MISSING_DMM_OPTION, AG34980A_ERROR_MISSING_DMM_OPTION),
		new CIviCDriverErrorInfo(E_AGILENT34980A_BAD_SIMULATION_OPTION, AG34980A_ERROR_BAD_SIMULATION_OPTION),
		new CIviCDriverErrorInfo(E_AGILENT34980A_MISSING_SIMULATION_OPTION, AG34980A_ERROR_MISSING_SIMULATION_OPTION),
		NULL);

	return &_errorMap;
}
const CIviCErrorMap* GetIviCDriverErrorMapAgilent34950A()
{
	static const CIviCErrorMap _errorMap(
		new CIviCDriverErrorInfo(S_IVI_SUCCESS, AG34980A_SUCCESS),
		new CIviCDriverErrorInfo(S_IVI_NSUP_ID_QUERY, AG34980A_WARN_NSUP_ID_QUERY),
		new CIviCDriverErrorInfo(S_IVI_NSUP_RESET, AG34980A_WARN_NSUP_RESET),
		new CIviCDriverErrorInfo(S_IVI_NSUP_SELF_TEST, AG34980A_WARN_NSUP_SELF_TEST),
		new CIviCDriverErrorInfo(S_IVI_NSUP_ERROR_QUERY, AG34980A_WARN_NSUP_ERROR_QUERY),
		new CIviCDriverErrorInfo(S_IVI_NSUP_REV_QUERY, AG34980A_WARN_NSUP_REV_QUERY),
		new CIviCDriverErrorInfo(E_IVI_CANNOT_RECOVER, AG34980A_ERROR_CANNOT_RECOVER),
		new CIviCDriverErrorInfo(E_IVI_INSTRUMENT_STATUS, AG34980A_ERROR_INSTRUMENT_STATUS),
		new CIviCDriverErrorInfo(E_IVI_CANNOT_OPEN_FILE, AG34980A_ERROR_CANNOT_OPEN_FILE),
		new CIviCDriverErrorInfo(E_IVI_READING_FILE, AG34980A_ERROR_READING_FILE),
		new CIviCDriverErrorInfo(E_IVI_WRITING_FILE, AG34980A_ERROR_WRITING_FILE),
		new CIviCDriverErrorInfo(E_IVI_INVALID_PATHNAME, AG34980A_ERROR_INVALID_PATHNAME),
		new CIviCDriverErrorInfo(E_IVI_INVALID_VALUE, AG34980A_ERROR_INVALID_VALUE),
		new CIviCDriverErrorInfo(E_IVI_METHOD_NOT_SUPPORTED, AG34980A_ERROR_FUNCTION_NOT_SUPPORTED),
		new CIviCDriverErrorInfo(E_IVI_PROPERTY_NOT_SUPPORTED, AG34980A_ERROR_ATTRIBUTE_NOT_SUPPORTED),
		new CIviCDriverErrorInfo(E_IVI_VALUE_NOT_SUPPORTED, AG34980A_ERROR_VALUE_NOT_SUPPORTED),
		new CIviCDriverErrorInfo(E_IVI_NOT_INITIALIZED, AG34980A_ERROR_NOT_INITIALIZED),
		new CIviCDriverErrorInfo(E_IVI_UNKNOWN_CHANNEL_NAME, AG34980A_ERROR_UNKNOWN_CHANNEL_NAME),
		new CIviCDriverErrorInfo(E_IVI_TOO_MANY_OPEN_FILES, AG34980A_ERROR_TOO_MANY_OPEN_FILES),
		new CIviCDriverErrorInfo(E_IVI_CHANNEL_NAME_REQUIRED, AG34980A_ERROR_CHANNEL_NAME_REQUIRED),
		new CIviCDriverErrorInfo(E_IVI_MISSING_OPTION_NAME, AG34980A_ERROR_MISSING_OPTION_NAME),
		new CIviCDriverErrorInfo(E_IVI_MISSING_OPTION_VALUE, AG34980A_ERROR_MISSING_OPTION_VALUE),
		new CIviCDriverErrorInfo(E_IVI_BAD_OPTION_NAME, AG34980A_ERROR_BAD_OPTION_NAME),
		new CIviCDriverErrorInfo(E_IVI_BAD_OPTION_VALUE, AG34980A_ERROR_BAD_OPTION_VALUE),
		new CIviCDriverErrorInfo(E_IVI_OUT_OF_MEMORY, AG34980A_ERROR_OUT_OF_MEMORY),
		new CIviCDriverErrorInfo(E_IVI_OPERATION_PENDING, AG34980A_ERROR_OPERATION_PENDING),
		new CIviCDriverErrorInfo(E_IVI_NULL_POINTER, AG34980A_ERROR_NULL_POINTER),
		new CIviCDriverErrorInfo(E_IVI_UNEXPECTED_RESPONSE, AG34980A_ERROR_UNEXPECTED_RESPONSE),
		new CIviCDriverErrorInfo(E_IVI_FILE_NOT_FOUND, AG34980A_ERROR_FILE_NOT_FOUND),
		new CIviCDriverErrorInfo(E_IVI_INVALID_FILE_FORMAT, AG34980A_ERROR_INVALID_FILE_FORMAT),
		new CIviCDriverErrorInfo(E_IVI_STATUS_NOT_AVAILABLE, AG34980A_ERROR_STATUS_NOT_AVAILABLE),
		new CIviCDriverErrorInfo(E_IVI_ID_QUERY_FAILED, AG34980A_ERROR_ID_QUERY_FAILED),
		new CIviCDriverErrorInfo(E_IVI_RESET_FAILED, AG34980A_ERROR_RESET_FAILED),
		new CIviCDriverErrorInfo(E_IVI_RESOURCE_UNKNOWN, AG34980A_ERROR_RESOURCE_UNKNOWN),
		new CIviCDriverErrorInfo(E_IVI_ALREADY_INITIALIZED, AG34980A_ERROR_ALREADY_INITIALIZED),
		new CIviCDriverErrorInfo(E_IVI_CANNOT_CHANGE_SIMULATION_STATE, AG34980A_ERROR_CANNOT_CHANGE_SIMULATION_STATE),
		new CIviCDriverErrorInfo(E_IVI_INVALID_NUMBER_OF_LEVELS_IN_SELECTOR, AG34980A_ERROR_INVALID_NUMBER_OF_LEVELS_IN_SELECTOR),
		new CIviCDriverErrorInfo(E_IVI_INVALID_RANGE_IN_SELECTOR, AG34980A_ERROR_INVALID_RANGE_IN_SELECTOR),
		new CIviCDriverErrorInfo(E_IVI_UNKNOWN_NAME_IN_SELECTOR, AG34980A_ERROR_UNKOWN_NAME_IN_SELECTOR),
		new CIviCDriverErrorInfo(E_IVI_BADLY_FORMED_SELECTOR, AG34980A_ERROR_BADLY_FORMED_SELECTOR),
		new CIviCDriverErrorInfo(E_IVI_UNKNOWN_PHYSICAL_IDENTIFIER, AG34980A_ERROR_UNKNOWN_PHYSICAL_IDENTIFIER),
		new CIviCDriverErrorInfo(E_AGILENT34950A_WRAPPED_DRIVER_ERROR, AG34980A_ERRORAGILENT34950A_WRAPPED_DRIVER_ERROR),
		new CIviCDriverErrorInfo(E_AGILENT34950A_VALUE_OUT_OF_RANGE, AG34980A_ERRORAGILENT34950A_VALUE_OUT_OF_RANGE),
		new CIviCDriverErrorInfo(E_AGILENT34950A_MODEL_NOT_SUPPORTED, AG34980A_ERRORAGILENT34950A_MODEL_NOT_SUPPORTED),
		new CIviCDriverErrorInfo(E_AGILENT34950A_IO_TIMEOUT, AG34980A_ERRORAGILENT34950A_IO_TIMEOUT),
		new CIviCDriverErrorInfo(E_AGILENT34950A_IO_GENERAL, AG34980A_ERRORAGILENT34950A_IO_GENERAL),
		new CIviCDriverErrorInfo(E_AGILENT34950A_PERSONALITY_NOT_LICENSED, AG34980A_ERRORAGILENT34950A_PERSONALITY_NOT_LICENSED),
		new CIviCDriverErrorInfo(E_AGILENT34950A_PERSONALITY_NOT_INSTALLED, AG34980A_ERRORAGILENT34950A_PERSONALITY_NOT_INSTALLED),
		new CIviCDriverErrorInfo(E_AGILENT34950A_PERSONALITY_NOT_ACTIVE, AG34980A_ERRORAGILENT34950A_PERSONALITY_NOT_ACTIVE),
		new CIviCDriverErrorInfo(E_AGILENT34950A_UNEXPECTED, AG34980A_ERRORAGILENT34950A_UNEXPECTED),
		NULL);

	return &_errorMap;
}
const CIviCErrorMap* GetIviCDriverErrorMapAgilent34951A()
{
	static const CIviCErrorMap _errorMap(
		new CIviCDriverErrorInfo(S_IVI_SUCCESS, AG34980A_SUCCESS),
		new CIviCDriverErrorInfo(S_IVI_NSUP_ID_QUERY, AG34980A_WARN_NSUP_ID_QUERY),
		new CIviCDriverErrorInfo(S_IVI_NSUP_RESET, AG34980A_WARN_NSUP_RESET),
		new CIviCDriverErrorInfo(S_IVI_NSUP_SELF_TEST, AG34980A_WARN_NSUP_SELF_TEST),
		new CIviCDriverErrorInfo(S_IVI_NSUP_ERROR_QUERY, AG34980A_WARN_NSUP_ERROR_QUERY),
		new CIviCDriverErrorInfo(S_IVI_NSUP_REV_QUERY, AG34980A_WARN_NSUP_REV_QUERY),
		new CIviCDriverErrorInfo(E_IVI_CANNOT_RECOVER, AG34980A_ERROR_CANNOT_RECOVER),
		new CIviCDriverErrorInfo(E_IVI_INSTRUMENT_STATUS, AG34980A_ERROR_INSTRUMENT_STATUS),
		new CIviCDriverErrorInfo(E_IVI_CANNOT_OPEN_FILE, AG34980A_ERROR_CANNOT_OPEN_FILE),
		new CIviCDriverErrorInfo(E_IVI_READING_FILE, AG34980A_ERROR_READING_FILE),
		new CIviCDriverErrorInfo(E_IVI_WRITING_FILE, AG34980A_ERROR_WRITING_FILE),
		new CIviCDriverErrorInfo(E_IVI_INVALID_PATHNAME, AG34980A_ERROR_INVALID_PATHNAME),
		new CIviCDriverErrorInfo(E_IVI_INVALID_VALUE, AG34980A_ERROR_INVALID_VALUE),
		new CIviCDriverErrorInfo(E_IVI_METHOD_NOT_SUPPORTED, AG34980A_ERROR_FUNCTION_NOT_SUPPORTED),
		new CIviCDriverErrorInfo(E_IVI_PROPERTY_NOT_SUPPORTED, AG34980A_ERROR_ATTRIBUTE_NOT_SUPPORTED),
		new CIviCDriverErrorInfo(E_IVI_VALUE_NOT_SUPPORTED, AG34980A_ERROR_VALUE_NOT_SUPPORTED),
		new CIviCDriverErrorInfo(E_IVI_NOT_INITIALIZED, AG34980A_ERROR_NOT_INITIALIZED),
		new CIviCDriverErrorInfo(E_IVI_UNKNOWN_CHANNEL_NAME, AG34980A_ERROR_UNKNOWN_CHANNEL_NAME),
		new CIviCDriverErrorInfo(E_IVI_TOO_MANY_OPEN_FILES, AG34980A_ERROR_TOO_MANY_OPEN_FILES),
		new CIviCDriverErrorInfo(E_IVI_CHANNEL_NAME_REQUIRED, AG34980A_ERROR_CHANNEL_NAME_REQUIRED),
		new CIviCDriverErrorInfo(E_IVI_MISSING_OPTION_NAME, AG34980A_ERROR_MISSING_OPTION_NAME),
		new CIviCDriverErrorInfo(E_IVI_MISSING_OPTION_VALUE, AG34980A_ERROR_MISSING_OPTION_VALUE),
		new CIviCDriverErrorInfo(E_IVI_BAD_OPTION_NAME, AG34980A_ERROR_BAD_OPTION_NAME),
		new CIviCDriverErrorInfo(E_IVI_BAD_OPTION_VALUE, AG34980A_ERROR_BAD_OPTION_VALUE),
		new CIviCDriverErrorInfo(E_IVI_OUT_OF_MEMORY, AG34980A_ERROR_OUT_OF_MEMORY),
		new CIviCDriverErrorInfo(E_IVI_OPERATION_PENDING, AG34980A_ERROR_OPERATION_PENDING),
		new CIviCDriverErrorInfo(E_IVI_NULL_POINTER, AG34980A_ERROR_NULL_POINTER),
		new CIviCDriverErrorInfo(E_IVI_UNEXPECTED_RESPONSE, AG34980A_ERROR_UNEXPECTED_RESPONSE),
		new CIviCDriverErrorInfo(E_IVI_FILE_NOT_FOUND, AG34980A_ERROR_FILE_NOT_FOUND),
		new CIviCDriverErrorInfo(E_IVI_INVALID_FILE_FORMAT, AG34980A_ERROR_INVALID_FILE_FORMAT),
		new CIviCDriverErrorInfo(E_IVI_STATUS_NOT_AVAILABLE, AG34980A_ERROR_STATUS_NOT_AVAILABLE),
		new CIviCDriverErrorInfo(E_IVI_ID_QUERY_FAILED, AG34980A_ERROR_ID_QUERY_FAILED),
		new CIviCDriverErrorInfo(E_IVI_RESET_FAILED, AG34980A_ERROR_RESET_FAILED),
		new CIviCDriverErrorInfo(E_IVI_RESOURCE_UNKNOWN, AG34980A_ERROR_RESOURCE_UNKNOWN),
		new CIviCDriverErrorInfo(E_IVI_ALREADY_INITIALIZED, AG34980A_ERROR_ALREADY_INITIALIZED),
		new CIviCDriverErrorInfo(E_IVI_CANNOT_CHANGE_SIMULATION_STATE, AG34980A_ERROR_CANNOT_CHANGE_SIMULATION_STATE),
		new CIviCDriverErrorInfo(E_IVI_INVALID_NUMBER_OF_LEVELS_IN_SELECTOR, AG34980A_ERROR_INVALID_NUMBER_OF_LEVELS_IN_SELECTOR),
		new CIviCDriverErrorInfo(E_IVI_INVALID_RANGE_IN_SELECTOR, AG34980A_ERROR_INVALID_RANGE_IN_SELECTOR),
		new CIviCDriverErrorInfo(E_IVI_UNKNOWN_NAME_IN_SELECTOR, AG34980A_ERROR_UNKOWN_NAME_IN_SELECTOR),
		new CIviCDriverErrorInfo(E_IVI_BADLY_FORMED_SELECTOR, AG34980A_ERROR_BADLY_FORMED_SELECTOR),
		new CIviCDriverErrorInfo(E_IVI_UNKNOWN_PHYSICAL_IDENTIFIER, AG34980A_ERROR_UNKNOWN_PHYSICAL_IDENTIFIER),
		new CIviCDriverErrorInfo(E_AGILENT34951A_UNEXPECTED, AG34980A_ERRORAGILENT34951A_UNEXPECTED),
		new CIviCDriverErrorInfo(E_AGILENT34951A_PERSONALITY_NOT_ACTIVE, AG34980A_ERRORAGILENT34951A_PERSONALITY_NOT_ACTIVE),
		new CIviCDriverErrorInfo(E_AGILENT34951A_PERSONALITY_NOT_INSTALLED, AG34980A_ERRORAGILENT34951A_PERSONALITY_NOT_INSTALLED),
		new CIviCDriverErrorInfo(E_AGILENT34951A_PERSONALITY_NOT_LICENSED, AG34980A_ERRORAGILENT34951A_PERSONALITY_NOT_LICENSED),
		new CIviCDriverErrorInfo(E_AGILENT34951A_IO_GENERAL, AG34980A_ERRORAGILENT34951A_IO_GENERAL),
		new CIviCDriverErrorInfo(E_AGILENT34951A_IO_TIMEOUT, AG34980A_ERRORAGILENT34951A_IO_TIMEOUT),
		new CIviCDriverErrorInfo(E_AGILENT34951A_MODEL_NOT_SUPPORTED, AG34980A_ERRORAGILENT34951A_MODEL_NOT_SUPPORTED),
		new CIviCDriverErrorInfo(E_AGILENT34951A_VALUE_OUT_OF_RANGE, AG34980A_ERRORAGILENT34951A_VALUE_OUT_OF_RANGE),
		new CIviCDriverErrorInfo(E_AGILENT34951A_WRAPPED_DRIVER_ERROR, AG34980A_ERRORAGILENT34951A_WRAPPED_DRIVER_ERROR),
		NULL);

	return &_errorMap;
}
const CIviCErrorMap* GetIviCDriverErrorMapAgilent34952A()
{
	static const CIviCErrorMap _errorMap(
		new CIviCDriverErrorInfo(S_IVI_SUCCESS, AG34980A_SUCCESS),
		new CIviCDriverErrorInfo(S_IVI_NSUP_ID_QUERY, AG34980A_WARN_NSUP_ID_QUERY),
		new CIviCDriverErrorInfo(S_IVI_NSUP_RESET, AG34980A_WARN_NSUP_RESET),
		new CIviCDriverErrorInfo(S_IVI_NSUP_SELF_TEST, AG34980A_WARN_NSUP_SELF_TEST),
		new CIviCDriverErrorInfo(S_IVI_NSUP_ERROR_QUERY, AG34980A_WARN_NSUP_ERROR_QUERY),
		new CIviCDriverErrorInfo(S_IVI_NSUP_REV_QUERY, AG34980A_WARN_NSUP_REV_QUERY),
		new CIviCDriverErrorInfo(E_IVI_CANNOT_RECOVER, AG34980A_ERROR_CANNOT_RECOVER),
		new CIviCDriverErrorInfo(E_IVI_INSTRUMENT_STATUS, AG34980A_ERROR_INSTRUMENT_STATUS),
		new CIviCDriverErrorInfo(E_IVI_CANNOT_OPEN_FILE, AG34980A_ERROR_CANNOT_OPEN_FILE),
		new CIviCDriverErrorInfo(E_IVI_READING_FILE, AG34980A_ERROR_READING_FILE),
		new CIviCDriverErrorInfo(E_IVI_WRITING_FILE, AG34980A_ERROR_WRITING_FILE),
		new CIviCDriverErrorInfo(E_IVI_INVALID_PATHNAME, AG34980A_ERROR_INVALID_PATHNAME),
		new CIviCDriverErrorInfo(E_IVI_INVALID_VALUE, AG34980A_ERROR_INVALID_VALUE),
		new CIviCDriverErrorInfo(E_IVI_METHOD_NOT_SUPPORTED, AG34980A_ERROR_FUNCTION_NOT_SUPPORTED),
		new CIviCDriverErrorInfo(E_IVI_PROPERTY_NOT_SUPPORTED, AG34980A_ERROR_ATTRIBUTE_NOT_SUPPORTED),
		new CIviCDriverErrorInfo(E_IVI_VALUE_NOT_SUPPORTED, AG34980A_ERROR_VALUE_NOT_SUPPORTED),
		new CIviCDriverErrorInfo(E_IVI_NOT_INITIALIZED, AG34980A_ERROR_NOT_INITIALIZED),
		new CIviCDriverErrorInfo(E_IVI_UNKNOWN_CHANNEL_NAME, AG34980A_ERROR_UNKNOWN_CHANNEL_NAME),
		new CIviCDriverErrorInfo(E_IVI_TOO_MANY_OPEN_FILES, AG34980A_ERROR_TOO_MANY_OPEN_FILES),
		new CIviCDriverErrorInfo(E_IVI_CHANNEL_NAME_REQUIRED, AG34980A_ERROR_CHANNEL_NAME_REQUIRED),
		new CIviCDriverErrorInfo(E_IVI_MISSING_OPTION_NAME, AG34980A_ERROR_MISSING_OPTION_NAME),
		new CIviCDriverErrorInfo(E_IVI_MISSING_OPTION_VALUE, AG34980A_ERROR_MISSING_OPTION_VALUE),
		new CIviCDriverErrorInfo(E_IVI_BAD_OPTION_NAME, AG34980A_ERROR_BAD_OPTION_NAME),
		new CIviCDriverErrorInfo(E_IVI_BAD_OPTION_VALUE, AG34980A_ERROR_BAD_OPTION_VALUE),
		new CIviCDriverErrorInfo(E_IVI_OUT_OF_MEMORY, AG34980A_ERROR_OUT_OF_MEMORY),
		new CIviCDriverErrorInfo(E_IVI_OPERATION_PENDING, AG34980A_ERROR_OPERATION_PENDING),
		new CIviCDriverErrorInfo(E_IVI_NULL_POINTER, AG34980A_ERROR_NULL_POINTER),
		new CIviCDriverErrorInfo(E_IVI_UNEXPECTED_RESPONSE, AG34980A_ERROR_UNEXPECTED_RESPONSE),
		new CIviCDriverErrorInfo(E_IVI_FILE_NOT_FOUND, AG34980A_ERROR_FILE_NOT_FOUND),
		new CIviCDriverErrorInfo(E_IVI_INVALID_FILE_FORMAT, AG34980A_ERROR_INVALID_FILE_FORMAT),
		new CIviCDriverErrorInfo(E_IVI_STATUS_NOT_AVAILABLE, AG34980A_ERROR_STATUS_NOT_AVAILABLE),
		new CIviCDriverErrorInfo(E_IVI_ID_QUERY_FAILED, AG34980A_ERROR_ID_QUERY_FAILED),
		new CIviCDriverErrorInfo(E_IVI_RESET_FAILED, AG34980A_ERROR_RESET_FAILED),
		new CIviCDriverErrorInfo(E_IVI_RESOURCE_UNKNOWN, AG34980A_ERROR_RESOURCE_UNKNOWN),
		new CIviCDriverErrorInfo(E_IVI_ALREADY_INITIALIZED, AG34980A_ERROR_ALREADY_INITIALIZED),
		new CIviCDriverErrorInfo(E_IVI_CANNOT_CHANGE_SIMULATION_STATE, AG34980A_ERROR_CANNOT_CHANGE_SIMULATION_STATE),
		new CIviCDriverErrorInfo(E_IVI_INVALID_NUMBER_OF_LEVELS_IN_SELECTOR, AG34980A_ERROR_INVALID_NUMBER_OF_LEVELS_IN_SELECTOR),
		new CIviCDriverErrorInfo(E_IVI_INVALID_RANGE_IN_SELECTOR, AG34980A_ERROR_INVALID_RANGE_IN_SELECTOR),
		new CIviCDriverErrorInfo(E_IVI_UNKNOWN_NAME_IN_SELECTOR, AG34980A_ERROR_UNKOWN_NAME_IN_SELECTOR),
		new CIviCDriverErrorInfo(E_IVI_BADLY_FORMED_SELECTOR, AG34980A_ERROR_BADLY_FORMED_SELECTOR),
		new CIviCDriverErrorInfo(E_IVI_UNKNOWN_PHYSICAL_IDENTIFIER, AG34980A_ERROR_UNKNOWN_PHYSICAL_IDENTIFIER),
		new CIviCDriverErrorInfo(E_AGILENT34952A_UNEXPECTED, AG34980A_ERRORAGILENT34952A_UNEXPECTED),
		new CIviCDriverErrorInfo(E_AGILENT34952A_PERSONALITY_NOT_ACTIVE, AG34980A_ERRORAGILENT34952A_PERSONALITY_NOT_ACTIVE),
		new CIviCDriverErrorInfo(E_AGILENT34952A_PERSONALITY_NOT_INSTALLED, AG34980A_ERRORAGILENT34952A_PERSONALITY_NOT_INSTALLED),
		new CIviCDriverErrorInfo(E_AGILENT34952A_PERSONALITY_NOT_LICENSED, AG34980A_ERRORAGILENT34952A_PERSONALITY_NOT_LICENSED),
		new CIviCDriverErrorInfo(E_AGILENT34952A_IO_GENERAL, AG34980A_ERRORAGILENT34952A_IO_GENERAL),
		new CIviCDriverErrorInfo(E_AGILENT34952A_IO_TIMEOUT, AG34980A_ERRORAGILENT34952A_IO_TIMEOUT),
		new CIviCDriverErrorInfo(E_AGILENT34952A_MODEL_NOT_SUPPORTED, AG34980A_ERRORAGILENT34952A_MODEL_NOT_SUPPORTED),
		new CIviCDriverErrorInfo(E_AGILENT34952A_VALUE_OUT_OF_RANGE, AG34980A_ERRORAGILENT34952A_VALUE_OUT_OF_RANGE),
		new CIviCDriverErrorInfo(E_AGILENT34952A_WRAPPED_DRIVER_ERROR, AG34980A_ERRORAGILENT34952A_WRAPPED_DRIVER_ERROR),
		NULL);

	return &_errorMap;
}
const CIviCErrorMap* GetIviCDriverErrorMapAgilent34945A()
{
	static const CIviCErrorMap _errorMap(
		new CIviCDriverErrorInfo(S_IVI_SUCCESS, AG34980A_SUCCESS),
		new CIviCDriverErrorInfo(S_IVI_NSUP_ID_QUERY, AG34980A_WARN_NSUP_ID_QUERY),
		new CIviCDriverErrorInfo(S_IVI_NSUP_RESET, AG34980A_WARN_NSUP_RESET),
		new CIviCDriverErrorInfo(S_IVI_NSUP_SELF_TEST, AG34980A_WARN_NSUP_SELF_TEST),
		new CIviCDriverErrorInfo(S_IVI_NSUP_ERROR_QUERY, AG34980A_WARN_NSUP_ERROR_QUERY),
		new CIviCDriverErrorInfo(S_IVI_NSUP_REV_QUERY, AG34980A_WARN_NSUP_REV_QUERY),
		new CIviCDriverErrorInfo(E_IVI_CANNOT_RECOVER, AG34980A_ERROR_CANNOT_RECOVER),
		new CIviCDriverErrorInfo(E_IVI_INSTRUMENT_STATUS, AG34980A_ERROR_INSTRUMENT_STATUS),
		new CIviCDriverErrorInfo(E_IVI_CANNOT_OPEN_FILE, AG34980A_ERROR_CANNOT_OPEN_FILE),
		new CIviCDriverErrorInfo(E_IVI_READING_FILE, AG34980A_ERROR_READING_FILE),
		new CIviCDriverErrorInfo(E_IVI_WRITING_FILE, AG34980A_ERROR_WRITING_FILE),
		new CIviCDriverErrorInfo(E_IVI_INVALID_PATHNAME, AG34980A_ERROR_INVALID_PATHNAME),
		new CIviCDriverErrorInfo(E_IVI_INVALID_VALUE, AG34980A_ERROR_INVALID_VALUE),
		new CIviCDriverErrorInfo(E_IVI_METHOD_NOT_SUPPORTED, AG34980A_ERROR_FUNCTION_NOT_SUPPORTED),
		new CIviCDriverErrorInfo(E_IVI_PROPERTY_NOT_SUPPORTED, AG34980A_ERROR_ATTRIBUTE_NOT_SUPPORTED),
		new CIviCDriverErrorInfo(E_IVI_VALUE_NOT_SUPPORTED, AG34980A_ERROR_VALUE_NOT_SUPPORTED),
		new CIviCDriverErrorInfo(E_IVI_NOT_INITIALIZED, AG34980A_ERROR_NOT_INITIALIZED),
		new CIviCDriverErrorInfo(E_IVI_UNKNOWN_CHANNEL_NAME, AG34980A_ERROR_UNKNOWN_CHANNEL_NAME),
		new CIviCDriverErrorInfo(E_IVI_TOO_MANY_OPEN_FILES, AG34980A_ERROR_TOO_MANY_OPEN_FILES),
		new CIviCDriverErrorInfo(E_IVI_CHANNEL_NAME_REQUIRED, AG34980A_ERROR_CHANNEL_NAME_REQUIRED),
		new CIviCDriverErrorInfo(E_IVI_MISSING_OPTION_NAME, AG34980A_ERROR_MISSING_OPTION_NAME),
		new CIviCDriverErrorInfo(E_IVI_MISSING_OPTION_VALUE, AG34980A_ERROR_MISSING_OPTION_VALUE),
		new CIviCDriverErrorInfo(E_IVI_BAD_OPTION_NAME, AG34980A_ERROR_BAD_OPTION_NAME),
		new CIviCDriverErrorInfo(E_IVI_BAD_OPTION_VALUE, AG34980A_ERROR_BAD_OPTION_VALUE),
		new CIviCDriverErrorInfo(E_IVI_OUT_OF_MEMORY, AG34980A_ERROR_OUT_OF_MEMORY),
		new CIviCDriverErrorInfo(E_IVI_OPERATION_PENDING, AG34980A_ERROR_OPERATION_PENDING),
		new CIviCDriverErrorInfo(E_IVI_NULL_POINTER, AG34980A_ERROR_NULL_POINTER),
		new CIviCDriverErrorInfo(E_IVI_UNEXPECTED_RESPONSE, AG34980A_ERROR_UNEXPECTED_RESPONSE),
		new CIviCDriverErrorInfo(E_IVI_FILE_NOT_FOUND, AG34980A_ERROR_FILE_NOT_FOUND),
		new CIviCDriverErrorInfo(E_IVI_INVALID_FILE_FORMAT, AG34980A_ERROR_INVALID_FILE_FORMAT),
		new CIviCDriverErrorInfo(E_IVI_STATUS_NOT_AVAILABLE, AG34980A_ERROR_STATUS_NOT_AVAILABLE),
		new CIviCDriverErrorInfo(E_IVI_ID_QUERY_FAILED, AG34980A_ERROR_ID_QUERY_FAILED),
		new CIviCDriverErrorInfo(E_IVI_RESET_FAILED, AG34980A_ERROR_RESET_FAILED),
		new CIviCDriverErrorInfo(E_IVI_RESOURCE_UNKNOWN, AG34980A_ERROR_RESOURCE_UNKNOWN),
		new CIviCDriverErrorInfo(E_IVI_ALREADY_INITIALIZED, AG34980A_ERROR_ALREADY_INITIALIZED),
		new CIviCDriverErrorInfo(E_IVI_CANNOT_CHANGE_SIMULATION_STATE, AG34980A_ERROR_CANNOT_CHANGE_SIMULATION_STATE),
		new CIviCDriverErrorInfo(E_IVI_INVALID_NUMBER_OF_LEVELS_IN_SELECTOR, AG34980A_ERROR_INVALID_NUMBER_OF_LEVELS_IN_SELECTOR),
		new CIviCDriverErrorInfo(E_IVI_INVALID_RANGE_IN_SELECTOR, AG34980A_ERROR_INVALID_RANGE_IN_SELECTOR),
		new CIviCDriverErrorInfo(E_IVI_UNKNOWN_NAME_IN_SELECTOR, AG34980A_ERROR_UNKOWN_NAME_IN_SELECTOR),
		new CIviCDriverErrorInfo(E_IVI_BADLY_FORMED_SELECTOR, AG34980A_ERROR_BADLY_FORMED_SELECTOR),
		new CIviCDriverErrorInfo(E_IVI_UNKNOWN_PHYSICAL_IDENTIFIER, AG34980A_ERROR_UNKNOWN_PHYSICAL_IDENTIFIER),
		new CIviCDriverErrorInfo(E_AGILENT34945A_UNEXPECTED, AG34980A_ERRORAGILENT34945A_UNEXPECTED),
		new CIviCDriverErrorInfo(E_AGILENT34945A_PERSONALITY_NOT_ACTIVE, AG34980A_ERRORAGILENT34945A_PERSONALITY_NOT_ACTIVE),
		new CIviCDriverErrorInfo(E_AGILENT34945A_PERSONALITY_NOT_INSTALLED, AG34980A_ERRORAGILENT34945A_PERSONALITY_NOT_INSTALLED),
		new CIviCDriverErrorInfo(E_AGILENT34945A_PERSONALITY_NOT_LICENSED, AG34980A_ERRORAGILENT34945A_PERSONALITY_NOT_LICENSED),
		new CIviCDriverErrorInfo(E_AGILENT34945A_IO_GENERAL, AG34980A_ERRORAGILENT34945A_IO_GENERAL),
		new CIviCDriverErrorInfo(E_AGILENT34945A_IO_TIMEOUT, AG34980A_ERRORAGILENT34945A_IO_TIMEOUT),
		new CIviCDriverErrorInfo(E_AGILENT34945A_MODEL_NOT_SUPPORTED, AG34980A_ERRORAGILENT34945A_MODEL_NOT_SUPPORTED),
		new CIviCDriverErrorInfo(E_AGILENT34945A_VALUE_OUT_OF_RANGE, AG34980A_ERRORAGILENT34945A_VALUE_OUT_OF_RANGE),
		new CIviCDriverErrorInfo(E_AGILENT34945A_WRAPPED_DRIVER_ERROR, AG34980A_ERRORAGILENT34945A_WRAPPED_DRIVER_ERROR),
		new CIviCDriverErrorInfo(E_AGILENT34945A_MULTIPLE_CHANNELS_IN_GET, AG34980A_ERRORAGILENT34945A_MULTIPLE_CHANNELS_IN_GET),
		NULL);

	return &_errorMap;
}
const CIviCErrorMap* GetIviCDriverErrorMapAgilent34959A()
{
	static const CIviCErrorMap _errorMap(
		new CIviCDriverErrorInfo(S_IVI_SUCCESS, AG34980A_SUCCESS),
		new CIviCDriverErrorInfo(S_IVI_NSUP_ID_QUERY, AG34980A_WARN_NSUP_ID_QUERY),
		new CIviCDriverErrorInfo(S_IVI_NSUP_RESET, AG34980A_WARN_NSUP_RESET),
		new CIviCDriverErrorInfo(S_IVI_NSUP_SELF_TEST, AG34980A_WARN_NSUP_SELF_TEST),
		new CIviCDriverErrorInfo(S_IVI_NSUP_ERROR_QUERY, AG34980A_WARN_NSUP_ERROR_QUERY),
		new CIviCDriverErrorInfo(S_IVI_NSUP_REV_QUERY, AG34980A_WARN_NSUP_REV_QUERY),
		new CIviCDriverErrorInfo(E_IVI_CANNOT_RECOVER, AG34980A_ERROR_CANNOT_RECOVER),
		new CIviCDriverErrorInfo(E_IVI_INSTRUMENT_STATUS, AG34980A_ERROR_INSTRUMENT_STATUS),
		new CIviCDriverErrorInfo(E_IVI_CANNOT_OPEN_FILE, AG34980A_ERROR_CANNOT_OPEN_FILE),
		new CIviCDriverErrorInfo(E_IVI_READING_FILE, AG34980A_ERROR_READING_FILE),
		new CIviCDriverErrorInfo(E_IVI_WRITING_FILE, AG34980A_ERROR_WRITING_FILE),
		new CIviCDriverErrorInfo(E_IVI_INVALID_PATHNAME, AG34980A_ERROR_INVALID_PATHNAME),
		new CIviCDriverErrorInfo(E_IVI_INVALID_VALUE, AG34980A_ERROR_INVALID_VALUE),
		new CIviCDriverErrorInfo(E_IVI_METHOD_NOT_SUPPORTED, AG34980A_ERROR_FUNCTION_NOT_SUPPORTED),
		new CIviCDriverErrorInfo(E_IVI_PROPERTY_NOT_SUPPORTED, AG34980A_ERROR_ATTRIBUTE_NOT_SUPPORTED),
		new CIviCDriverErrorInfo(E_IVI_VALUE_NOT_SUPPORTED, AG34980A_ERROR_VALUE_NOT_SUPPORTED),
		new CIviCDriverErrorInfo(E_IVI_NOT_INITIALIZED, AG34980A_ERROR_NOT_INITIALIZED),
		new CIviCDriverErrorInfo(E_IVI_UNKNOWN_CHANNEL_NAME, AG34980A_ERROR_UNKNOWN_CHANNEL_NAME),
		new CIviCDriverErrorInfo(E_IVI_TOO_MANY_OPEN_FILES, AG34980A_ERROR_TOO_MANY_OPEN_FILES),
		new CIviCDriverErrorInfo(E_IVI_CHANNEL_NAME_REQUIRED, AG34980A_ERROR_CHANNEL_NAME_REQUIRED),
		new CIviCDriverErrorInfo(E_IVI_MISSING_OPTION_NAME, AG34980A_ERROR_MISSING_OPTION_NAME),
		new CIviCDriverErrorInfo(E_IVI_MISSING_OPTION_VALUE, AG34980A_ERROR_MISSING_OPTION_VALUE),
		new CIviCDriverErrorInfo(E_IVI_BAD_OPTION_NAME, AG34980A_ERROR_BAD_OPTION_NAME),
		new CIviCDriverErrorInfo(E_IVI_BAD_OPTION_VALUE, AG34980A_ERROR_BAD_OPTION_VALUE),
		new CIviCDriverErrorInfo(E_IVI_OUT_OF_MEMORY, AG34980A_ERROR_OUT_OF_MEMORY),
		new CIviCDriverErrorInfo(E_IVI_OPERATION_PENDING, AG34980A_ERROR_OPERATION_PENDING),
		new CIviCDriverErrorInfo(E_IVI_NULL_POINTER, AG34980A_ERROR_NULL_POINTER),
		new CIviCDriverErrorInfo(E_IVI_UNEXPECTED_RESPONSE, AG34980A_ERROR_UNEXPECTED_RESPONSE),
		new CIviCDriverErrorInfo(E_IVI_FILE_NOT_FOUND, AG34980A_ERROR_FILE_NOT_FOUND),
		new CIviCDriverErrorInfo(E_IVI_INVALID_FILE_FORMAT, AG34980A_ERROR_INVALID_FILE_FORMAT),
		new CIviCDriverErrorInfo(E_IVI_STATUS_NOT_AVAILABLE, AG34980A_ERROR_STATUS_NOT_AVAILABLE),
		new CIviCDriverErrorInfo(E_IVI_ID_QUERY_FAILED, AG34980A_ERROR_ID_QUERY_FAILED),
		new CIviCDriverErrorInfo(E_IVI_RESET_FAILED, AG34980A_ERROR_RESET_FAILED),
		new CIviCDriverErrorInfo(E_IVI_RESOURCE_UNKNOWN, AG34980A_ERROR_RESOURCE_UNKNOWN),
		new CIviCDriverErrorInfo(E_IVI_ALREADY_INITIALIZED, AG34980A_ERROR_ALREADY_INITIALIZED),
		new CIviCDriverErrorInfo(E_IVI_CANNOT_CHANGE_SIMULATION_STATE, AG34980A_ERROR_CANNOT_CHANGE_SIMULATION_STATE),
		new CIviCDriverErrorInfo(E_IVI_INVALID_NUMBER_OF_LEVELS_IN_SELECTOR, AG34980A_ERROR_INVALID_NUMBER_OF_LEVELS_IN_SELECTOR),
		new CIviCDriverErrorInfo(E_IVI_INVALID_RANGE_IN_SELECTOR, AG34980A_ERROR_INVALID_RANGE_IN_SELECTOR),
		new CIviCDriverErrorInfo(E_IVI_UNKNOWN_NAME_IN_SELECTOR, AG34980A_ERROR_UNKOWN_NAME_IN_SELECTOR),
		new CIviCDriverErrorInfo(E_IVI_BADLY_FORMED_SELECTOR, AG34980A_ERROR_BADLY_FORMED_SELECTOR),
		new CIviCDriverErrorInfo(E_IVI_UNKNOWN_PHYSICAL_IDENTIFIER, AG34980A_ERROR_UNKNOWN_PHYSICAL_IDENTIFIER),
		new CIviCDriverErrorInfo(E_AGILENT34959A_UNEXPECTED, AG34980A_ERRORAGILENT34959A_UNEXPECTED),
		new CIviCDriverErrorInfo(E_AGILENT34959A_PERSONALITY_NOT_ACTIVE, AG34980A_ERRORAGILENT34959A_PERSONALITY_NOT_ACTIVE),
		new CIviCDriverErrorInfo(E_AGILENT34959A_PERSONALITY_NOT_INSTALLED, AG34980A_ERRORAGILENT34959A_PERSONALITY_NOT_INSTALLED),
		new CIviCDriverErrorInfo(E_AGILENT34959A_PERSONALITY_NOT_LICENSED, AG34980A_ERRORAGILENT34959A_PERSONALITY_NOT_LICENSED),
		new CIviCDriverErrorInfo(E_AGILENT34959A_IO_GENERAL, AG34980A_ERRORAGILENT34959A_IO_GENERAL),
		new CIviCDriverErrorInfo(E_AGILENT34959A_IO_TIMEOUT, AG34980A_ERRORAGILENT34959A_IO_TIMEOUT),
		new CIviCDriverErrorInfo(E_AGILENT34959A_MODEL_NOT_SUPPORTED, AG34980A_ERRORAGILENT34959A_MODEL_NOT_SUPPORTED),
		new CIviCDriverErrorInfo(E_AGILENT34959A_VALUE_OUT_OF_RANGE, AG34980A_ERRORAGILENT34959A_VALUE_OUT_OF_RANGE),
		new CIviCDriverErrorInfo(E_AGILENT34959A_WRAPPED_DRIVER_ERROR, AG34980A_ERRORAGILENT34959A_WRAPPED_DRIVER_ERROR),
		NULL);

	return &_errorMap;
}

ViStatus TranslateHRESULT(ViSession session, HRESULT hr)
{
	ViStatus error = VI_SUCCESS;
	
	const CIviCDriverErrorInfo* pIviCErrorInfo = NULL;
	if (GetIviCDriverErrorMap()->GetErrorMap()->Lookup(hr, pIviCErrorInfo))
	{
		error = pIviCErrorInfo->GetStatus();
	}
	else
	{
		if (FAILED(hr))
		{
			// Internal error?
			error = _VI_ERROR;
		}
	}

	return SetErrorUsingComErrorInfoDescription(session, error);
}
ViStatus TranslateHRESULTAgilent34950A(ViSession session, HRESULT hr)
{
	ViStatus error = VI_SUCCESS;
	
	const CIviCDriverErrorInfo* pIviCErrorInfo = NULL;
	if (GetIviCDriverErrorMapAgilent34950A()->GetErrorMap()->Lookup(hr, pIviCErrorInfo))
	{
		error = pIviCErrorInfo->GetStatus();
	}
	else
	{
		if (FAILED(hr))
		{
			// Internal error?
			error = _VI_ERROR;
		}
	}

	return SetErrorUsingComErrorInfoDescription(session, error);
}
ViStatus TranslateHRESULTAgilent34951A(ViSession session, HRESULT hr)
{
	ViStatus error = VI_SUCCESS;
	
	const CIviCDriverErrorInfo* pIviCErrorInfo = NULL;
	if (GetIviCDriverErrorMapAgilent34951A()->GetErrorMap()->Lookup(hr, pIviCErrorInfo))
	{
		error = pIviCErrorInfo->GetStatus();
	}
	else
	{
		if (FAILED(hr))
		{
			// Internal error?
			error = _VI_ERROR;
		}
	}

	return SetErrorUsingComErrorInfoDescription(session, error);
}
ViStatus TranslateHRESULTAgilent34952A(ViSession session, HRESULT hr)
{
	ViStatus error = VI_SUCCESS;
	
	const CIviCDriverErrorInfo* pIviCErrorInfo = NULL;
	if (GetIviCDriverErrorMapAgilent34952A()->GetErrorMap()->Lookup(hr, pIviCErrorInfo))
	{
		error = pIviCErrorInfo->GetStatus();
	}
	else
	{
		if (FAILED(hr))
		{
			// Internal error?
			error = _VI_ERROR;
		}
	}

	return SetErrorUsingComErrorInfoDescription(session, error);
}
ViStatus TranslateHRESULTAgilent34945A(ViSession session, HRESULT hr)
{
	ViStatus error = VI_SUCCESS;
	
	const CIviCDriverErrorInfo* pIviCErrorInfo = NULL;
	if (GetIviCDriverErrorMapAgilent34945A()->GetErrorMap()->Lookup(hr, pIviCErrorInfo))
	{
		error = pIviCErrorInfo->GetStatus();
	}
	else
	{
		if (FAILED(hr))
		{
			// Internal error?
			error = _VI_ERROR;
		}
	}

	return SetErrorUsingComErrorInfoDescription(session, error);
}
ViStatus TranslateHRESULTAgilent34959A(ViSession session, HRESULT hr)
{
	ViStatus error = VI_SUCCESS;
	
	const CIviCDriverErrorInfo* pIviCErrorInfo = NULL;
	if (GetIviCDriverErrorMapAgilent34959A()->GetErrorMap()->Lookup(hr, pIviCErrorInfo))
	{
		error = pIviCErrorInfo->GetStatus();
	}
	else
	{
		if (FAILED(hr))
		{
			// Internal error?
			error = _VI_ERROR;
		}
	}

	return SetErrorUsingComErrorInfoDescription(session, error);
}

