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

#ifndef __INTERFACES_NIMBUS_H__
#define __INTERFACES_NIMBUS_H__

#include "HelpContextIds.nimbus.h"
#include <winerror.h>

[
	export, 
	library_block, 
	uuid("64b51280-98fe-43d5-a3b7-d23a81e25582"),
	v1_enum
]
enum Agilent34980AErrorCodesEnum
{
	E_AGILENT34980A_UNEXPECTED = 0x80044210,
	E_AGILENT34980A_PERSONALITY_NOT_ACTIVE = 0x80044211,
	E_AGILENT34980A_PERSONALITY_NOT_INSTALLED = 0x80044212,
	E_AGILENT34980A_PERSONALITY_NOT_LICENSED = 0x80044213,
	E_AGILENT34980A_IO_GENERAL = 0x80044214,
	E_AGILENT34980A_IO_TIMEOUT = 0x80044215,
	E_AGILENT34980A_MODEL_NOT_SUPPORTED = 0x80044216,
	E_AGILENT34980A_VALUE_OUT_OF_RANGE = 0x80044217,
	E_AGILENT34980A_WRAPPED_DRIVER_ERROR = 0x80044218,
	E_AGILENT34980A_LOCATIONS_BUSY = 0x80044002,
	E_AGILENT34980A_MULTIPLE_CHANNELS_IN_GET = 0x80044096,
	E_AGILENT34980A_MISSING_DMM_OPTION = 0x80044003,
	E_AGILENT34980A_BAD_SIMULATION_OPTION = 0x80044004,
	E_AGILENT34980A_MISSING_SIMULATION_OPTION = 0x80044005
};


__interface IAgilent34980A;
[idl_quote("interface IAgilent34980A;")];

__interface IAgilent34980AACCurrent;
[idl_quote("interface IAgilent34980AACCurrent;")];

__interface IAgilent34980AACVoltage;
[idl_quote("interface IAgilent34980AACVoltage;")];

__interface IAgilent34980AAlarm;
[idl_quote("interface IAgilent34980AAlarm;")];

__interface IAgilent34980ACalibration;
[idl_quote("interface IAgilent34980ACalibration;")];

__interface IAgilent34980ACurrent;
[idl_quote("interface IAgilent34980ACurrent;")];

__interface IAgilent34980ADAC;
[idl_quote("interface IAgilent34980ADAC;")];

__interface IAgilent34980ADCCurrent;
[idl_quote("interface IAgilent34980ADCCurrent;")];

__interface IAgilent34980ADCVoltage;
[idl_quote("interface IAgilent34980ADCVoltage;")];

__interface IAgilent34980ADMM;
[idl_quote("interface IAgilent34980ADMM;")];

__interface IAgilent34980ADataFormat;
[idl_quote("interface IAgilent34980ADataFormat;")];

__interface IAgilent34980ADiagnostic;
[idl_quote("interface IAgilent34980ADiagnostic;")];

__interface IAgilent34980ADisplay;
[idl_quote("interface IAgilent34980ADisplay;")];

__interface IAgilent34980AFRTD;
[idl_quote("interface IAgilent34980AFRTD;")];

__interface IAgilent34980AFResistance;
[idl_quote("interface IAgilent34980AFResistance;")];

__interface IAgilent34980AFrequency;
[idl_quote("interface IAgilent34980AFrequency;")];

__interface IAgilent34980AMeasurement;
[idl_quote("interface IAgilent34980AMeasurement;")];

__interface IAgilent34980AMemory;
[idl_quote("interface IAgilent34980AMemory;")];

__interface IAgilent34980APeriod;
[idl_quote("interface IAgilent34980APeriod;")];

__interface IAgilent34980APersonality;
[idl_quote("interface IAgilent34980APersonality;")];

__interface IAgilent34980ARTD;
[idl_quote("interface IAgilent34980ARTD;")];

__interface IAgilent34980AResistance;
[idl_quote("interface IAgilent34980AResistance;")];

__interface IAgilent34980ARoute;
[idl_quote("interface IAgilent34980ARoute;")];

__interface IAgilent34980AScale;
[idl_quote("interface IAgilent34980AScale;")];

__interface IAgilent34980AScan;
[idl_quote("interface IAgilent34980AScan;")];

__interface IAgilent34980AStatistics;
[idl_quote("interface IAgilent34980AStatistics;")];

__interface IAgilent34980AStatus;
[idl_quote("interface IAgilent34980AStatus;")];

__interface IAgilent34980ASystem;
[idl_quote("interface IAgilent34980ASystem;")];

__interface IAgilent34980ATemperature;
[idl_quote("interface IAgilent34980ATemperature;")];

__interface IAgilent34980AThermistor;
[idl_quote("interface IAgilent34980AThermistor;")];

__interface IAgilent34980AThermocouple;
[idl_quote("interface IAgilent34980AThermocouple;")];

__interface IAgilent34980ATrigger;
[idl_quote("interface IAgilent34980ATrigger;")];

__interface IAgilent34980AVoltage;
[idl_quote("interface IAgilent34980AVoltage;")];

__interface IAgilent34980AAlarm2;
[idl_quote("interface IAgilent34980AAlarm2;")];

__interface IAgilent34980A2;
[idl_quote("interface IAgilent34980A2;")];

__interface IAgilent34980ARoute2;
[idl_quote("interface IAgilent34980ARoute2;")];

__interface IAgilent34980AStatus2;
[idl_quote("interface IAgilent34980AStatus2;")];


[
	export, 
	library_block, 
	uuid("9b47c400-64c4-42a9-8443-0dd15395ff94"),
	v1_enum, 
	helpstring("Enumeration for the alarm modes."), 
	helpcontext(HID_AGILENT34980AALARMMODEENUM)
]
enum Agilent34980AAlarmModeEnum
{
	Agilent34980AAlarmModeLatch = 0,
	Agilent34980AAlarmModeTrack = 1
};

[
	export, 
	library_block, 
	uuid("b5b87fb9-cd34-477c-b8d8-1fc16eb9abbd"),
	v1_enum, 
	helpstring("Enumeration for the auto zero mode."), 
	helpcontext(HID_AGILENT34980AAUTOZEROENUM)
]
enum Agilent34980AAutoZeroEnum
{
	Agilent34980AAutoZeroOFF = 0,
	Agilent34980AAutoZeroONCE = 1,
	Agilent34980AAutoZeroON = 2
};

[
	export, 
	library_block, 
	uuid("ebd227d8-4723-472f-8646-1e5520b6209a"),
	v1_enum, 
	helpstring("Enumeration for the alpha type."), 
	helpcontext(HID_AGILENT34980AFRTDALPHAENUM)
]
enum Agilent34980AFRTDAlphaEnum
{
	Agilent34980AFRTDAlpha85 = 85,
	Agilent34980AFRTDAlpha91 = 91
};

[
	export, 
	library_block, 
	uuid("6fb2154a-45df-4715-8428-6379689e24c1"),
	v1_enum, 
	helpstring("Enumeration for the interface used to communicate with the instrument."), 
	helpcontext(HID_AGILENT34980AHWINTERFACEENUM)
]
enum Agilent34980AHWInterfaceEnum
{
	Agilent34980AHWInterfaceGPIB = 0,
	Agilent34980AHWInterfaceUsb = 1,
	Agilent34980AHWInterfaceLan = 2,
	Agilent34980AHWInterfaceSockets = 3,
	Agilent34980AHWInterfaceTelnet = 4,
	Agilent34980AHWInterfaceVXI11 = 5,
	Agilent34980AHWInterfaceWeb = 6
};

[
	export, 
	library_block, 
	uuid("86b3ce7e-1bcd-4a0e-887c-12f765b0178d"),
	v1_enum, 
	helpstring("Enumerates which temperatures to query for."), 
	helpcontext(HID_AGILENT34980AMODULETEMPERATUREENUM)
]
enum Agilent34980AModuleTemperatureEnum
{
	Agilent34980AModuleTemperatureTransducer = 0,
	Agilent34980AModuleTemperatureThreshold = 1
};

[
	export, 
	library_block, 
	uuid("21c2870a-37c1-42de-b303-78e85a561a42"),
	v1_enum, 
	helpstring("Enumeration for the monitoring options."), 
	helpcontext(HID_AGILENT34980AMONITORMODEENUM)
]
enum Agilent34980AMonitorModeEnum
{
	Agilent34980AMonitorModeChannel = 0,
	Agilent34980AMonitorModeDMM = 1
};

[
	export, 
	library_block, 
	uuid("2770ef26-9cfe-463f-a754-7488ad0ba098"),
	v1_enum, 
	helpstring("Enumeration for the reference junction temperature."), 
	helpcontext(HID_AGILENT34980ARJUNCTIONENUM)
]
enum Agilent34980ARJunctionEnum
{
	Agilent34980ARJunctionInternal = 0,
	Agilent34980ARJunctionExternal = 1,
	Agilent34980ARJunctionFixed = 2
};

[
	export, 
	library_block, 
	uuid("f366efc3-026c-4fda-aacf-bbab73453b11"),
	v1_enum, 
	helpstring("Enumeration for the alpha type."), 
	helpcontext(HID_AGILENT34980ARTDALPHAENUM)
]
enum Agilent34980ARTDAlphaEnum
{
	Agilent34980ARTDAlpha85 = 85,
	Agilent34980ARTDAlpha91 = 91
};

[
	export, 
	library_block, 
	uuid("02342f73-2e04-4356-935d-ff0ab8253560"),
	v1_enum, 
	helpstring("Enumerates possible resolutions specified in Configure and Measure methods."), 
	helpcontext(HID_AGILENT34980ARESOLUTIONENUM)
]
enum Agilent34980AResolutionEnum
{
	Agilent34980AResolutionLeast = 0,
	Agilent34980AResolutionDefault = 1,
	Agilent34980AResolutionBest = 2
};

[
	export, 
	library_block, 
	uuid("5d4209bd-e09e-46bd-a720-63eeb6c42bac"),
	v1_enum, 
	helpstring("Enumeration for the Reason parameter of the ConfigureServiceRequest method in the Status interface"), 
	helpcontext(HID_AGILENT34980ASRQREASONENUM)
]
enum Agilent34980ASRQReasonEnum
{
	Agilent34980ASRQReasonStbMAV = 1,
	Agilent34980ASRQReasonStbErrorQue = 2097152,
	Agilent34980ASRQReasonAlarm1 = 2,
	Agilent34980ASRQReasonEsrOPC = 4,
	Agilent34980ASRQReasonEsrQueryError = 8,
	Agilent34980ASRQReasonEsrDeviceError = 16,
	Agilent34980ASRQReasonEsrExecutionError = 32,
	Agilent34980ASRQReasonEsrCommandError = 64,
	Agilent34980ASRQReasonAlarm2 = 128,
	Agilent34980ASRQReasonQuesVoltage = 256,
	Agilent34980ASRQReasonQuesCurrent = 512,
	Agilent34980ASRQReasonAlarm3 = 1024,
	Agilent34980ASRQReasonAlarm4 = 2048,
	Agilent34980ASRQReasonAlarmQEmpty = 4096,
	Agilent34980ASRQReasonQuesResistance = 8192,
	Agilent34980ASRQReasonQuesTemperature = 16384,
	Agilent34980ASRQReasonQuesTotalizer = 32768,
	Agilent34980ASRQReasonQuesMemory = 65536,
	Agilent34980ASRQReasonAlarmQOV = 131072,
	Agilent34980ASRQReasonOperScanning = 262144,
	Agilent34980ASRQReasonOperConfChange = 524288,
	Agilent34980ASRQReasonOperMemThreshold = 1048576
};

[
	export, 
	library_block, 
	uuid("5fa9362a-0a61-4a0a-8ddd-c501b28fca7c"),
	v1_enum, 
	helpstring("Enumeration for the slope type."), 
	helpcontext(HID_AGILENT34980ASLOPEENUM)
]
enum Agilent34980ASlopeEnum
{
	Agilent34980ASlopeNegative = 0,
	Agilent34980ASlopePositive = 1
};

[
	export, 
	library_block, 
	uuid("10dfed10-e5cb-44b5-97e9-952ec2c0978d"),
	v1_enum, 
	helpstring("Enumeration for the Register parameter of the Register property in the Status interface."), 
	helpcontext(HID_AGILENT34980ASTATUSREGISTERENUM)
]
enum Agilent34980AStatusRegisterEnum
{
	Agilent34980AStatusRegisterStatusByte = 0,
	Agilent34980AStatusRegisterStandardEvent = 1,
	Agilent34980AStatusRegisterOperation = 2,
	Agilent34980AStatusRegisterQuestionable = 3,
	Agilent34980AStatusRegisterAlarm = 4,
	Agilent34980AStatusRegisterModule = 5
};

[
	export, 
	library_block, 
	uuid("8098352c-20b0-488c-b1ad-b580e2c71bc8"),
	v1_enum, 
	helpstring("Enumeration for the SubRegister parameter of the Register property in the Status interface."), 
	helpcontext(HID_AGILENT34980ASTATUSSUBREGISTERENUM)
]
enum Agilent34980AStatusSubRegisterEnum
{
	Agilent34980AStatusSubRegisterCondition = 0,
	Agilent34980AStatusSubRegisterEvent = 1,
	Agilent34980AStatusSubRegisterEnable = 2
};

[
	export, 
	library_block, 
	uuid("858aec90-532a-4436-a4c6-1ab3f58f5624"),
	v1_enum, 
	helpstring("Enumeration for the temperature untis."), 
	helpcontext(HID_AGILENT34980ATEMPERATUREUNITSENUM)
]
enum Agilent34980ATemperatureUnitsEnum
{
	Agilent34980ATemperatureUnitsCelcius = 0,
	Agilent34980ATemperatureUnitsFahrenheit = 1,
	Agilent34980ATemperatureUnitsKelvin = 2
};

[
	export, 
	library_block, 
	uuid("b49eb766-36b9-4358-8767-3f214fe6b740"),
	v1_enum, 
	helpstring("Enumeration for the thermistor type."), 
	helpcontext(HID_AGILENT34980ATHERMISTORENUM)
]
enum Agilent34980AThermistorEnum
{
	Agilent34980AThermistor2252 = 2252,
	Agilent34980AThermistor5000 = 5000,
	Agilent34980AThermistor10000 = 10000
};

[
	export, 
	library_block, 
	uuid("d96e3952-ef44-4fa7-94e1-83b6968a3ec3"),
	v1_enum, 
	helpstring("Enumeration for the thermocouple types."), 
	helpcontext(HID_AGILENT34980ATHERMOCOUPLEENUM)
]
enum Agilent34980AThermocoupleEnum
{
	Agilent34980AThermocoupleBType = 0,
	Agilent34980AThermocoupleEType = 1,
	Agilent34980AThermocoupleJType = 2,
	Agilent34980AThermocoupleKType = 3,
	Agilent34980AThermocoupleNType = 4,
	Agilent34980AThermocoupleRType = 5,
	Agilent34980AThermocoupleSType = 6,
	Agilent34980AThermocoupleTType = 7
};

[
	export, 
	library_block, 
	uuid("35cb7dfa-9d9a-4279-a278-cc514f67f263"),
	v1_enum, 
	helpstring("Enumeratioin for the time offset types."), 
	helpcontext(HID_AGILENT34980ATIMEOFFSETENUM)
]
enum Agilent34980ATimeOffsetEnum
{
	Agilent34980ATimeOffsetAbsolute = 0,
	Agilent34980ATimeOffsetRelative = 1
};

[
	export, 
	library_block, 
	uuid("02cecac3-fe86-4ae4-b907-8e5e0205f992"),
	v1_enum, 
	helpstring("Enumeratioin for the transducer types."), 
	helpcontext(HID_AGILENT34980ATRANSDUCERENUM)
]
enum Agilent34980ATransducerEnum
{
	Agilent34980ATransducerTcouple = 0,
	Agilent34980ATransducerRTD = 1,
	Agilent34980ATransducerFRTD = 2,
	Agilent34980ATransducerThermistor = 3
};

[
	export, 
	library_block, 
	uuid("84650969-99b3-4eae-8564-b2c03c768dd9"),
	v1_enum, 
	helpstring("Enumeratioin for the trigger sources."), 
	helpcontext(HID_AGILENT34980ATRIGGERSOURCEENUM)
]
enum Agilent34980ATriggerSourceEnum
{
	Agilent34980ATriggerSourceBus = 0,
	Agilent34980ATriggerSourceImmediate = 1,
	Agilent34980ATriggerSourceExternal = 2,
	Agilent34980ATriggerSourceAlarm1 = 3,
	Agilent34980ATriggerSourceAlarm2 = 4,
	Agilent34980ATriggerSourceAlarm3 = 5,
	Agilent34980ATriggerSourceAlarm4 = 6,
	Agilent34980ATriggerSourceTimer = 7
};

[
	export, 
	library_block, 
	uuid("e5ea10ab-c2bb-4045-8a96-0afd240a9d79"),
	v1_enum, 
	helpstring("Enumerates the wire modes of modules 34923 reed multiplexer, the 34925 FET multiplexer, and the 34933 Dual 4x8 reed multiplexer."), 
	helpcontext(HID_AGILENT34980AWIREMODEENUM)
]
enum Agilent34980AWireModeEnum
{
	Agilent34980AWireMode1Wire = 0,
	Agilent34980AWireMode2Wire = 1
};

[
	export, 
	library_block, 
	uuid("dded85a5-99a4-482c-a565-78fe820d8edb"),
	v1_enum, 
	helpstring("Sequence trigger source enum."), 
	helpcontext(HID_AGILENT34980ASEQUENCETRIGGERSOURCEENUM)
]
enum Agilent34980ASequenceTriggerSourceEnum
{
	Agilent34980ASequenceTriggerSourceAlarm1 = 0,
	Agilent34980ASequenceTriggerSourceAlarm2 = 1,
	Agilent34980ASequenceTriggerSourceAlarm3 = 2,
	Agilent34980ASequenceTriggerSourceAlarm4 = 3,
	Agilent34980ASequenceTriggerSourceManual = 4
};


[
	object, 
	library_block,
	uuid("12e25558-9ab0-49b8-9f06-9cf759f89fa4"),
	helpstring("IAgilent34980A root interface."), 
	helpcontext(HID_IAGILENT34980A),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980A : IIviDriver
{
	[propget, helpstring("Returns pointer to the instrument specific Alarm interface"), helpcontext(HID_IAGILENT34980A_ALARM)]
	HRESULT Alarm([out, retval] IAgilent34980AAlarm** val);

	[propget, helpstring("Returns pointer to the instrument specific Calibration interface"), helpcontext(HID_IAGILENT34980A_CALIBRATION)]
	HRESULT Calibration([out, retval] IAgilent34980ACalibration** val);

	[propget, helpstring("Returns pointer to the instrument specific Current interface"), helpcontext(HID_IAGILENT34980A_CURRENT)]
	HRESULT Current([out, retval] IAgilent34980ACurrent** val);

	[propget, helpstring("Returns pointer to the Diagnostic interface"), helpcontext(HID_IAGILENT34980A_DIAGNOSTIC)]
	HRESULT Diagnostic([out, retval] IAgilent34980ADiagnostic** val);

	[propget, helpstring("Returns pointer to the instrument specific Display interface"), helpcontext(HID_IAGILENT34980A_DISPLAY)]
	HRESULT Display([out, retval] IAgilent34980ADisplay** val);

	[propget, helpstring("Returns pointer to the instrument specific Frequency interface"), helpcontext(HID_IAGILENT34980A_FREQUENCY)]
	HRESULT Frequency([out, retval] IAgilent34980AFrequency** val);

	[propget, helpstring("Returns pointer to the instrument specific FResistance interface"), helpcontext(HID_IAGILENT34980A_FRESISTANCE)]
	HRESULT FResistance([out, retval] IAgilent34980AFResistance** val);

	[propget, helpstring("Returns pointer to the instrument specific Measurement interface"), helpcontext(HID_IAGILENT34980A_MEASUREMENT)]
	HRESULT Measurement([out, retval] IAgilent34980AMeasurement** val);

	[propget, helpstring("Returns pointer to the instrument specific Memory interface"), helpcontext(HID_IAGILENT34980A_MEMORY)]
	HRESULT Memory([out, retval] IAgilent34980AMemory** val);

	[propget, helpstring("Returns pointer to the instrument specific Period interface"), helpcontext(HID_IAGILENT34980A_PERIOD)]
	HRESULT Period([out, retval] IAgilent34980APeriod** val);

	[propget, helpstring("Returns pointer to the instrument specific Resistance interface"), helpcontext(HID_IAGILENT34980A_RESISTANCE)]
	HRESULT Resistance([out, retval] IAgilent34980AResistance** val);

	[propget, helpstring("Returns pointer to the instrument specific Route interface"), helpcontext(HID_IAGILENT34980A_ROUTE)]
	HRESULT Route([out, retval] IAgilent34980ARoute** val);

	[propget, helpstring("Returns pointer to the instrument specific Scale interface"), helpcontext(HID_IAGILENT34980A_SCALE)]
	HRESULT Scale([out, retval] IAgilent34980AScale** val);

	[propget, helpstring("Returns pointer to the instrument specific Scan interface"), helpcontext(HID_IAGILENT34980A_SCAN)]
	HRESULT Scan([out, retval] IAgilent34980AScan** val);

	[propget, helpstring("Returns pointer to the instrument specific Statistics interface"), helpcontext(HID_IAGILENT34980A_STATISTICS)]
	HRESULT Statistics([out, retval] IAgilent34980AStatistics** val);

	[propget, helpstring("Returns pointer to the instrument specific Status interface."), helpcontext(HID_IAGILENT34980A_STATUS)]
	HRESULT Status([out, retval] IAgilent34980AStatus** val);

	[propget, helpstring("Returns pointer to the instrument specific System interface"), helpcontext(HID_IAGILENT34980A_SYSTEM)]
	HRESULT System([out, retval] IAgilent34980ASystem** val);

	[propget, helpstring("Returns pointer to the instrument specific Temperature interface"), helpcontext(HID_IAGILENT34980A_TEMPERATURE)]
	HRESULT Temperature([out, retval] IAgilent34980ATemperature** val);

	[propget, helpstring("Returns pointer to the instrument specific instrument specific Voltage interface"), helpcontext(HID_IAGILENT34980A_VOLTAGE)]
	HRESULT Voltage([out, retval] IAgilent34980AVoltage** val);

	[propget, helpstring("Returns pointer to the instrument specific Personality interface"), helpcontext(HID_IAGILENT34980A_PERSONALITY)]
	HRESULT Personality([out, retval] IAgilent34980APersonality** val);

	[propget, helpstring("Returns pointer to the instrument specific Trigger interface"), helpcontext(HID_IAGILENT34980A_TRIGGER)]
	HRESULT Trigger([out, retval] IAgilent34980ATrigger** val);
};

[
	object, 
	library_block,
	uuid("ca572dd4-e896-4f61-963b-edc00fe72dbe"),
	helpstring("IAgilent34980AACCurrent interface."), 
	helpcontext(HID_IAGILENT34980AACCURRENT),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980AACCurrent : IUnknown
{
	[helpstring("Resets all measurement parameters on the specified channels to their default  values.    Then, configures the channels for ac current measurements but does not initiate  the scan."), helpcontext(HID_IAGILENT34980AACCURRENT_CONFIGURE)]
	HRESULT Configure([in] BSTR ChannelList, [in] double Range, [in] Agilent34980AResolutionEnum Resolution);

	[helpstring("Resets all measurement parameters on the specified channels to their default  values.   	Then, configures the channels for ac current measurements and immediately sweeps  through the specified channels one time."), helpcontext(HID_IAGILENT34980AACCURRENT_MEASURE)]
	HRESULT Measure([in] BSTR ChannelList, [in] double Range, [in] Agilent34980AResolutionEnum Resolution, [out, retval] [satype(double)] SAFEARRAY** val);

	[propget, helpstring("Enables/Disables autoranging on the specified channels."), helpcontext(HID_IAGILENT34980AACCURRENT_AUTORANGE)]
	HRESULT AutoRange([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Enables/Disables autoranging on the specified channels."), helpcontext(HID_IAGILENT34980AACCURRENT_AUTORANGE)]
	HRESULT AutoRange(BSTR ChannelList, VARIANT_BOOL val);

	[propget, helpstring("Sets or gets the AC bandwidth."), helpcontext(HID_IAGILENT34980AACCURRENT_BANDWIDTH)]
	HRESULT Bandwidth([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Sets or gets the AC bandwidth."), helpcontext(HID_IAGILENT34980AACCURRENT_BANDWIDTH)]
	HRESULT Bandwidth(BSTR ChannelList, double val);

	[propget, helpstring("Selects the measurement range on the specified channel."), helpcontext(HID_IAGILENT34980AACCURRENT_RANGE)]
	HRESULT Range([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Selects the measurement range on the specified channel."), helpcontext(HID_IAGILENT34980AACCURRENT_RANGE)]
	HRESULT Range(BSTR ChannelList, double val);
};

[
	object, 
	library_block,
	uuid("3792fb40-33c1-4d5d-8430-256dfa880842"),
	helpstring("IAgilent34980AACVoltage interface."), 
	helpcontext(HID_IAGILENT34980AACVOLTAGE),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980AACVoltage : IUnknown
{
	[helpstring("Configures the specified channels for AC voltage measurements but does not initiate the scan."), helpcontext(HID_IAGILENT34980AACVOLTAGE_CONFIGURE)]
	HRESULT Configure([in] BSTR ChannelList, [in] double Range, [in] Agilent34980AResolutionEnum Resolution);

	[helpstring("Resets all measurement parameters on the specified channels to their default values. Then configures the channels for ac voltage measurements and immediately sweeps  through the specified channels one time."), helpcontext(HID_IAGILENT34980AACVOLTAGE_MEASURE)]
	HRESULT Measure([in] BSTR ChannelList, [in] double Range, [in] Agilent34980AResolutionEnum Resolution, [out, retval] [satype(double)] SAFEARRAY** val);

	[propget, helpstring("Enables/Disables autoranging on the specified channel."), helpcontext(HID_IAGILENT34980AACVOLTAGE_AUTORANGE)]
	HRESULT AutoRange([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Enables/Disables autoranging on the specified channel."), helpcontext(HID_IAGILENT34980AACVOLTAGE_AUTORANGE)]
	HRESULT AutoRange(BSTR ChannelList, VARIANT_BOOL val);

	[propget, helpstring("Sets or gets the AC bandwidth."), helpcontext(HID_IAGILENT34980AACVOLTAGE_BANDWIDTH)]
	HRESULT Bandwidth([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Sets or gets the AC bandwidth."), helpcontext(HID_IAGILENT34980AACVOLTAGE_BANDWIDTH)]
	HRESULT Bandwidth(BSTR ChannelList, double val);

	[propget, helpstring("Selects the measurement range on the specified channel."), helpcontext(HID_IAGILENT34980AACVOLTAGE_RANGE)]
	HRESULT Range([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Selects the measurement range on the specified channel."), helpcontext(HID_IAGILENT34980AACVOLTAGE_RANGE)]
	HRESULT Range(BSTR ChannelList, double val);
};

[
	object, 
	library_block,
	uuid("e0143f4b-d9c8-43a8-8cde-2ec85a0262c9"),
	helpstring("IAgilent34980AAlarm interface."), 
	helpcontext(HID_IAGILENT34980AALARM),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980AAlarm : IUnknown
{
	[helpstring("Clears the specified alarm output lines.  If ClearAll is TRUE, all four alarm output lines are cleared."), helpcontext(HID_IAGILENT34980AALARM_CLEAR)]
	HRESULT Clear([in] VARIANT_BOOL ClearAll, [in] long Index);

	[helpstring("Configures the instrument to scan when an alarm occurs.  If ChannelList is empty, the existing scan list is used."), helpcontext(HID_IAGILENT34980AALARM_ALARMSCANSETUP)]
	HRESULT AlarmScanSetup([in] BSTR ChannelList, [in] long Channel, [in] long AlarmIndex, [in] long NumSweeps, [in] double UpperLimit);

	[propget, helpstring("Sets or gets the lower limit for alarms on the specified channel.  You can set the value to any number between -120% and +120% of the highest range, for the present function.  The lower limit MUST ALWAYS be less than or equal to the upper limit."), helpcontext(HID_IAGILENT34980AALARM_LOWERLIMIT)]
	HRESULT LowerLimit([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Sets or gets the lower limit for alarms on the specified channel.  You can set the value to any number between -120% and +120% of the highest range, for the present function.  The lower limit MUST ALWAYS be less than or equal to the upper limit."), helpcontext(HID_IAGILENT34980AALARM_LOWERLIMIT)]
	HRESULT LowerLimit(BSTR ChannelList, double val);

	[propget, helpstring("Enables/Disables the lower alarm limit on the specified channel."), helpcontext(HID_IAGILENT34980AALARM_LOWERLIMITENABLE)]
	HRESULT LowerLimitEnable([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Enables/Disables the lower alarm limit on the specified channel."), helpcontext(HID_IAGILENT34980AALARM_LOWERLIMITENABLE)]
	HRESULT LowerLimitEnable(BSTR ChannelList, VARIANT_BOOL val);

	[propget, helpstring("Sets or gets the configuration of the four alarm output lines.  Applies to all four alarm output lines."), helpcontext(HID_IAGILENT34980AALARM_MODE)]
	HRESULT Mode([out, retval] Agilent34980AAlarmModeEnum* val);

	[propput, helpstring("Sets or gets the configuration of the four alarm output lines.  Applies to all four alarm output lines."), helpcontext(HID_IAGILENT34980AALARM_MODE)]
	HRESULT Mode(Agilent34980AAlarmModeEnum val);

	[propget, helpstring("Read the alarm data from the output queue."), helpcontext(HID_IAGILENT34980AALARM_QUERYALARMQUEUE)]
	HRESULT QueryAlarmQueue([out, retval] BSTR* val);

	[propget, helpstring("Sets or gets the slope of the pulse from the alarm outputs.  !!! Note that changing the slope of the output lines may cause the lines to change state."), helpcontext(HID_IAGILENT34980AALARM_SLOPE)]
	HRESULT Slope([out, retval] Agilent34980ASlopeEnum* val);

	[propput, helpstring("Sets or gets the slope of the pulse from the alarm outputs.  !!! Note that changing the slope of the output lines may cause the lines to change state."), helpcontext(HID_IAGILENT34980AALARM_SLOPE)]
	HRESULT Slope(Agilent34980ASlopeEnum val);

	[propget, helpstring("Sets or gets the Alarm source currently used by the specified channel."), helpcontext(HID_IAGILENT34980AALARM_SOURCE)]
	HRESULT Source([in] long Index, [out, retval] BSTR* val);

	[propput, helpstring("Sets or gets the Alarm source currently used by the specified channel."), helpcontext(HID_IAGILENT34980AALARM_SOURCE)]
	HRESULT Source(long Index, BSTR val);

	[propget, helpstring("Sets or gets the upper limit for alarms on the specified channels."), helpcontext(HID_IAGILENT34980AALARM_UPPERLIMIT)]
	HRESULT UpperLimit([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Sets or gets the upper limit for alarms on the specified channels."), helpcontext(HID_IAGILENT34980AALARM_UPPERLIMIT)]
	HRESULT UpperLimit(BSTR ChannelList, double val);

	[propget, helpstring("Enables/Disables the upper alarm limit on the specified channel."), helpcontext(HID_IAGILENT34980AALARM_UPPERLIMITENABLE)]
	HRESULT UpperLimitEnable([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Enables/Disables the upper alarm limit on the specified channel."), helpcontext(HID_IAGILENT34980AALARM_UPPERLIMITENABLE)]
	HRESULT UpperLimitEnable(BSTR ChannelList, VARIANT_BOOL val);
};

[
	object, 
	library_block,
	uuid("331ab8de-b208-43eb-aecf-daf03e6e34dc"),
	helpstring("IAgilent34980ACalibration interface."), 
	helpcontext(HID_IAGILENT34980ACALIBRATION),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980ACalibration : IUnknown
{
	[helpstring("Enables or disables the calibration state, when the proper Code string is supplied."), helpcontext(HID_IAGILENT34980ACALIBRATION_SECURITYENABLE)]
	HRESULT SecurityEnable([in] VARIANT_BOOL Enable, [in] BSTR Code);

	[propput, helpstring("Enters a new security code."), helpcontext(HID_IAGILENT34980ACALIBRATION_CODE)]
	HRESULT Code(BSTR val);

	[propget, helpstring("Sets or gets message stored in Mainframe calibration memory."), helpcontext(HID_IAGILENT34980ACALIBRATION_STRING)]
	HRESULT String([out, retval] BSTR* val);

	[propput, helpstring("Sets or gets message stored in Mainframe calibration memory."), helpcontext(HID_IAGILENT34980ACALIBRATION_STRING)]
	HRESULT String(BSTR val);

	[propget, helpstring("Gets the calibration count on the specified location."), helpcontext(HID_IAGILENT34980ACALIBRATION_COUNT)]
	HRESULT Count([out, retval] long* val);

	[propget, helpstring("Gets/Sets the line frequency used for 34951 Calibration."), helpcontext(HID_IAGILENT34980ACALIBRATION_LINEFREQUENCY)]
	HRESULT LineFrequency([out, retval] double* val);

	[propput, helpstring("Gets/Sets the line frequency used for 34951 Calibration."), helpcontext(HID_IAGILENT34980ACALIBRATION_LINEFREQUENCY)]
	HRESULT LineFrequency(double val);

	[propget, helpstring("Returns the state of calibration security on the instrument."), helpcontext(HID_IAGILENT34980ACALIBRATION_SECURITYSTATE)]
	HRESULT SecurityState([out, retval] VARIANT_BOOL* val);

	[propget, helpstring("Returns pointer to the instrument specific DAC interface"), helpcontext(HID_IAGILENT34980ACALIBRATION_DAC)]
	HRESULT DAC([out, retval] IAgilent34980ADAC** val);

	[propget, helpstring("Returns pointer to the instrument specific DMM interface"), helpcontext(HID_IAGILENT34980ACALIBRATION_DMM)]
	HRESULT DMM([out, retval] IAgilent34980ADMM** val);
};

[
	object, 
	library_block,
	uuid("831a51e9-b3fb-40cc-95e9-bb32728201b5"),
	helpstring("IAgilent34980ACurrent interface."), 
	helpcontext(HID_IAGILENT34980ACURRENT),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980ACurrent : IUnknown
{
	[propget, helpstring("Retrieves a pointer to IAgilent34980AACCurrent interface"), helpcontext(HID_IAGILENT34980ACURRENT_ACCURRENT)]
	HRESULT ACCurrent([out, retval] IAgilent34980AACCurrent** val);

	[propget, helpstring("Retrieves a pointer to IAgilent34980ADCCurrent interface"), helpcontext(HID_IAGILENT34980ACURRENT_DCCURRENT)]
	HRESULT DCCurrent([out, retval] IAgilent34980ADCCurrent** val);
};

[
	object, 
	library_block,
	uuid("2589d208-d4e1-4749-909d-f2e31c51781a"),
	helpstring("IAgilent34980ADAC interface."), 
	helpcontext(HID_IAGILENT34980ADAC),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980ADAC : IUnknown
{
	[helpstring("This method causes an automatic calibration of the specified 34951 DAC modules."), helpcontext(HID_IAGILENT34980ADAC_AUTOCALIBRATE)]
	HRESULT AutoCalibrate([in] short SlotNumber, [in] VARIANT_BOOL All);

	[helpstring("Aborts a calibration sequence on the specified DAC channel."), helpcontext(HID_IAGILENT34980ADAC_ABORT)]
	HRESULT Abort();

	[helpstring("Initiates a voltage calibration (adjustment) sequence for the specified DAC channel on a 34952A or 34951A DAC channel."), helpcontext(HID_IAGILENT34980ADAC_BEGINVOLTAGECAL)]
	HRESULT BeginVoltageCal([in] BSTR ChannelList, [in] short SetupNumber);

	[helpstring("This command follows the BeginDacVoltCal method in the voltage calibration sequence for the specified DAC channel on the 34952A Multifunction Module."), helpcontext(HID_IAGILENT34980ADAC_POINT)]
	HRESULT Point([in] double PointData);

	[propget, helpstring("Gets the calibration count on the specified location."), helpcontext(HID_IAGILENT34980ADAC_COUNT)]
	HRESULT Count([in] short SlotNumber, [out, retval] long* val);

	[propget, helpstring("Sets or gets the specified calibration string."), helpcontext(HID_IAGILENT34980ADAC_STRING)]
	HRESULT String([in] short SlotNumber, [out, retval] BSTR* val);

	[propput, helpstring("Sets or gets the specified calibration string."), helpcontext(HID_IAGILENT34980ADAC_STRING)]
	HRESULT String(short SlotNumber, BSTR val);
};

[
	object, 
	library_block,
	uuid("c8ae4c49-d06b-45dc-ab3a-7ce6a3d7ecda"),
	helpstring("IAgilent34980ADCCurrent interface."), 
	helpcontext(HID_IAGILENT34980ADCCURRENT),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980ADCCurrent : IUnknown
{
	[helpstring("Configures the specified channels for DC current measurements but do not   initiate the scan."), helpcontext(HID_IAGILENT34980ADCCURRENT_CONFIGURE)]
	HRESULT Configure([in] BSTR ChannelList, [in] double Range, [in] Agilent34980AResolutionEnum Resolution);

	[helpstring("Resets all measurement parameters on the specified channels to their default values. Then configures the channels for dc current measurements and immediately sweeps through the specified channels one time."), helpcontext(HID_IAGILENT34980ADCCURRENT_MEASURE)]
	HRESULT Measure([in] BSTR ChannelList, [in] double Range, [in] Agilent34980AResolutionEnum Resolution, [out, retval] [satype(double)] SAFEARRAY** val);

	[propget, helpstring("Sets or gets the measurement acquisition time (called integration time) in seconds."), helpcontext(HID_IAGILENT34980ADCCURRENT_APERTURE)]
	HRESULT Aperture([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Sets or gets the measurement acquisition time (called integration time) in seconds."), helpcontext(HID_IAGILENT34980ADCCURRENT_APERTURE)]
	HRESULT Aperture(BSTR ChannelList, double val);

	[propget, helpstring("Enables/Disables autoranging on the specified channel."), helpcontext(HID_IAGILENT34980ADCCURRENT_AUTORANGE)]
	HRESULT AutoRange([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Enables/Disables autoranging on the specified channel."), helpcontext(HID_IAGILENT34980ADCCURRENT_AUTORANGE)]
	HRESULT AutoRange(BSTR ChannelList, VARIANT_BOOL val);

	[propget, helpstring("Sets or gets the measurement acquisition time (called integration time) in number of power line cycles (PLCs) on the specified channels."), helpcontext(HID_IAGILENT34980ADCCURRENT_NPLC)]
	HRESULT NPLC([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Sets or gets the measurement acquisition time (called integration time) in number of power line cycles (PLCs) on the specified channels."), helpcontext(HID_IAGILENT34980ADCCURRENT_NPLC)]
	HRESULT NPLC(BSTR ChannelList, double val);

	[propget, helpstring("Selects the measurement range on the specified channel."), helpcontext(HID_IAGILENT34980ADCCURRENT_RANGE)]
	HRESULT Range([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Selects the measurement range on the specified channel."), helpcontext(HID_IAGILENT34980ADCCURRENT_RANGE)]
	HRESULT Range(BSTR ChannelList, double val);

	[propget, helpstring("Gets the resolution on the specified channel."), helpcontext(HID_IAGILENT34980ADCCURRENT_RESOLUTION)]
	HRESULT Resolution([in] BSTR ChannelList, [out, retval] double* val);

	[propget, helpstring("Disables or enables the autozero mode on the specified channels. If you supply an empty ChannelList, this property applies to the internal DMM, independent of any channels or a scan list."), helpcontext(HID_IAGILENT34980ADCCURRENT_AUTOZERO)]
	HRESULT AutoZero([in] BSTR ChannelList, [out, retval] Agilent34980AAutoZeroEnum* val);

	[propput, helpstring("Disables or enables the autozero mode on the specified channels. If you supply an empty ChannelList, this property applies to the internal DMM, independent of any channels or a scan list."), helpcontext(HID_IAGILENT34980ADCCURRENT_AUTOZERO)]
	HRESULT AutoZero(BSTR ChannelList, Agilent34980AAutoZeroEnum val);
};

[
	object, 
	library_block,
	uuid("44efd368-ac81-43a0-a30d-4c96d71b8ba9"),
	helpstring("IAgilent34980ADCVoltage interface."), 
	helpcontext(HID_IAGILENT34980ADCVOLTAGE),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980ADCVoltage : IUnknown
{
	[helpstring("Configures the specified channels for DC voltage measurements but does not initiate the scan."), helpcontext(HID_IAGILENT34980ADCVOLTAGE_CONFIGURE)]
	HRESULT Configure([in] BSTR ChannelList, [in] double Range, [in] Agilent34980AResolutionEnum Resolution);

	[helpstring("Resets all measurement parameters on the specified channels to their default  values. Then configures the channels for dc    voltage measurements and immediately sweeps through the specified channels  one time."), helpcontext(HID_IAGILENT34980ADCVOLTAGE_MEASURE)]
	HRESULT Measure([in] BSTR ChannelList, [in] double Range, [in] Agilent34980AResolutionEnum Resolution, [out, retval] [satype(double)] SAFEARRAY** val);

	[propget, helpstring("Sets or gets the measurement acquisition time (called integration time) in seconds."), helpcontext(HID_IAGILENT34980ADCVOLTAGE_APERTURE)]
	HRESULT Aperture([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Sets or gets the measurement acquisition time (called integration time) in seconds."), helpcontext(HID_IAGILENT34980ADCVOLTAGE_APERTURE)]
	HRESULT Aperture(BSTR ChannelList, double val);

	[propget, helpstring("Enables/Disables autoranging on the specified channel."), helpcontext(HID_IAGILENT34980ADCVOLTAGE_AUTORANGE)]
	HRESULT AutoRange([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Enables/Disables autoranging on the specified channel."), helpcontext(HID_IAGILENT34980ADCVOLTAGE_AUTORANGE)]
	HRESULT AutoRange(BSTR ChannelList, VARIANT_BOOL val);

	[propget, helpstring("Sets or gets the measurement acquisition time (called integration time) in number of power line cycles (PLCs) on the specified channels."), helpcontext(HID_IAGILENT34980ADCVOLTAGE_NPLC)]
	HRESULT NPLC([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Sets or gets the measurement acquisition time (called integration time) in number of power line cycles (PLCs) on the specified channels."), helpcontext(HID_IAGILENT34980ADCVOLTAGE_NPLC)]
	HRESULT NPLC(BSTR ChannelList, double val);

	[propget, helpstring("Selects the measurement range on the specified channel."), helpcontext(HID_IAGILENT34980ADCVOLTAGE_RANGE)]
	HRESULT Range([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Selects the measurement range on the specified channel."), helpcontext(HID_IAGILENT34980ADCVOLTAGE_RANGE)]
	HRESULT Range(BSTR ChannelList, double val);

	[propget, helpstring("Sets the resolution on the specified channel."), helpcontext(HID_IAGILENT34980ADCVOLTAGE_RESOLUTION)]
	HRESULT Resolution([in] BSTR ChannelList, [out, retval] double* val);

	[propget, helpstring("Disables or enables the autozero mode on the specified channels. If you supply an empty ChannelList, this property applies to the internal DMM, independent of any channels or a scan list."), helpcontext(HID_IAGILENT34980ADCVOLTAGE_AUTOZERO)]
	HRESULT AutoZero([in] BSTR ChannelList, [out, retval] Agilent34980AAutoZeroEnum* val);

	[propput, helpstring("Disables or enables the autozero mode on the specified channels. If you supply an empty ChannelList, this property applies to the internal DMM, independent of any channels or a scan list."), helpcontext(HID_IAGILENT34980ADCVOLTAGE_AUTOZERO)]
	HRESULT AutoZero(BSTR ChannelList, Agilent34980AAutoZeroEnum val);

	[propget, helpstring("Disables or enables the automatic input resistance mode for dc voltage measurements on the specified channels."), helpcontext(HID_IAGILENT34980ADCVOLTAGE_AUTOIMPEDANCE)]
	HRESULT AutoImpedance([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Disables or enables the automatic input resistance mode for dc voltage measurements on the specified channels."), helpcontext(HID_IAGILENT34980ADCVOLTAGE_AUTOIMPEDANCE)]
	HRESULT AutoImpedance(BSTR ChannelList, VARIANT_BOOL val);
};

[
	object, 
	library_block,
	uuid("229cc78f-a5ef-4dcf-81d4-a8a6bad3ddc6"),
	helpstring("IAgilent34980ADMM interface."), 
	helpcontext(HID_IAGILENT34980ADMM),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980ADMM : IUnknown
{
	[helpstring("This method is used to calculate and save the DMM calibration values for the present calibration step on the internal DMM."), helpcontext(HID_IAGILENT34980ADMM_PERFORMCALIBRATION)]
	HRESULT PerformCalibration();

	[propget, helpstring("Gets the calibration count on the internal DMM."), helpcontext(HID_IAGILENT34980ADMM_COUNT)]
	HRESULT Count([out, retval] long* val);

	[propget, helpstring("Sets or gets the calibration string."), helpcontext(HID_IAGILENT34980ADMM_STRING)]
	HRESULT String([out, retval] BSTR* val);

	[propput, helpstring("Sets or gets the calibration string."), helpcontext(HID_IAGILENT34980ADMM_STRING)]
	HRESULT String(BSTR val);

	[propget, helpstring("This attribute is used to calibrate the internal DMM."), helpcontext(HID_IAGILENT34980ADMM_VALUE)]
	HRESULT Value([out, retval] double* val);

	[propput, helpstring("This attribute is used to calibrate the internal DMM."), helpcontext(HID_IAGILENT34980ADMM_VALUE)]
	HRESULT Value(double val);
};

[
	object, 
	library_block,
	uuid("2085aa5a-c6cd-4571-817b-a71daa508b52"),
	helpstring("IAgilent34980ADataFormat  interface."), 
	helpcontext(HID_IAGILENT34980ADATAFORMAT),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980ADataFormat : IUnknown
{
	[helpstring("Disables or enables the inclusion of alarm information with data retrieved by the READ? command, the FETCh? command, or other queries of scan results."), helpcontext(HID_IAGILENT34980ADATAFORMAT_CONFIGURE)]
	HRESULT Configure([in] VARIANT_BOOL EnableAlarm, [in] VARIANT_BOOL EnableChannel, [in] VARIANT_BOOL EnableTime, [in] Agilent34980ATimeOffsetEnum TimeType, [in] VARIANT_BOOL EnableUnit);

	[propget, helpstring("Disables or enables the inclusion of alarm information with the data retrieved."), helpcontext(HID_IAGILENT34980ADATAFORMAT_ALARMENABLE)]
	HRESULT AlarmEnable([out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Disables or enables the inclusion of alarm information with the data retrieved."), helpcontext(HID_IAGILENT34980ADATAFORMAT_ALARMENABLE)]
	HRESULT AlarmEnable(VARIANT_BOOL val);

	[propget, helpstring("Disables or enables the inclusion of channel number information with data the retrieved."), helpcontext(HID_IAGILENT34980ADATAFORMAT_CHANNELENABLE)]
	HRESULT ChannelEnable([out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Disables or enables the inclusion of channel number information with data the retrieved."), helpcontext(HID_IAGILENT34980ADATAFORMAT_CHANNELENABLE)]
	HRESULT ChannelEnable(VARIANT_BOOL val);

	[propget, helpstring("Disables or enables the inclusion of a time stamp with the data retrieved."), helpcontext(HID_IAGILENT34980ADATAFORMAT_TIMEENABLE)]
	HRESULT TimeEnable([out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Disables or enables the inclusion of a time stamp with the data retrieved."), helpcontext(HID_IAGILENT34980ADATAFORMAT_TIMEENABLE)]
	HRESULT TimeEnable(VARIANT_BOOL val);

	[propget, helpstring("Selects the time format for storing scanned data in memory. You can select absolute time (time of day with date) or relative time (time since start of scan)."), helpcontext(HID_IAGILENT34980ADATAFORMAT_TIMETYPE)]
	HRESULT TimeType([out, retval] Agilent34980ATimeOffsetEnum* val);

	[propput, helpstring("Selects the time format for storing scanned data in memory. You can select absolute time (time of day with date) or relative time (time since start of scan)."), helpcontext(HID_IAGILENT34980ADATAFORMAT_TIMETYPE)]
	HRESULT TimeType(Agilent34980ATimeOffsetEnum val);

	[propget, helpstring("Disables or enables the inclusion of measurement units (VAC, VDC, OHM, etc.) with the data retrieved."), helpcontext(HID_IAGILENT34980ADATAFORMAT_UNITENABLE)]
	HRESULT UnitEnable([out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Disables or enables the inclusion of measurement units (VAC, VDC, OHM, etc.) with the data retrieved."), helpcontext(HID_IAGILENT34980ADATAFORMAT_UNITENABLE)]
	HRESULT UnitEnable(VARIANT_BOOL val);
};

[
	object, 
	library_block,
	uuid("4c634de3-3845-4015-8fc1-51d51825a273"),
	helpstring("IAgilent34980ADiagnostic interface."), 
	helpcontext(HID_IAGILENT34980ADIAGNOSTIC),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980ADiagnostic : IUnknown
{
	[helpstring("Resets the cycle count on the specified channels.  The instrument must be unsecured to reset the cycle count."), helpcontext(HID_IAGILENT34980ADIAGNOSTIC_RELAYCYCLESCLEAR)]
	HRESULT RelayCyclesClear([in] BSTR ChannelList);

	[helpstring("Resets the relay cycle count on the specified internal DMM relay."), helpcontext(HID_IAGILENT34980ADIAGNOSTIC_DMMCYCLESCLEAR)]
	HRESULT DMMCyclesClear([in] long Index);

	[propget, helpstring("Reads the cycle count on one of the six relays associated with function selection and isolation on the internal DMM."), helpcontext(HID_IAGILENT34980ADIAGNOSTIC_DMMCYCLES)]
	HRESULT DMMCycles([in] long Index, [out, retval] long* val);

	[propget, helpstring("Reads the cycle count on the specified channels. In addition to the channel relays, you can also query the count on the Analog Bus relays and bank relays."), helpcontext(HID_IAGILENT34980ADIAGNOSTIC_RELAYCYCLES)]
	HRESULT RelayCycles([in] BSTR ChannelList, [out, retval] long* val);
};

[
	object, 
	library_block,
	uuid("54dcef67-4d55-4a7a-8233-72290f5bd118"),
	helpstring("IAgilent34980ADisplay interface."), 
	helpcontext(HID_IAGILENT34980ADISPLAY),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980ADisplay : IUnknown
{
	[helpstring("Clears the message displayed on the front panel display."), helpcontext(HID_IAGILENT34980ADISPLAY_CLEARDISPLAY)]
	HRESULT ClearDisplay();

	[helpstring("Sets Monitor mode to internal DMM."), helpcontext(HID_IAGILENT34980ADISPLAY_MONITORDMM)]
	HRESULT MonitorDMM();

	[helpstring("Sets Monitor mode to a channel on one of these modules: 34921A through 34925A Multiplexer Modules,  34950A Digital I/O Module (digital input and totalizer channels only) and 34952A Multifunction Module (digital input and totalizer channels only)."), helpcontext(HID_IAGILENT34980ADISPLAY_MONITORCHANNEL)]
	HRESULT MonitorChannel([in] BSTR Channel);

	[propget, helpstring("Enables/Disables the front panel display."), helpcontext(HID_IAGILENT34980ADISPLAY_DISPLAYENABLED)]
	HRESULT DisplayEnabled([out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Enables/Disables the front panel display."), helpcontext(HID_IAGILENT34980ADISPLAY_DISPLAYENABLED)]
	HRESULT DisplayEnabled(VARIANT_BOOL val);

	[propget, helpstring("Displays a message on the instrument's front panel display.  The message sent can be up to 13 characters, and can consist of letters (A-Z), numbers (0-9), and special characters like '@', '%', '*', etc.  Use the '#' symbol to display a degree symbol."), helpcontext(HID_IAGILENT34980ADISPLAY_DISPLAYTEXT)]
	HRESULT DisplayText([out, retval] BSTR* val);

	[propput, helpstring("Displays a message on the instrument's front panel display.  The message sent can be up to 13 characters, and can consist of letters (A-Z), numbers (0-9), and special characters like '@', '%', '*', etc.  Use the '#' symbol to display a degree symbol."), helpcontext(HID_IAGILENT34980ADISPLAY_DISPLAYTEXT)]
	HRESULT DisplayText(BSTR val);

	[propget, helpstring("Reads the data from the channel currently selected for the Monitor mode or from the internal DMM. One reading is returned each time this property is called."), helpcontext(HID_IAGILENT34980ADISPLAY_MONITORDATA)]
	HRESULT MonitorData([out, retval] double* val);

	[propget, helpstring("Disables or enables the Monitor mode."), helpcontext(HID_IAGILENT34980ADISPLAY_MONITORENABLE)]
	HRESULT MonitorEnable([out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Disables or enables the Monitor mode."), helpcontext(HID_IAGILENT34980ADISPLAY_MONITORENABLE)]
	HRESULT MonitorEnable(VARIANT_BOOL val);

	[propget, helpstring("Selects whether the Monitor mode uses a channel on one of the modules listed below or the internal DMM."), helpcontext(HID_IAGILENT34980ADISPLAY_MONITORMODE)]
	HRESULT MonitorMode([out, retval] Agilent34980AMonitorModeEnum* val);

	[propput, helpstring("Selects whether the Monitor mode uses a channel on one of the modules listed below or the internal DMM."), helpcontext(HID_IAGILENT34980ADISPLAY_MONITORMODE)]
	HRESULT MonitorMode(Agilent34980AMonitorModeEnum val);

	[propget, helpstring("Disables or enables the Monitor mode on the specified channels. without modifying the active scan list."), helpcontext(HID_IAGILENT34980ADISPLAY_ENABLEMONITORCHAN)]
	HRESULT EnableMonitorChan([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Disables or enables the Monitor mode on the specified channels. without modifying the active scan list."), helpcontext(HID_IAGILENT34980ADISPLAY_ENABLEMONITORCHAN)]
	HRESULT EnableMonitorChan(BSTR ChannelList, VARIANT_BOOL val);

	[propget, helpstring("Selects the channel to be displayed on the front panel in the Monitor mode. Only one channel can be monitored at a time."), helpcontext(HID_IAGILENT34980ADISPLAY_SELECTMONITORCHAN)]
	HRESULT SelectMonitorChan([out, retval] BSTR* val);

	[propput, helpstring("Selects the channel to be displayed on the front panel in the Monitor mode. Only one channel can be monitored at a time."), helpcontext(HID_IAGILENT34980ADISPLAY_SELECTMONITORCHAN)]
	HRESULT SelectMonitorChan(BSTR val);
};

[
	object, 
	library_block,
	uuid("cd64a418-6b1c-4a2c-9b87-f3f9317cb590"),
	helpstring("IAgilent34980AFRTD interface."), 
	helpcontext(HID_IAGILENT34980AFRTD),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980AFRTD : IUnknown
{
	[helpstring("Resets all measurement parameters on the specified channels to their default values. Then, configures the channels for temperature measurements but does not initiate the scan."), helpcontext(HID_IAGILENT34980AFRTD_CONFIGURE)]
	HRESULT Configure([in] BSTR ChannelList, [in] Agilent34980AResolutionEnum Resolution, [in] Agilent34980AFRTDAlphaEnum Type);

	[helpstring("Resets all measurement parameters on the specified channels to their default values. Then, configures the channels for temperature measurements and immediately  sweeps through the specified channels one time."), helpcontext(HID_IAGILENT34980AFRTD_MEASURE)]
	HRESULT Measure([in] BSTR ChannelList, [in] Agilent34980ARTDAlphaEnum Type, [in] Agilent34980AResolutionEnum Resolution, [out, retval] [satype(double)] SAFEARRAY** val);

	[propget, helpstring("Selects the nominal resistance (Ro) for 4-wire RTD measurements on the specified channels."), helpcontext(HID_IAGILENT34980AFRTD_RESISTANCE)]
	HRESULT Resistance([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Selects the nominal resistance (Ro) for 4-wire RTD measurements on the specified channels."), helpcontext(HID_IAGILENT34980AFRTD_RESISTANCE)]
	HRESULT Resistance(BSTR ChannelList, double val);

	[propget, helpstring("This property selects the FRTD type for 4-wire temperature measurements on the specified channels. If you supply an empty  ChannelList, this property applies to the internal DMM, independent of any channels or a scan list."), helpcontext(HID_IAGILENT34980AFRTD_ALPHA)]
	HRESULT Alpha([in] BSTR ChannelList, [out, retval] Agilent34980AFRTDAlphaEnum* val);

	[propput, helpstring("This property selects the FRTD type for 4-wire temperature measurements on the specified channels. If you supply an empty  ChannelList, this property applies to the internal DMM, independent of any channels or a scan list."), helpcontext(HID_IAGILENT34980AFRTD_ALPHA)]
	HRESULT Alpha(BSTR ChannelList, Agilent34980AFRTDAlphaEnum val);

	[propget, helpstring("Enables or Disables the measurement on the specified channel (or the DMM if channelList is empty) to be used as an external reference for a thermocouple measurement that has been configured to use an external reference."), helpcontext(HID_IAGILENT34980AFRTD_ISEXTERNALREFERENCE)]
	HRESULT IsExternalReference([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Enables or Disables the measurement on the specified channel (or the DMM if channelList is empty) to be used as an external reference for a thermocouple measurement that has been configured to use an external reference."), helpcontext(HID_IAGILENT34980AFRTD_ISEXTERNALREFERENCE)]
	HRESULT IsExternalReference(BSTR ChannelList, VARIANT_BOOL val);

	[propget, helpstring("Enables or disables offset compensation."), helpcontext(HID_IAGILENT34980AFRTD_OCOMPENSATED)]
	HRESULT OCompensated([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Enables or disables offset compensation."), helpcontext(HID_IAGILENT34980AFRTD_OCOMPENSATED)]
	HRESULT OCompensated(BSTR ChannelList, VARIANT_BOOL val);
};

[
	object, 
	library_block,
	uuid("5830c617-2db9-48e1-9246-4e899d1ae195"),
	helpstring("IAgilent34980AFResistance interface."), 
	helpcontext(HID_IAGILENT34980AFRESISTANCE),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980AFResistance : IUnknown
{
	[helpstring("Configures the specified channels for 4-wire measurements but do not initiate  the scan."), helpcontext(HID_IAGILENT34980AFRESISTANCE_CONFIGURE)]
	HRESULT Configure([in] BSTR ChannelList, [in] double Range, [in] Agilent34980AResolutionEnum Resolution);

	[helpstring("Resets all measurement parameters on the specified channels to their default  values. Then, configures the channels for 4-wire resistance measurements and immediately sweeps through the specified  channels one time    (channels in Bank 1 are automatically"), helpcontext(HID_IAGILENT34980AFRESISTANCE_MEASURE)]
	HRESULT Measure([in] BSTR ChannelList, [in] double Range, [in] Agilent34980AResolutionEnum Resolution, [out, retval] [satype(double)] SAFEARRAY** val);

	[propget, helpstring("Sets or gets the measurement acquisition time (called integration time) in seconds."), helpcontext(HID_IAGILENT34980AFRESISTANCE_APERTURE)]
	HRESULT Aperture([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Sets or gets the measurement acquisition time (called integration time) in seconds."), helpcontext(HID_IAGILENT34980AFRESISTANCE_APERTURE)]
	HRESULT Aperture(BSTR ChannelList, double val);

	[propget, helpstring("Enables/Disables autoranging on the specified channel."), helpcontext(HID_IAGILENT34980AFRESISTANCE_AUTORANGE)]
	HRESULT AutoRange([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Enables/Disables autoranging on the specified channel."), helpcontext(HID_IAGILENT34980AFRESISTANCE_AUTORANGE)]
	HRESULT AutoRange(BSTR ChannelList, VARIANT_BOOL val);

	[propget, helpstring("Sets or gets the measurement acquisition time (called integration time) in number of power line cycles (PLCs) on the specified channels."), helpcontext(HID_IAGILENT34980AFRESISTANCE_NPLC)]
	HRESULT NPLC([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Sets or gets the measurement acquisition time (called integration time) in number of power line cycles (PLCs) on the specified channels."), helpcontext(HID_IAGILENT34980AFRESISTANCE_NPLC)]
	HRESULT NPLC(BSTR ChannelList, double val);

	[propget, helpstring("Enables or disables offset compensation."), helpcontext(HID_IAGILENT34980AFRESISTANCE_OCOMPENSATED)]
	HRESULT OCompensated([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Enables or disables offset compensation."), helpcontext(HID_IAGILENT34980AFRESISTANCE_OCOMPENSATED)]
	HRESULT OCompensated(BSTR ChannelList, VARIANT_BOOL val);

	[propget, helpstring("Selects the measurement range on the specified channel."), helpcontext(HID_IAGILENT34980AFRESISTANCE_RANGE)]
	HRESULT Range([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Selects the measurement range on the specified channel."), helpcontext(HID_IAGILENT34980AFRESISTANCE_RANGE)]
	HRESULT Range(BSTR ChannelList, double val);

	[propget, helpstring("Sets or gets the resolution on the specified channel."), helpcontext(HID_IAGILENT34980AFRESISTANCE_RESOLUTION)]
	HRESULT Resolution([in] BSTR ChannelList, [out, retval] double* val);
};

[
	object, 
	library_block,
	uuid("82889fb3-914a-48a3-8eca-cfcb7a13d358"),
	helpstring("IAgilent34980AFrequency interface."), 
	helpcontext(HID_IAGILENT34980AFREQUENCY),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980AFrequency : IUnknown
{
	[helpstring("Resets all measurement parameters on the specified channels to their default  values. Then, configures the channels    for frequency measurements and immediately sweeps through the specified channels  one time."), helpcontext(HID_IAGILENT34980AFREQUENCY_MEASURE)]
	HRESULT Measure([in] BSTR ChannelList, [in] double Range, [in] Agilent34980AResolutionEnum Resolution, [out, retval] [satype(double)] SAFEARRAY** val);

	[helpstring("Configures the specified channels for frequency measurements but  does not    initiate the scan."), helpcontext(HID_IAGILENT34980AFREQUENCY_CONFIGURE)]
	HRESULT Configure([in] BSTR ChannelList, [in] double Range, [in] Agilent34980AResolutionEnum Resolution);

	[propget, helpstring("Sets or gets the gate time for a period or frequency measurement."), helpcontext(HID_IAGILENT34980AFREQUENCY_APERTURE)]
	HRESULT Aperture([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Sets or gets the gate time for a period or frequency measurement."), helpcontext(HID_IAGILENT34980AFREQUENCY_APERTURE)]
	HRESULT Aperture(BSTR ChannelList, double val);

	[propget, helpstring("Enables/Disables autoranging on the specified channel."), helpcontext(HID_IAGILENT34980AFREQUENCY_AUTORANGE)]
	HRESULT AutoRange([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Enables/Disables autoranging on the specified channel."), helpcontext(HID_IAGILENT34980AFREQUENCY_AUTORANGE)]
	HRESULT AutoRange(BSTR ChannelList, VARIANT_BOOL val);

	[propget, helpstring("Sets or gets the lowest frequency expected in the input signal for frequency measurements on the specified channel."), helpcontext(HID_IAGILENT34980AFREQUENCY_LOWRANGE)]
	HRESULT LowRange([in] BSTR ChannelList, [out, retval] long* val);

	[propput, helpstring("Sets or gets the lowest frequency expected in the input signal for frequency measurements on the specified channel."), helpcontext(HID_IAGILENT34980AFREQUENCY_LOWRANGE)]
	HRESULT LowRange(BSTR ChannelList, long val);

	[propget, helpstring("Returns the frequency range, this is always 3.0 Hz."), helpcontext(HID_IAGILENT34980AFREQUENCY_RANGE)]
	HRESULT Range([in] BSTR ChannelList, [out, retval] double* val);
};

[
	object, 
	library_block,
	uuid("bcbc3c11-0aca-424e-a095-d89ea7ffeb2e"),
	helpstring("IAgilent34980AMeasurement interface."), 
	helpcontext(HID_IAGILENT34980AMEASUREMENT),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980AMeasurement : IUnknown
{
	[helpstring("Changes the state of the triggering system from the idle state to the wait-for-trigger state."), helpcontext(HID_IAGILENT34980AMEASUREMENT_INITIATE)]
	HRESULT Initiate();

	[helpstring("Aborts a measurement in progress from a scan or internal DMM measurements"), helpcontext(HID_IAGILENT34980AMEASUREMENT_ABORT)]
	HRESULT Abort();

	[helpstring("Reads and erases readings from volatile memory up to the specified MaxCount."), helpcontext(HID_IAGILENT34980AMEASUREMENT_DESTRUCTIVEREAD)]
	HRESULT DestructiveRead([in] long MaxCount, [out, retval] [satype(double)] SAFEARRAY** val);

	[helpstring("Transfers readings from volatile memory to the instrument's output buffer where  you can read them into your computer."), helpcontext(HID_IAGILENT34980AMEASUREMENT_FETCH)]
	HRESULT Fetch([out, retval] [satype(BSTR)] SAFEARRAY** val);

	[helpstring("Transfers readings from volatile memory to the instrument's output buffer where you can read them into your computer."), helpcontext(HID_IAGILENT34980AMEASUREMENT_FETCHNUMBERSONLY)]
	HRESULT FetchNumbersOnly([out, retval] [satype(double)] SAFEARRAY** val);

	[helpstring("This method returns the last measurement taken on the specified channel (single channel only)."), helpcontext(HID_IAGILENT34980AMEASUREMENT_QUERYLAST)]
	HRESULT QueryLast([in] BSTR Channel, [out, retval] double* val);

	[helpstring("Changes the instrument's triggering system from the idle state to the wait-for-trigger"), helpcontext(HID_IAGILENT34980AMEASUREMENT_READ)]
	HRESULT Read([in] BSTR ChannelList, [out, retval] [satype(BSTR)] SAFEARRAY** val);

	[helpstring("Changes the instrument's triggering system from the idle state to the wait-for-trigger state."), helpcontext(HID_IAGILENT34980AMEASUREMENT_READNUMBERSONLY)]
	HRESULT ReadNumbersOnly([in] BSTR ChannelList, [out, retval] [satype(double)] SAFEARRAY** val);

	[helpstring("Reads and erases the specified number of readings from memory."), helpcontext(HID_IAGILENT34980AMEASUREMENT_REMOVEREADINGS)]
	HRESULT RemoveReadings([in] long NumReadings, [out, retval] [satype(double)] SAFEARRAY** val);

	[helpstring("Triggers the instrument from the remote interface."), helpcontext(HID_IAGILENT34980AMEASUREMENT_SENDSOFTWARETRIGGER)]
	HRESULT SendSoftwareTrigger();

	[propget, helpstring("Returns pointer to IAgilent34980ADataFormat interface."), helpcontext(HID_IAGILENT34980AMEASUREMENT_DATAFORMAT)]
	HRESULT DataFormat([out, retval] IAgilent34980ADataFormat** val);

	[propget, helpstring("Returns the total number of readings currently stored in reading memory from a scan or internal DMM measurements."), helpcontext(HID_IAGILENT34980AMEASUREMENT_READINGCOUNT)]
	HRESULT ReadingCount([out, retval] long* val);

	[propget, helpstring("Sets or gets the measurement function on the specified channel.  If the channelList parameter is empty, the function is changed on the DMM only, independent of any scan list."), helpcontext(HID_IAGILENT34980AMEASUREMENT_MEASUREMENTFUNCTION)]
	HRESULT MeasurementFunction([in] BSTR Channel, [out, retval] BSTR* val);

	[propput, helpstring("Sets or gets the measurement function on the specified channel.  If the channelList parameter is empty, the function is changed on the DMM only, independent of any scan list."), helpcontext(HID_IAGILENT34980AMEASUREMENT_MEASUREMENTFUNCTION)]
	HRESULT MeasurementFunction(BSTR Channel, BSTR val);
};

[
	object, 
	library_block,
	uuid("debf8ae0-43e7-4499-a747-17963d8b1184"),
	helpstring("IAgilent34980AMemory interface."), 
	helpcontext(HID_IAGILENT34980AMEMORY),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980AMemory : IUnknown
{
	[helpstring("Stores (saves) the current instrument state in the specified storage location."), helpcontext(HID_IAGILENT34980AMEMORY_SAVESTATE)]
	HRESULT SaveState([in] BSTR Identifier);

	[helpstring("Recalls the instrument state stored in the specified storage location."), helpcontext(HID_IAGILENT34980AMEMORY_RECALLSTATE)]
	HRESULT RecallState([in] BSTR Identifier);

	[helpstring("Deletes the contents of the specified storage location."), helpcontext(HID_IAGILENT34980AMEMORY_DELETELOCATION)]
	HRESULT DeleteLocation([in] long LocationNum, [in] VARIANT_BOOL DeleteAll);

	[propget, helpstring("Enables/disables the automatic recall of the power-down state from storage location 0 when power is turned on.  Select OFF to issue a Factory Reset."), helpcontext(HID_IAGILENT34980AMEMORY_AUTORECALL)]
	HRESULT AutoRecall([out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Enables/disables the automatic recall of the power-down state from storage location 0 when power is turned on.  Select OFF to issue a Factory Reset."), helpcontext(HID_IAGILENT34980AMEMORY_AUTORECALL)]
	HRESULT AutoRecall(VARIANT_BOOL val);

	[propget, helpstring("Returns the number of memory locations that are available for state storage.  Always returns 6."), helpcontext(HID_IAGILENT34980AMEMORY_NUMSTATES)]
	HRESULT NumStates([out, retval] long* val);

	[propget, helpstring("Sets or gets the name connected to the specified memory location."), helpcontext(HID_IAGILENT34980AMEMORY_STATENAME)]
	HRESULT StateName([in] long LocationNum, [out, retval] BSTR* val);

	[propput, helpstring("Sets or gets the name connected to the specified memory location."), helpcontext(HID_IAGILENT34980AMEMORY_STATENAME)]
	HRESULT StateName(long LocationNum, BSTR val);

	[propget, helpstring("Determines if a valid state has been stored in the specified memory location.  The valid location numbers are 1 through 5."), helpcontext(HID_IAGILENT34980AMEMORY_VALIDSTATE)]
	HRESULT ValidState([in] long LocationNum, [out, retval] VARIANT_BOOL* val);

	[propget, helpstring("This property returns the names assigned to storage locations 0 through 5."), helpcontext(HID_IAGILENT34980AMEMORY_CATALOG)]
	HRESULT Catalog([out, retval] BSTR* val);
};

[
	object, 
	library_block,
	uuid("f7b3dbe7-c02e-4f15-b191-6b98c94344c4"),
	helpstring("IAgilent34980APeriod interface."), 
	helpcontext(HID_IAGILENT34980APERIOD),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980APeriod : IUnknown
{
	[helpstring("Configure the specified channels for period measurements but does not initiate the scan."), helpcontext(HID_IAGILENT34980APERIOD_CONFIGURE)]
	HRESULT Configure([in] BSTR ChannelList, [in] double Range, [in] Agilent34980AResolutionEnum Resolution);

	[helpstring("Resets all measurement parameters on the specified channels to their default values. Then, configures the channels for period measurements and immediately sweeps through the specified channels one time."), helpcontext(HID_IAGILENT34980APERIOD_MEASURE)]
	HRESULT Measure([in] BSTR ChannelList, [in] double Range, [in] Agilent34980AResolutionEnum Resolution, [out, retval] [satype(double)] SAFEARRAY** val);

	[propget, helpstring("Sets or gets the gate time for a period or frequency measurement."), helpcontext(HID_IAGILENT34980APERIOD_APERTURE)]
	HRESULT Aperture([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Sets or gets the gate time for a period or frequency measurement."), helpcontext(HID_IAGILENT34980APERIOD_APERTURE)]
	HRESULT Aperture(BSTR ChannelList, double val);

	[propget, helpstring("Enables/Disables autoranging on the specified channel."), helpcontext(HID_IAGILENT34980APERIOD_AUTORANGE)]
	HRESULT AutoRange([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Enables/Disables autoranging on the specified channel."), helpcontext(HID_IAGILENT34980APERIOD_AUTORANGE)]
	HRESULT AutoRange(BSTR ChannelList, VARIANT_BOOL val);

	[propget, helpstring("Returns the period range, this is always 0.333333 seconds."), helpcontext(HID_IAGILENT34980APERIOD_RANGE)]
	HRESULT Range([in] BSTR ChannelList, [out, retval] double* val);
};

[
	object, 
	library_block,
	uuid("c93a8c33-5476-4d04-97d6-8cc32081e574"),
	helpstring("IAgilent34980APersonality interface."), 
	helpcontext(HID_IAGILENT34980APERSONALITY),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980APersonality : IUnknown
{
	[helpstring("Selects a personality to be active and returns a pointer to that personality."), helpcontext(HID_IAGILENT34980APERSONALITY_SELECT)]
	HRESULT Select([in] BSTR personalityName, [out, retval] IUnknown** val);

	[helpstring("Gets the names of all the personalities available."), helpcontext(HID_IAGILENT34980APERSONALITY_GETPERSONALITYNAMES)]
	HRESULT GetPersonalityNames([out, retval] [satype(BSTR)] SAFEARRAY** val);
};

[
	object, 
	library_block,
	uuid("5954f74d-91a1-4d94-b2cb-57aecae896bd"),
	helpstring("IAgilent34980ARTD interface."), 
	helpcontext(HID_IAGILENT34980ARTD),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980ARTD : IUnknown
{
	[helpstring("Resets all measurement parameters on the specified channels to their default values. Then configures the channels for temperature measurements but does not initiate the scan."), helpcontext(HID_IAGILENT34980ARTD_CONFIGURE)]
	HRESULT Configure([in] BSTR ChannelList, [in] Agilent34980AResolutionEnum Resolution, [in] Agilent34980ARTDAlphaEnum Type);

	[helpstring("Resets all measurement parameters on the specified channels to their default   values. Then configures the channels for     temperature measurements and immediately sweeps through the specified channels   one time."), helpcontext(HID_IAGILENT34980ARTD_MEASURE)]
	HRESULT Measure([in] BSTR ChannelList, [in] Agilent34980ARTDAlphaEnum Type, [in] Agilent34980AResolutionEnum Resolution, [out, retval] [satype(double)] SAFEARRAY** val);

	[propget, helpstring("Selects the nominal resistance (Ro) for 2-wire RTD measurements on the specified channels.  If you supply an empty ChannelList, this property applies to the internal DMM, independent of any channels or a scan list."), helpcontext(HID_IAGILENT34980ARTD_RESISTANCE)]
	HRESULT Resistance([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Selects the nominal resistance (Ro) for 2-wire RTD measurements on the specified channels.  If you supply an empty ChannelList, this property applies to the internal DMM, independent of any channels or a scan list."), helpcontext(HID_IAGILENT34980ARTD_RESISTANCE)]
	HRESULT Resistance(BSTR ChannelList, double val);

	[propget, helpstring("Selects the RTD type for 2-wire temperature measurements on the specified channels. If you supply an empty  ChannelList, this method applies to the internal DMM, independent of any channels or a scan list."), helpcontext(HID_IAGILENT34980ARTD_ALPHA)]
	HRESULT Alpha([in] BSTR ChannelList, [out, retval] Agilent34980ARTDAlphaEnum* val);

	[propput, helpstring("Selects the RTD type for 2-wire temperature measurements on the specified channels. If you supply an empty  ChannelList, this method applies to the internal DMM, independent of any channels or a scan list."), helpcontext(HID_IAGILENT34980ARTD_ALPHA)]
	HRESULT Alpha(BSTR ChannelList, Agilent34980ARTDAlphaEnum val);

	[propget, helpstring("Enables or Disables the measurement on the specified channel (or the DMM if channelList is empty) to be used as an external reference for a thermocouple measurement that has been configured to use an external reference."), helpcontext(HID_IAGILENT34980ARTD_ISEXTERNALREFERENCE)]
	HRESULT IsExternalReference([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Enables or Disables the measurement on the specified channel (or the DMM if channelList is empty) to be used as an external reference for a thermocouple measurement that has been configured to use an external reference."), helpcontext(HID_IAGILENT34980ARTD_ISEXTERNALREFERENCE)]
	HRESULT IsExternalReference(BSTR ChannelList, VARIANT_BOOL val);

	[propget, helpstring("Enables or disables offset compensation."), helpcontext(HID_IAGILENT34980ARTD_OCOMPENSATED)]
	HRESULT OCompensated([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Enables or disables offset compensation."), helpcontext(HID_IAGILENT34980ARTD_OCOMPENSATED)]
	HRESULT OCompensated(BSTR ChannelList, VARIANT_BOOL val);
};

[
	object, 
	library_block,
	uuid("90bfe635-cef5-442d-89dc-a5c1b125c511"),
	helpstring("IAgilent34980AResistance interface."), 
	helpcontext(HID_IAGILENT34980ARESISTANCE),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980AResistance : IUnknown
{
	[helpstring("Configures the specified channels for 2-wire measurements but does not initiate the scan."), helpcontext(HID_IAGILENT34980ARESISTANCE_CONFIGURE)]
	HRESULT Configure([in] BSTR ChannelList, [in] double Range, [in] Agilent34980AResolutionEnum Resolution);

	[helpstring("Resets all measurement parameters on the specified channels to their default values. Then, configures the channels for 2-wire resistance measurements and immediately sweeps through the specified  channels one time."), helpcontext(HID_IAGILENT34980ARESISTANCE_MEASURE)]
	HRESULT Measure([in] BSTR ChannelList, [in] double Range, [in] Agilent34980AResolutionEnum Resolution, [out, retval] [satype(double)] SAFEARRAY** val);

	[propget, helpstring("Sets or gets the measurement acquisition time (called integration time) in seconds."), helpcontext(HID_IAGILENT34980ARESISTANCE_APERTURE)]
	HRESULT Aperture([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Sets or gets the measurement acquisition time (called integration time) in seconds."), helpcontext(HID_IAGILENT34980ARESISTANCE_APERTURE)]
	HRESULT Aperture(BSTR ChannelList, double val);

	[propget, helpstring("Enables/Disables autoranging on the specified channel."), helpcontext(HID_IAGILENT34980ARESISTANCE_AUTORANGE)]
	HRESULT AutoRange([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Enables/Disables autoranging on the specified channel."), helpcontext(HID_IAGILENT34980ARESISTANCE_AUTORANGE)]
	HRESULT AutoRange(BSTR ChannelList, VARIANT_BOOL val);

	[propget, helpstring("Sets or gets the measurement acquisition time (called integration time) in number of power line cycles (PLCs) on the specified channels."), helpcontext(HID_IAGILENT34980ARESISTANCE_NPLC)]
	HRESULT NPLC([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Sets or gets the measurement acquisition time (called integration time) in number of power line cycles (PLCs) on the specified channels."), helpcontext(HID_IAGILENT34980ARESISTANCE_NPLC)]
	HRESULT NPLC(BSTR ChannelList, double val);

	[propget, helpstring("Enables or disables offset compensation."), helpcontext(HID_IAGILENT34980ARESISTANCE_OCOMPENSATED)]
	HRESULT OCompensated([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Enables or disables offset compensation."), helpcontext(HID_IAGILENT34980ARESISTANCE_OCOMPENSATED)]
	HRESULT OCompensated(BSTR ChannelList, VARIANT_BOOL val);

	[propget, helpstring("Selects the measurement range on the specified channel."), helpcontext(HID_IAGILENT34980ARESISTANCE_RANGE)]
	HRESULT Range([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Selects the measurement range on the specified channel."), helpcontext(HID_IAGILENT34980ARESISTANCE_RANGE)]
	HRESULT Range(BSTR ChannelList, double val);

	[propget, helpstring("Sets the resolution on the specified channel."), helpcontext(HID_IAGILENT34980ARESISTANCE_RESOLUTION)]
	HRESULT Resolution([in] BSTR ChannelList, [out, retval] double* val);

	[propget, helpstring("Disables or enables the autozero mode on the specified channels. If you supply an empty ChannelList, this property applies to the internal DMM, independent of any channels or a scan list"), helpcontext(HID_IAGILENT34980ARESISTANCE_AUTOZERO)]
	HRESULT AutoZero([in] BSTR ChannelList, [out, retval] Agilent34980AAutoZeroEnum* val);

	[propput, helpstring("Disables or enables the autozero mode on the specified channels. If you supply an empty ChannelList, this property applies to the internal DMM, independent of any channels or a scan list"), helpcontext(HID_IAGILENT34980ARESISTANCE_AUTOZERO)]
	HRESULT AutoZero(BSTR ChannelList, Agilent34980AAutoZeroEnum val);
};

[
	object, 
	library_block,
	uuid("e1d7c3a8-3ab6-43fd-a67a-88d5c5855989"),
	helpstring("IAgilent34980ARoute interface."), 
	helpcontext(HID_IAGILENT34980AROUTE),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980ARoute : IUnknown
{
	[helpstring("Opens all channels on the modules included in the ChannelList, and closes only the specified channels on a multiplexer or switch module."), helpcontext(HID_IAGILENT34980AROUTE_CLOSEEXCLUSIVE)]
	HRESULT CloseExclusive([in] BSTR ChannelList);

	[helpstring("Closes the specified channels on a multiplexer or switch module."), helpcontext(HID_IAGILENT34980AROUTE_CLOSE)]
	HRESULT Close([in] BSTR ChannelList);

	[helpstring("Opens the specified channels on a multiplexer or switch module."), helpcontext(HID_IAGILENT34980AROUTE_OPEN)]
	HRESULT Open([in] BSTR ChannelList);

	[helpstring("Opens all channels on the specified slot."), helpcontext(HID_IAGILENT34980AROUTE_OPENALL)]
	HRESULT OpenAll([in] long Slot);

	[propget, helpstring("Enables/Disables automatic channel delay on the specified channel."), helpcontext(HID_IAGILENT34980AROUTE_AUTODELAY)]
	HRESULT AutoDelay([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Enables/Disables automatic channel delay on the specified channel."), helpcontext(HID_IAGILENT34980AROUTE_AUTODELAY)]
	HRESULT AutoDelay(BSTR ChannelList, VARIANT_BOOL val);

	[propget, helpstring("Sets or gets the delay on a multiplexer channel"), helpcontext(HID_IAGILENT34980AROUTE_DELAY)]
	HRESULT Delay([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Sets or gets the delay on a multiplexer channel"), helpcontext(HID_IAGILENT34980AROUTE_DELAY)]
	HRESULT Delay(BSTR ChannelList, double val);

	[propget, helpstring("Sets or gets the 4-wire external scanning configuration for the specified channels without the internal DMM."), helpcontext(HID_IAGILENT34980AROUTE_FWIRE)]
	HRESULT FWire([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Sets or gets the 4-wire external scanning configuration for the specified channels without the internal DMM."), helpcontext(HID_IAGILENT34980AROUTE_FWIRE)]
	HRESULT FWire(BSTR ChannelList, VARIANT_BOOL val);

	[propget, helpstring("Waits until all switch operations are done, then returns 1."), helpcontext(HID_IAGILENT34980AROUTE_DONE)]
	HRESULT Done([out, retval] VARIANT_BOOL* val);

	[propget, helpstring("Gets the closet state of the specified channel."), helpcontext(HID_IAGILENT34980AROUTE_ISCLOSED)]
	HRESULT IsClosed([in] BSTR Channel, [out, retval] VARIANT_BOOL* val);
};

[
	object, 
	library_block,
	uuid("81efae45-0df6-4bf1-8c66-f22450dd262f"),
	helpstring("IAgilent34980AScale interface."), 
	helpcontext(HID_IAGILENT34980ASCALE),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980AScale : IUnknown
{
	[helpstring("Makes an immediate null measurement on the specified channels and store it as the offset ('B') for subsequent measurements.  This allows you to adjust for voltage or resistive offsets through your wiring to the point of the measurement."), helpcontext(HID_IAGILENT34980ASCALE_OFFSETNULL)]
	HRESULT OffsetNull([in] BSTR ChannelList);

	[propget, helpstring("Sets or gets the gain for scaled readings on the specified channel."), helpcontext(HID_IAGILENT34980ASCALE_GAIN)]
	HRESULT Gain([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Sets or gets the gain for scaled readings on the specified channel."), helpcontext(HID_IAGILENT34980ASCALE_GAIN)]
	HRESULT Gain(BSTR ChannelList, double val);

	[propget, helpstring("Sets or gets the offset for scaled readings on the specified channels."), helpcontext(HID_IAGILENT34980ASCALE_OFFSET)]
	HRESULT Offset([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Sets or gets the offset for scaled readings on the specified channels."), helpcontext(HID_IAGILENT34980ASCALE_OFFSET)]
	HRESULT Offset(BSTR ChannelList, double val);

	[propget, helpstring("Enables/Disables scaling on the specified channel."), helpcontext(HID_IAGILENT34980ASCALE_STATE)]
	HRESULT State([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Enables/Disables scaling on the specified channel."), helpcontext(HID_IAGILENT34980ASCALE_STATE)]
	HRESULT State(BSTR ChannelList, VARIANT_BOOL val);

	[propget, helpstring("Sets the custom label for scaled measurements on the specified channel.  The label can have up to three characters, including letters (A-Z), numbers (0-9), the underscore (_), or the # character for a degree symbol."), helpcontext(HID_IAGILENT34980ASCALE_UNIT)]
	HRESULT Unit([in] BSTR ChannelList, [out, retval] BSTR* val);

	[propput, helpstring("Sets the custom label for scaled measurements on the specified channel.  The label can have up to three characters, including letters (A-Z), numbers (0-9), the underscore (_), or the # character for a degree symbol."), helpcontext(HID_IAGILENT34980ASCALE_UNIT)]
	HRESULT Unit(BSTR ChannelList, BSTR val);
};

[
	object, 
	library_block,
	uuid("ed0bbc4d-816e-443d-ab9d-db5cd271b57d"),
	helpstring("IAgilent34980AScan interface."), 
	helpcontext(HID_IAGILENT34980ASCAN),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980AScan : IUnknown
{
	[helpstring("Configures the instrument for a scan."), helpcontext(HID_IAGILENT34980ASCAN_CONFIGURESCAN)]
	HRESULT ConfigureScan([in] BSTR ChannelList, [in] long SweepCount, [in] VARIANT_BOOL Ordered);

	[propget, helpstring("Returns the number of channels in the scan list."), helpcontext(HID_IAGILENT34980ASCAN_SCANSIZE)]
	HRESULT ScanSize([out, retval] long* val);

	[propget, helpstring("Sets or gets an automated scan. The specified channels supersede any channels previously defined to be part of the scan list."), helpcontext(HID_IAGILENT34980ASCAN_SCANLIST)]
	HRESULT ScanList([out, retval] BSTR* val);

	[propput, helpstring("Sets or gets an automated scan. The specified channels supersede any channels previously defined to be part of the scan list."), helpcontext(HID_IAGILENT34980ASCAN_SCANLIST)]
	HRESULT ScanList(BSTR val);

	[propget, helpstring("Returns the time at the start of the scan."), helpcontext(HID_IAGILENT34980ASCAN_SCANTIME)]
	HRESULT ScanTime([out, retval] BSTR* val);

	[propget, helpstring("Sets or gets the number of triggers that will be accepted by the internal DMM before returning to the idle trigger state."), helpcontext(HID_IAGILENT34980ASCAN_SWEEPCOUNT)]
	HRESULT SweepCount([out, retval] long* val);

	[propput, helpstring("Sets or gets the number of triggers that will be accepted by the internal DMM before returning to the idle trigger state."), helpcontext(HID_IAGILENT34980ASCAN_SWEEPCOUNT)]
	HRESULT SweepCount(long val);

	[propget, helpstring("When OFF, Scan list will be executed in the order given in the list.  When ON, the scan list will be re-ordered in ascending channel number order.  Also affects READ and MEAS commands."), helpcontext(HID_IAGILENT34980ASCAN_ORDEREDSCAN)]
	HRESULT OrderedScan([out, retval] VARIANT_BOOL* val);

	[propput, helpstring("When OFF, Scan list will be executed in the order given in the list.  When ON, the scan list will be re-ordered in ascending channel number order.  Also affects READ and MEAS commands."), helpcontext(HID_IAGILENT34980ASCAN_ORDEREDSCAN)]
	HRESULT OrderedScan(VARIANT_BOOL val);
};

[
	object, 
	library_block,
	uuid("33293209-e9ae-4104-9545-8ea955398bf0"),
	helpstring("IAgilent34980AStatistics interface."), 
	helpcontext(HID_IAGILENT34980ASTATISTICS),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980AStatistics : IUnknown
{
	[helpstring("Clears all values from the statistics registers for the specified channels.  Each channel must be a multiplexer channel that has been configured to be part of the scan list."), helpcontext(HID_IAGILENT34980ASTATISTICS_CLEARSTATISTICS)]
	HRESULT ClearStatistics([in] BSTR ChannelList);

	[propget, helpstring("Calculates the mathematical average of all readings taken on the specified channel since the start of the scan."), helpcontext(HID_IAGILENT34980ASTATISTICS_AVERAGE)]
	HRESULT Average([in] BSTR ChannelList, [out, retval] double* val);

	[propget, helpstring("Count the number of readings taken on the specified channel since the start of the scan."), helpcontext(HID_IAGILENT34980ASTATISTICS_COUNT)]
	HRESULT Count([in] BSTR ChannelList, [out, retval] long* val);

	[propget, helpstring("Returns the maximum value found on the specified channel during the scan."), helpcontext(HID_IAGILENT34980ASTATISTICS_MAXVALUE)]
	HRESULT MaxValue([in] BSTR ChannelList, [out, retval] double* val);

	[propget, helpstring("Returns the time the maximum reading was taken on the specified channel during the scan (in full time and date format)."), helpcontext(HID_IAGILENT34980ASTATISTICS_MAXVALUETIME)]
	HRESULT MaxValueTime([in] BSTR ChannelList, [out, retval] BSTR* val);

	[propget, helpstring("Returns the minimum value found on the specified channel during the scan."), helpcontext(HID_IAGILENT34980ASTATISTICS_MINVALUE)]
	HRESULT MinValue([in] BSTR ChannelList, [out, retval] double* val);

	[propget, helpstring("Returns the time the minimum reading was taken on the specified channel during the scan (in full time and date format)."), helpcontext(HID_IAGILENT34980ASTATISTICS_MINVALUETIME)]
	HRESULT MinValueTime([in] BSTR ChannelList, [out, retval] BSTR* val);

	[propget, helpstring("Calculates the peak-to-peak value (difference between the min and max reading) of all readings taken on the specified channel since the start of the scan."), helpcontext(HID_IAGILENT34980ASTATISTICS_PTPEAK)]
	HRESULT PTPeak([in] BSTR ChannelList, [out, retval] double* val);
};

[
	object, 
	library_block,
	uuid("96bcb901-be6b-4cc1-8752-5f5150b23d6d"),
	helpstring("IAgilent34980AStatus interface."), 
	helpcontext(HID_IAGILENT34980ASTATUS),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980AStatus : IUnknown
{
	[helpstring("Presets the status system"), helpcontext(HID_IAGILENT34980ASTATUS_PRESET)]
	HRESULT Preset();

	[helpstring("Configures instrument to issue an SRQ on events defined in SRQReasonEnum parameter."), helpcontext(HID_IAGILENT34980ASTATUS_CONFIGURESERVICEREQUEST)]
	HRESULT ConfigureServiceRequest([in] Agilent34980ASRQReasonEnum Reason);

	[helpstring("Clears event registers and error queue."), helpcontext(HID_IAGILENT34980ASTATUS_CLEAR)]
	HRESULT Clear();

	[propget, helpstring("This routine is used enable the propagation of bits from the register specified by parameter 2 (with the exception of the Status Byte register) into a summary bit for the specified register that gets sent on to the Status Byte.  For the Status Byte regist"), helpcontext(HID_IAGILENT34980ASTATUS_REGISTER)]
	HRESULT Register([in] Agilent34980AStatusRegisterEnum Register, [in] Agilent34980AStatusSubRegisterEnum SubRegister, [out, retval] long* val);

	[propput, helpstring("This routine is used enable the propagation of bits from the register specified by parameter 2 (with the exception of the Status Byte register) into a summary bit for the specified register that gets sent on to the Status Byte.  For the Status Byte regist"), helpcontext(HID_IAGILENT34980ASTATUS_REGISTER)]
	HRESULT Register(Agilent34980AStatusRegisterEnum Register, Agilent34980AStatusSubRegisterEnum SubRegister, long val);

	[propget, helpstring("Serial poll the instrument status byte."), helpcontext(HID_IAGILENT34980ASTATUS_SERIALPOLL)]
	HRESULT SerialPoll([out, retval] long* val);
};

[
	object, 
	library_block,
	uuid("a0032131-09b4-40b2-8b52-1bdd61961217"),
	helpstring("IAgilent34980ASystem interface."), 
	helpcontext(HID_IAGILENT34980ASYSTEM),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980ASystem : IUnknown
{
	[helpstring("Returns when all pending operations are complete or MaxTimeMilliseconds period is exceeded."), helpcontext(HID_IAGILENT34980ASYSTEM_WAITFOROPERATIONCOMPLETE)]
	HRESULT WaitForOperationComplete([in] long MaxTimeMilliseconds);

	[helpstring("Sets the instrument clock."), helpcontext(HID_IAGILENT34980ASYSTEM_SETSYSTEMTIME)]
	HRESULT SetSystemTime([in] long Hours, [in] long Mins, [in] double Seconds);

	[helpstring("Sets the instrument calendar."), helpcontext(HID_IAGILENT34980ASYSTEM_SETSYSTEMDATE)]
	HRESULT SetSystemDate([in] long Year, [in] long Month, [in] long Day);

	[helpstring("Presets the instrument to a known configuration."), helpcontext(HID_IAGILENT34980ASYSTEM_PRESET)]
	HRESULT Preset();

	[helpstring("Returns the instrument clock. The format is hh,mm,ss.sss"), helpcontext(HID_IAGILENT34980ASYSTEM_GETSYSTEMTIME)]
	HRESULT GetSystemTime([in, out] long* Hours, [in, out] long* Mins, [in, out] double* Seconds);

	[helpstring("Returns the date in the form 2004,11,21"), helpcontext(HID_IAGILENT34980ASYSTEM_GETSYSTEMDATE)]
	HRESULT GetSystemDate([in, out] long* Year, [in, out] long* Month, [in, out] long* Day);

	[helpstring("Resets the module in the specified slot to its power-on state."), helpcontext(HID_IAGILENT34980ASYSTEM_CARDRESET)]
	HRESULT CardReset([in] long SlotNum);

	[helpstring("Requests a lock on the instrument.  If granted, a 1 is returned, otherwise a 0 is returned."), helpcontext(HID_IAGILENT34980ASYSTEM_LOCKREQUEST)]
	HRESULT LockRequest([out, retval] VARIANT_BOOL* val);

	[helpstring("Releases a lock on the IO interface from which this command is executed, and decrements the lock count by 1."), helpcontext(HID_IAGILENT34980ASYSTEM_LOCKRELEASE)]
	HRESULT LockRelease();

	[helpstring("This method clears all instrument memory except for boot parameters and stored calibration constants."), helpcontext(HID_IAGILENT34980ASYSTEM_SECUREIMMEDIATE)]
	HRESULT SecureImmediate();

	[helpstring("Reads either the factory temperature threshold setting or the actual transducer temperature on a GP switch module."), helpcontext(HID_IAGILENT34980ASYSTEM_GETMODULETEMPERATURE)]
	HRESULT GetModuleTemperature([in] Agilent34980AModuleTemperatureEnum Mode, [in] long Slot, [out, retval] double* val);

	[propget, helpstring("Enables or disables asynchronos events."), helpcontext(HID_IAGILENT34980ASYSTEM_ASYNCEVENTSENABLED)]
	HRESULT AsyncEventsEnabled([out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Enables or disables asynchronos events."), helpcontext(HID_IAGILENT34980ASYSTEM_ASYNCEVENTSENABLED)]
	HRESULT AsyncEventsEnabled(VARIANT_BOOL val);

	[propget, helpstring("Returns the identity of the module in the specified slot."), helpcontext(HID_IAGILENT34980ASYSTEM_CARDTYPE)]
	HRESULT CardType([in] long SlotNum, [out, retval] BSTR* val);

	[propget, helpstring("Sets or gets the instrument calendar."), helpcontext(HID_IAGILENT34980ASYSTEM_DATE)]
	HRESULT Date([out, retval] BSTR* val);

	[propput, helpstring("Sets or gets the instrument calendar."), helpcontext(HID_IAGILENT34980ASYSTEM_DATE)]
	HRESULT Date(BSTR val);

	[propget, helpstring("Enables or disables the internal DMM."), helpcontext(HID_IAGILENT34980ASYSTEM_DMMENABLED)]
	HRESULT DMMEnabled([out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Enables or disables the internal DMM."), helpcontext(HID_IAGILENT34980ASYSTEM_DMMENABLED)]
	HRESULT DMMEnabled(VARIANT_BOOL val);

	[propget, helpstring("Queries the instrument to determine if the internal DMM is installed."), helpcontext(HID_IAGILENT34980ASYSTEM_DMMINSTALLED)]
	HRESULT DMMInstalled([out, retval] VARIANT_BOOL* val);

	[propget, helpstring("Enables or disables the instrument to set the Memory Threshold bit in the event register when the specified number of readings have been stored in reading memory during a scan."), helpcontext(HID_IAGILENT34980ASYSTEM_READINGTHRESHOLD)]
	HRESULT ReadingThreshold([out, retval] long* val);

	[propput, helpstring("Enables or disables the instrument to set the Memory Threshold bit in the event register when the specified number of readings have been stored in reading memory during a scan."), helpcontext(HID_IAGILENT34980ASYSTEM_READINGTHRESHOLD)]
	HRESULT ReadingThreshold(long val);

	[propget, helpstring("Gets the instrument serial number"), helpcontext(HID_IAGILENT34980ASYSTEM_SERIALNUMBER)]
	HRESULT SerialNumber([out, retval] BSTR* val);

	[propget, helpstring("Sets or gets the instrument clock time as a string in format hh,mm,ss.sss."), helpcontext(HID_IAGILENT34980ASYSTEM_TIME)]
	HRESULT Time([out, retval] BSTR* val);

	[propput, helpstring("Sets or gets the instrument clock time as a string in format hh,mm,ss.sss."), helpcontext(HID_IAGILENT34980ASYSTEM_TIME)]
	HRESULT Time(BSTR val);

	[propget, helpstring("Sets or gets the number of milliseconds before a query will timeout."), helpcontext(HID_IAGILENT34980ASYSTEM_TIMEOUTMILLISECONDS)]
	HRESULT TimeoutMilliseconds([out, retval] long* val);

	[propput, helpstring("Sets or gets the number of milliseconds before a query will timeout."), helpcontext(HID_IAGILENT34980ASYSTEM_TIMEOUTMILLISECONDS)]
	HRESULT TimeoutMilliseconds(long val);

	[propget, helpstring("Retrieves a pointer to the IFormattedIO488 interface."), helpcontext(HID_IAGILENT34980ASYSTEM_IO)]
	HRESULT IO([out, retval] IFormattedIO488** val);

	[propget, helpstring("Disables or enables the GPIB, USB, or LAN remote interfaces. In addition, this command disables or enables the available remote services such as Sockets, Telnet, VXI-11, and the 34980's built-in Web Interface."), helpcontext(HID_IAGILENT34980ASYSTEM_ENABLEINTERFACE)]
	HRESULT EnableInterface([in] Agilent34980AHWInterfaceEnum HWInterface, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Disables or enables the GPIB, USB, or LAN remote interfaces. In addition, this command disables or enables the available remote services such as Sockets, Telnet, VXI-11, and the 34980's built-in Web Interface."), helpcontext(HID_IAGILENT34980ASYSTEM_ENABLEINTERFACE)]
	HRESULT EnableInterface(Agilent34980AHWInterfaceEnum HWInterface, VARIANT_BOOL val);

	[propget, helpstring("Returns a string containing the IO interface that currently has the lock."), helpcontext(HID_IAGILENT34980ASYSTEM_LOCKOWNER)]
	HRESULT LockOwner([out, retval] BSTR* val);

	[propput, helpstring("Configures the specified module for 2-wire (differential) or 1-wire (single ended) operation."), helpcontext(HID_IAGILENT34980ASYSTEM_MODULEWIREMODE)]
	HRESULT ModuleWireMode(long SlotNumber, Agilent34980AWireModeEnum val);

	[propget, helpstring("Reads one event from the instrument Module Event Queue."), helpcontext(HID_IAGILENT34980ASYSTEM_MODULEEVENTS)]
	HRESULT ModuleEvents([out, retval] BSTR* val);
};

[
	object, 
	library_block,
	uuid("52f538da-8734-44df-86e9-afaff99ca5f0"),
	helpstring("IAgilent34980ATemperature interface."), 
	helpcontext(HID_IAGILENT34980ATEMPERATURE),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980ATemperature : IUnknown
{
	[propget, helpstring("Sets or gets the temperature measurements units on the specified channel."), helpcontext(HID_IAGILENT34980ATEMPERATURE_READINGUNITS)]
	HRESULT ReadingUnits([in] BSTR ChannelList, [out, retval] Agilent34980ATemperatureUnitsEnum* val);

	[propput, helpstring("Sets or gets the temperature measurements units on the specified channel."), helpcontext(HID_IAGILENT34980ATEMPERATURE_READINGUNITS)]
	HRESULT ReadingUnits(BSTR ChannelList, Agilent34980ATemperatureUnitsEnum val);

	[propget, helpstring("Retrieves a pointer to the FRTD interface."), helpcontext(HID_IAGILENT34980ATEMPERATURE_FRTD)]
	HRESULT FRTD([out, retval] IAgilent34980AFRTD** val);

	[propget, helpstring("Retrieves a pointer to the RTD interface."), helpcontext(HID_IAGILENT34980ATEMPERATURE_RTD)]
	HRESULT RTD([out, retval] IAgilent34980ARTD** val);

	[propget, helpstring("Retrieves a pointer to the Thermocouple interface."), helpcontext(HID_IAGILENT34980ATEMPERATURE_THERMOCOUPLE)]
	HRESULT Thermocouple([out, retval] IAgilent34980AThermocouple** val);

	[propget, helpstring("Retrieves a pointer to the Thermistor interface."), helpcontext(HID_IAGILENT34980ATEMPERATURE_THERMISTOR)]
	HRESULT Thermistor([out, retval] IAgilent34980AThermistor** val);

	[propget, helpstring("Disables or enables the autozero mode on the specified channels. If you supply an empty ChannelList, this property applies to the internal DMM, independent of any channels or a scan list"), helpcontext(HID_IAGILENT34980ATEMPERATURE_AUTOZERO)]
	HRESULT AutoZero([in] BSTR ChannelList, [out, retval] Agilent34980AAutoZeroEnum* val);

	[propput, helpstring("Disables or enables the autozero mode on the specified channels. If you supply an empty ChannelList, this property applies to the internal DMM, independent of any channels or a scan list"), helpcontext(HID_IAGILENT34980ATEMPERATURE_AUTOZERO)]
	HRESULT AutoZero(BSTR ChannelList, Agilent34980AAutoZeroEnum val);

	[propget, helpstring("Sets or gets the measurement acquisition time (called integration time) in number of power line cycles (PLCs) on the specified channels."), helpcontext(HID_IAGILENT34980ATEMPERATURE_NPLC)]
	HRESULT NPLC([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Sets or gets the measurement acquisition time (called integration time) in number of power line cycles (PLCs) on the specified channels."), helpcontext(HID_IAGILENT34980ATEMPERATURE_NPLC)]
	HRESULT NPLC(BSTR ChannelList, double val);

	[propget, helpstring("Sets or gets the temperature transducer probe type to use for measurements on  the specified channels."), helpcontext(HID_IAGILENT34980ATEMPERATURE_TRANSDUCERTYPE)]
	HRESULT TransducerType([in] BSTR ChannelList, [out, retval] Agilent34980ATransducerEnum* val);

	[propput, helpstring("Sets or gets the temperature transducer probe type to use for measurements on  the specified channels."), helpcontext(HID_IAGILENT34980ATEMPERATURE_TRANSDUCERTYPE)]
	HRESULT TransducerType(BSTR ChannelList, Agilent34980ATransducerEnum val);
};

[
	object, 
	library_block,
	uuid("8f241a69-baeb-407d-ad83-0f1055e5641b"),
	helpstring("IAgilent34980AThermistor interface."), 
	helpcontext(HID_IAGILENT34980ATHERMISTOR),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980AThermistor : IUnknown
{
	[helpstring("Resets all measurement parameters on the specified channels to their default values. Then, configures the channels for temperature measurements but does not initiate the scan."), helpcontext(HID_IAGILENT34980ATHERMISTOR_CONFIGURE)]
	HRESULT Configure([in] BSTR ChannelList, [in] Agilent34980AResolutionEnum Resolution, [in] Agilent34980AThermistorEnum Type);

	[helpstring("Resets all measurement parameters on the specified channels to their default  values. Then, configures the    channels for temperature measurements and immediately sweeps through the specified  channels one time."), helpcontext(HID_IAGILENT34980ATHERMISTOR_MEASURE)]
	HRESULT Measure([in] BSTR ChannelList, [in] Agilent34980AThermistorEnum Type, [in] Agilent34980AResolutionEnum Resolution, [out, retval] [satype(double)] SAFEARRAY** val);

	[propget, helpstring("Sets or gets the thermistor type for temperature measurements on the specified channels."), helpcontext(HID_IAGILENT34980ATHERMISTOR_RESISTANCE)]
	HRESULT Resistance([in] BSTR ChannelList, [out, retval] Agilent34980AThermistorEnum* val);

	[propput, helpstring("Sets or gets the thermistor type for temperature measurements on the specified channels."), helpcontext(HID_IAGILENT34980ATHERMISTOR_RESISTANCE)]
	HRESULT Resistance(BSTR ChannelList, Agilent34980AThermistorEnum val);

	[propget, helpstring("Disables or enables the specified thermistor channels to be used as the reference channel for subsequent thermocouple measurements that specify an external reference source."), helpcontext(HID_IAGILENT34980ATHERMISTOR_ISEXTERNALREFERENCE)]
	HRESULT IsExternalReference([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Disables or enables the specified thermistor channels to be used as the reference channel for subsequent thermocouple measurements that specify an external reference source."), helpcontext(HID_IAGILENT34980ATHERMISTOR_ISEXTERNALREFERENCE)]
	HRESULT IsExternalReference(BSTR ChannelList, VARIANT_BOOL val);
};

[
	object, 
	library_block,
	uuid("67c8df42-2b2d-43e8-862d-069f3c0c0ff6"),
	helpstring("IAgilent34980AThermocouple interface."), 
	helpcontext(HID_IAGILENT34980ATHERMOCOUPLE),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980AThermocouple : IUnknown
{
	[helpstring("Resets all measurement parameters on the specified channels to their default values. Then, configures the channels for temperature measurements but does not initiate the scan."), helpcontext(HID_IAGILENT34980ATHERMOCOUPLE_CONFIGURE)]
	HRESULT Configure([in] BSTR ChannelList, [in] Agilent34980AResolutionEnum Resolution, [in] Agilent34980AThermocoupleEnum Type);

	[helpstring("Resets all measurement parameters on the specified channels to their default  values. Then, configures the channels for    temperature measurements and immediately sweeps through the specified channels  one time."), helpcontext(HID_IAGILENT34980ATHERMOCOUPLE_MEASURE)]
	HRESULT Measure([in] BSTR ChannelList, [in] Agilent34980AThermocoupleEnum Type, [in] Agilent34980AResolutionEnum Resolution, [out, retval] [satype(double)] SAFEARRAY** val);

	[propget, helpstring("Sets or gets the temperature transducer probe type to use for measurements on the specified channels."), helpcontext(HID_IAGILENT34980ATHERMOCOUPLE_THERMOCOUPLETYPE)]
	HRESULT ThermocoupleType([in] BSTR ChannelList, [out, retval] Agilent34980AThermocoupleEnum* val);

	[propput, helpstring("Sets or gets the temperature transducer probe type to use for measurements on the specified channels."), helpcontext(HID_IAGILENT34980ATHERMOCOUPLE_THERMOCOUPLETYPE)]
	HRESULT ThermocoupleType(BSTR ChannelList, Agilent34980AThermocoupleEnum val);

	[propget, helpstring("Sets or gets the reference junction source for thermocouple measurements on the specified channels."), helpcontext(HID_IAGILENT34980ATHERMOCOUPLE_REFERENCEJUNCTIONTYPE)]
	HRESULT ReferenceJunctionType([in] BSTR ChannelList, [out, retval] Agilent34980ARJunctionEnum* val);

	[propput, helpstring("Sets or gets the reference junction source for thermocouple measurements on the specified channels."), helpcontext(HID_IAGILENT34980ATHERMOCOUPLE_REFERENCEJUNCTIONTYPE)]
	HRESULT ReferenceJunctionType(BSTR ChannelList, Agilent34980ARJunctionEnum val);

	[propget, helpstring("Gets the fixed reference junction temperature in degrees Celsius for thermocouple   measurements on the specified channels."), helpcontext(HID_IAGILENT34980ATHERMOCOUPLE_FIXEDREFERENCEJUNCTION)]
	HRESULT FixedReferenceJunction([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Gets the fixed reference junction temperature in degrees Celsius for thermocouple   measurements on the specified channels."), helpcontext(HID_IAGILENT34980ATHERMOCOUPLE_FIXEDREFERENCEJUNCTION)]
	HRESULT FixedReferenceJunction(BSTR ChannelList, double val);

	[propget, helpstring("Disables or enables the thermocouple check feature to verify that your thermocouples are properly connected to the screw terminals for measurements."), helpcontext(HID_IAGILENT34980ATHERMOCOUPLE_CHECK)]
	HRESULT Check([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Disables or enables the thermocouple check feature to verify that your thermocouples are properly connected to the screw terminals for measurements."), helpcontext(HID_IAGILENT34980ATHERMOCOUPLE_CHECK)]
	HRESULT Check(BSTR ChannelList, VARIANT_BOOL val);

	[propget, helpstring("Disables or enables the automatic input resistance mode for dc voltage measurements on the specified channels."), helpcontext(HID_IAGILENT34980ATHERMOCOUPLE_AUTOIMPEDANCE)]
	HRESULT AutoImpedance([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Disables or enables the automatic input resistance mode for dc voltage measurements on the specified channels."), helpcontext(HID_IAGILENT34980ATHERMOCOUPLE_AUTOIMPEDANCE)]
	HRESULT AutoImpedance(BSTR ChannelList, VARIANT_BOOL val);

	[propget, helpstring("Returns the most-recently stored external reference temperature value for thermocouple measurements."), helpcontext(HID_IAGILENT34980ATHERMOCOUPLE_EXTERNALREFERENCEJUNCTION)]
	HRESULT ExternalReferenceJunction([out, retval] double* val);

	[propget, helpstring("Returns the internal reference junction temperature for thermocouple measurements on the specified channels"), helpcontext(HID_IAGILENT34980ATHERMOCOUPLE_INTERNALREFERENCEJUNCTION)]
	HRESULT InternalReferenceJunction([in] BSTR ChannelList, [out, retval] double* val);
};

[
	object, 
	library_block,
	uuid("bed97581-4c5c-4cdc-b8b9-63a1073d92a0"),
	helpstring("IAgilent34980ATrigger interface."), 
	helpcontext(HID_IAGILENT34980ATRIGGER),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980ATrigger : IUnknown
{
	[helpstring("Configures the trigger subsystem with desired source, trigger count, timer and sample count."), helpcontext(HID_IAGILENT34980ATRIGGER_CONFIGURE)]
	HRESULT Configure([in] Agilent34980ATriggerSourceEnum Source, [in] long TriggerCount, [in] double Timer, [in] long SampleCount);

	[propget, helpstring("Sets or gets the number of readings (samples) that will be taken on each channel in the scan list, or on the DMM if the scan list is empty, when either the Initiate, Read, or ReadNumbersOnly method is executed."), helpcontext(HID_IAGILENT34980ATRIGGER_SAMPLECOUNT)]
	HRESULT SampleCount([out, retval] long* val);

	[propput, helpstring("Sets or gets the number of readings (samples) that will be taken on each channel in the scan list, or on the DMM if the scan list is empty, when either the Initiate, Read, or ReadNumbersOnly method is executed."), helpcontext(HID_IAGILENT34980ATRIGGER_SAMPLECOUNT)]
	HRESULT SampleCount(long val);

	[propget, helpstring("Sets/gets the number of triggers that will be used to complete the measurement started with either the Measurement Initiate, Read, or ReadNumbersOnly method."), helpcontext(HID_IAGILENT34980ATRIGGER_COUNT)]
	HRESULT Count([out, retval] long* val);

	[propput, helpstring("Sets/gets the number of triggers that will be used to complete the measurement started with either the Measurement Initiate, Read, or ReadNumbersOnly method."), helpcontext(HID_IAGILENT34980ATRIGGER_COUNT)]
	HRESULT Count(long val);

	[propget, helpstring("Sets or gets the trigger source for measurements."), helpcontext(HID_IAGILENT34980ATRIGGER_SOURCE)]
	HRESULT Source([out, retval] Agilent34980ATriggerSourceEnum* val);

	[propput, helpstring("Sets or gets the trigger source for measurements."), helpcontext(HID_IAGILENT34980ATRIGGER_SOURCE)]
	HRESULT Source(Agilent34980ATriggerSourceEnum val);

	[propget, helpstring("Sets/gets the trigger-to-trigger interval (in seconds) for measurements started with the Initiate routine that have a trigger count greater than 1 and a trigger source setting of TIMer."), helpcontext(HID_IAGILENT34980ATRIGGER_TIMER)]
	HRESULT Timer([out, retval] double* val);

	[propput, helpstring("Sets/gets the trigger-to-trigger interval (in seconds) for measurements started with the Initiate routine that have a trigger count greater than 1 and a trigger source setting of TIMer."), helpcontext(HID_IAGILENT34980ATRIGGER_TIMER)]
	HRESULT Timer(double val);

	[propget, helpstring("This setting overrides the automatic trigger delay calculated by the instrument, and adds a delay between the trigger signal and the first reading taken on a DMM only measurement (a measurement taken with the Scan List set to empty, and started with one o"), helpcontext(HID_IAGILENT34980ATRIGGER_DELAY)]
	HRESULT Delay([out, retval] double* val);

	[propput, helpstring("This setting overrides the automatic trigger delay calculated by the instrument, and adds a delay between the trigger signal and the first reading taken on a DMM only measurement (a measurement taken with the Scan List set to empty, and started with one o"), helpcontext(HID_IAGILENT34980ATRIGGER_DELAY)]
	HRESULT Delay(double val);

	[propget, helpstring("Disables or enables an automatic trigger delay."), helpcontext(HID_IAGILENT34980ATRIGGER_DELAYAUTO)]
	HRESULT DelayAuto([out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Disables or enables an automatic trigger delay."), helpcontext(HID_IAGILENT34980ATRIGGER_DELAYAUTO)]
	HRESULT DelayAuto(VARIANT_BOOL val);
};

[
	object, 
	library_block,
	uuid("73b694c4-39c4-4500-918c-4a132374aabf"),
	helpstring("IAgilent34980AVoltage interface."), 
	helpcontext(HID_IAGILENT34980AVOLTAGE),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980AVoltage : IUnknown
{
	[propget, helpstring("Retrieves pointer to the ACVoltage interface."), helpcontext(HID_IAGILENT34980AVOLTAGE_ACVOLTAGE)]
	HRESULT ACVoltage([out, retval] IAgilent34980AACVoltage** val);

	[propget, helpstring("Retrieves pointer to the DCVoltage interface."), helpcontext(HID_IAGILENT34980AVOLTAGE_DCVOLTAGE)]
	HRESULT DCVoltage([out, retval] IAgilent34980ADCVoltage** val);
};

[
	object, 
	library_block,
	uuid("d5983c4e-29c1-44db-bc32-b59c309d1473"),
	helpstring("IAgilent34980AAlarm2 interface."), 
	helpcontext(HID_IAGILENT34980AALARM2),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980AAlarm2 : IAgilent34980AAlarm
{
	[propget, helpstring("Returns the sequence name associated with the specified alarm index."), helpcontext(HID_IAGILENT34980AALARM2_ALARMSEQUENCE)]
	HRESULT AlarmSequence([in] long Index, [out, retval] BSTR* val);
};

[
	object, 
	library_block,
	uuid("07678a7d-048a-42a6-8884-6cc8c575bd1f"),
	helpstring("IAgilent34980A interface."), 
	helpcontext(HID_IAGILENT34980A2),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980A2 : IIviDriver
{
	[propget, helpstring("Returns pointer to the instrument specific Alarm interface"), helpcontext(HID_IAGILENT34980A2_ALARM)]
	HRESULT Alarm([out, retval] IAgilent34980AAlarm2** val);

	[propget, helpstring("Returns pointer to the instrument specific Route interface"), helpcontext(HID_IAGILENT34980A2_ROUTE)]
	HRESULT Route([out, retval] IAgilent34980ARoute2** val);

	[propget, helpstring("Returns pointer to the instrument specific Status interface"), helpcontext(HID_IAGILENT34980A2_STATUS)]
	HRESULT Status([out, retval] IAgilent34980AStatus2** val);

	[propget, helpstring("Returns pointer to the instrument specific Calibration interface"), helpcontext(HID_IAGILENT34980A2_CALIBRATION)]
	HRESULT Calibration([out, retval] IAgilent34980ACalibration** val);

	[propget, helpstring("Returns pointer to the instrument specific Current interface"), helpcontext(HID_IAGILENT34980A2_CURRENT)]
	HRESULT Current([out, retval] IAgilent34980ACurrent** val);

	[propget, helpstring("Returns pointer to the Diagnostic interface"), helpcontext(HID_IAGILENT34980A2_DIAGNOSTIC)]
	HRESULT Diagnostic([out, retval] IAgilent34980ADiagnostic** val);

	[propget, helpstring("Returns pointer to the instrument specific Frequency interface"), helpcontext(HID_IAGILENT34980A2_FREQUENCY)]
	HRESULT Frequency([out, retval] IAgilent34980AFrequency** val);

	[propget, helpstring("Returns pointer to the instrument specific FResistance interface"), helpcontext(HID_IAGILENT34980A2_FRESISTANCE)]
	HRESULT FResistance([out, retval] IAgilent34980AFResistance** val);

	[propget, helpstring("Returns pointer to the instrument specific Measurement interface"), helpcontext(HID_IAGILENT34980A2_MEASUREMENT)]
	HRESULT Measurement([out, retval] IAgilent34980AMeasurement** val);

	[propget, helpstring("Returns pointer to the instrument specific Memory interface"), helpcontext(HID_IAGILENT34980A2_MEMORY)]
	HRESULT Memory([out, retval] IAgilent34980AMemory** val);

	[propget, helpstring("Returns pointer to the instrument specific Period interface"), helpcontext(HID_IAGILENT34980A2_PERIOD)]
	HRESULT Period([out, retval] IAgilent34980APeriod** val);

	[propget, helpstring("Returns pointer to the instrument specific Personality interface"), helpcontext(HID_IAGILENT34980A2_PERSONALITY)]
	HRESULT Personality([out, retval] IAgilent34980APersonality** val);

	[propget, helpstring("Returns pointer to the instrument specific Resistance interface"), helpcontext(HID_IAGILENT34980A2_RESISTANCE)]
	HRESULT Resistance([out, retval] IAgilent34980AResistance** val);

	[propget, helpstring("Returns pointer to the instrument specific Scale interface"), helpcontext(HID_IAGILENT34980A2_SCALE)]
	HRESULT Scale([out, retval] IAgilent34980AScale** val);

	[propget, helpstring("Returns pointer to the instrument specific Scan interface"), helpcontext(HID_IAGILENT34980A2_SCAN)]
	HRESULT Scan([out, retval] IAgilent34980AScan** val);

	[propget, helpstring("Returns pointer to the instrument specific Statistics interface"), helpcontext(HID_IAGILENT34980A2_STATISTICS)]
	HRESULT Statistics([out, retval] IAgilent34980AStatistics** val);

	[propget, helpstring("Returns pointer to the instrument specific System interface"), helpcontext(HID_IAGILENT34980A2_SYSTEM)]
	HRESULT System([out, retval] IAgilent34980ASystem** val);

	[propget, helpstring("Returns pointer to the instrument specific Temperature interface"), helpcontext(HID_IAGILENT34980A2_TEMPERATURE)]
	HRESULT Temperature([out, retval] IAgilent34980ATemperature** val);

	[propget, helpstring("Returns pointer to the instrument specific Trigger interface"), helpcontext(HID_IAGILENT34980A2_TRIGGER)]
	HRESULT Trigger([out, retval] IAgilent34980ATrigger** val);

	[propget, helpstring("Returns pointer to the instrument specific instrument specific Voltage interface"), helpcontext(HID_IAGILENT34980A2_VOLTAGE)]
	HRESULT Voltage([out, retval] IAgilent34980AVoltage** val);

	[propget, helpstring("Returns pointer to the instrument specific Display interface"), helpcontext(HID_IAGILENT34980A2_DISPLAY)]
	HRESULT Display([out, retval] IAgilent34980ADisplay** val);
};

[
	object, 
	library_block,
	uuid("5d6cf2d5-c05e-4c02-bc9d-b24f016281ea"),
	helpstring("IAgilent34980ARoute2 interface."), 
	helpcontext(HID_IAGILENT34980AROUTE2),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980ARoute2 : IAgilent34980ARoute
{
	[helpstring("Associates a user-specified name with a SCPI sequence and stores it in non-volatile memory."), helpcontext(HID_IAGILENT34980AROUTE2_SEQUENCEDEFINE)]
	HRESULT SequenceDefine([in] BSTR SequenceName, [in] BSTR CommandString);

	[helpstring("Deletes a single sequence from non-volatile memory."), helpcontext(HID_IAGILENT34980AROUTE2_SEQUENCEDELETE)]
	HRESULT SequenceDelete([in] BSTR SequenceName);

	[helpstring("Deletes all defined sequences from non-volatile memory."), helpcontext(HID_IAGILENT34980AROUTE2_SEQUENCEDELETEALL)]
	HRESULT SequenceDeleteAll();

	[helpstring("Executes the SCPI sequence specified by SequenceName."), helpcontext(HID_IAGILENT34980AROUTE2_SEQUENCETRIGGERIMMEDIATE)]
	HRESULT SequenceTriggerImmediate([in] BSTR SequenceName);

	[propget, helpstring("Assigns a user-defined label to the specified channels."), helpcontext(HID_IAGILENT34980AROUTE2_CHANNELLABEL)]
	HRESULT ChannelLabel([in] BSTR ChannelList, [out, retval] BSTR* val);

	[propput, helpstring("Assigns a user-defined label to the specified channels."), helpcontext(HID_IAGILENT34980AROUTE2_CHANNELLABEL)]
	HRESULT ChannelLabel(BSTR ChannelList, BSTR val);

	[propget, helpstring("Returns a comma-separated list of all of the sequence names that have been defined."), helpcontext(HID_IAGILENT34980AROUTE2_SEQUENCECATALOG)]
	HRESULT SequenceCatalog([out, retval] BSTR* val);

	[propget, helpstring("Associates sequence execution with a particular alarm, or removes a previously defined association."), helpcontext(HID_IAGILENT34980AROUTE2_SEQUENCETRIGGERSOURCE)]
	HRESULT SequenceTriggerSource([in] BSTR SequenceName, [out, retval] Agilent34980ASequenceTriggerSourceEnum* val);

	[propput, helpstring("Associates sequence execution with a particular alarm, or removes a previously defined association."), helpcontext(HID_IAGILENT34980AROUTE2_SEQUENCETRIGGERSOURCE)]
	HRESULT SequenceTriggerSource(BSTR SequenceName, Agilent34980ASequenceTriggerSourceEnum val);
};

[
	object, 
	library_block,
	uuid("d14529a6-cea0-4a2b-8614-b871d1482f0b"),
	helpstring("IAgilent34980AStatus2 interface."), 
	helpcontext(HID_IAGILENT34980ASTATUS2),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34980AStatus2 : IAgilent34980AStatus
{
	[propget, helpstring("This property can be used to get (read) the contents of the Module Condition and Event registers for the device in the specified slot, and to set (write) or get (read) the Module Enable register for the device in the specified slot."), helpcontext(HID_IAGILENT34980ASTATUS2_MODULEREGISTER)]
	HRESULT ModuleRegister([in] long Slot, [in] Agilent34980AStatusSubRegisterEnum SubRegister, [out, retval] long* val);

	[propput, helpstring("This property can be used to get (read) the contents of the Module Condition and Event registers for the device in the specified slot, and to set (write) or get (read) the Module Enable register for the device in the specified slot."), helpcontext(HID_IAGILENT34980ASTATUS2_MODULEREGISTER)]
	HRESULT ModuleRegister(long Slot, Agilent34980AStatusSubRegisterEnum SubRegister, long val);
};


#endif // __INTERFACES_NIMBUS_H__
