/******************************************************************************
 *                                                                         
 *               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("aaca35b8-b40b-4ef6-93d2-17db8200157b"),
	v1_enum
]
enum Agilent34952AErrorCodesEnum
{
	E_AGILENT34952A_UNEXPECTED = 0x80044210,
	E_AGILENT34952A_PERSONALITY_NOT_ACTIVE = 0x80044211,
	E_AGILENT34952A_PERSONALITY_NOT_INSTALLED = 0x80044212,
	E_AGILENT34952A_PERSONALITY_NOT_LICENSED = 0x80044213,
	E_AGILENT34952A_IO_GENERAL = 0x80044214,
	E_AGILENT34952A_IO_TIMEOUT = 0x80044215,
	E_AGILENT34952A_MODEL_NOT_SUPPORTED = 0x80044216,
	E_AGILENT34952A_VALUE_OUT_OF_RANGE = 0x80044217,
	E_AGILENT34952A_WRAPPED_DRIVER_ERROR = 0x80044218
};


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

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

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

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


[
	export, 
	library_block, 
	uuid("468ce07d-371d-4918-8866-72c9094a12e6"),
	v1_enum, 
	helpstring("Enumeration for the comparison types."), 
	helpcontext(HID_AGILENT34952ACOMPARISONTYPEENUM)
]
enum Agilent34952AComparisonTypeEnum
{
	Agilent34952AComparisonTypeEqual = 0,
	Agilent34952AComparisonTypeNotEqual = 1
};

[
	export, 
	library_block, 
	uuid("55544aa8-9073-4687-92f9-8fc8811edbc5"),
	v1_enum, 
	helpstring("Enumeration for the digital channel width types."), 
	helpcontext(HID_AGILENT34952ADIGITALMODEENUM)
]
enum Agilent34952ADigitalModeEnum
{
	Agilent34952ADigitalModeByte = 0,
	Agilent34952ADigitalModeWord = 1,
	Agilent34952ADigitalModeLWord = 2
};

[
	export, 
	library_block, 
	uuid("1ac7aba9-59af-4c2e-91bb-dfca98355342"),
	v1_enum, 
	helpstring("Enumerates the options for digital channels - input or output."), 
	helpcontext(HID_AGILENT34952ADIRECTIONENUM)
]
enum Agilent34952ADirectionEnum
{
	Agilent34952ADirectionInput = 0,
	Agilent34952ADirectionOutput = 1
};

[
	export, 
	library_block, 
	uuid("b9cfce38-bfff-41a1-95d1-53619c71211f"),
	v1_enum, 
	helpstring("Enumeration for the slope types."), 
	helpcontext(HID_AGILENT34952ATOTALIZESLOPEENUM)
]
enum Agilent34952ATotalizeSlopeEnum
{
	Agilent34952ATotalizeSlopePositive = 0,
	Agilent34952ATotalizeSlopeNegative = 1
};

[
	export, 
	library_block, 
	uuid("aa92301f-99ef-40a0-87c5-eacbcdbb00f8"),
	v1_enum, 
	helpstring("Enumeration for the threshold types."), 
	helpcontext(HID_AGILENT34952ATOTALIZETHRESHOLDMODEENUM)
]
enum Agilent34952ATotalizeThresholdModeEnum
{
	Agilent34952ATotalizeThresholdModeAC = 0,
	Agilent34952ATotalizeThresholdModeTTL = 1
};

[
	export, 
	library_block, 
	uuid("51aba76e-7d70-4333-8152-d889ba6ede6a"),
	v1_enum, 
	helpstring("Enumeration for the totalize types."), 
	helpcontext(HID_AGILENT34952ATOTALIZETYPEENUM)
]
enum Agilent34952ATotalizeTypeEnum
{
	Agilent34952ATotalizeTypeRead = 0,
	Agilent34952ATotalizeTypeRReset = 1
};


[
	object, 
	library_block,
	uuid("8cca9b1a-784f-4962-bc47-85e66135b1d3"),
	helpstring("Agilent34952A root interface."), 
	helpcontext(HID_IAGILENT34952A),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34952A : IUnknown
{
	[propget, helpstring("Retrieves a pointer to the DAC interface."), helpcontext(HID_IAGILENT34952A_DAC)]
	HRESULT DAC([out, retval] IAgilent34952ADAC** val);

	[propget, helpstring("Retrieves a pointer to the Digital interface."), helpcontext(HID_IAGILENT34952A_DIGITAL)]
	HRESULT Digital([out, retval] IAgilent34952ADigital** val);

	[propget, helpstring("Retrieves a pointer to the Totalize interface."), helpcontext(HID_IAGILENT34952A_TOTALIZE)]
	HRESULT Totalize([out, retval] IAgilent34952ATotalize** val);
};

[
	object, 
	library_block,
	uuid("3c8c9ceb-4d8d-4210-a8c1-a017fc91e69c"),
	helpstring("IAgilent34952ADAC  interface."), 
	helpcontext(HID_IAGILENT34952ADAC),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34952ADAC : IUnknown
{
	[propget, helpstring("Sets or gets the output voltage level for the specified channels"), helpcontext(HID_IAGILENT34952ADAC_VOLTAGE)]
	HRESULT Voltage([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Sets or gets the output voltage level for the specified channels"), helpcontext(HID_IAGILENT34952ADAC_VOLTAGE)]
	HRESULT Voltage(BSTR ChannelList, double val);
};

[
	object, 
	library_block,
	uuid("892ff2ba-07be-4a92-ae32-a08dd9b03b64"),
	helpstring("IAgilent34952ADigital  interface."), 
	helpcontext(HID_IAGILENT34952ADIGITAL),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34952ADigital : IUnknown
{
	[helpstring("Configures the specified digital input or output channels for the desired width."), helpcontext(HID_IAGILENT34952ADIGITAL_CONFIGURE)]
	HRESULT Configure([in] BSTR ChannelList, [in] Agilent34952ADigitalModeEnum Mode, [in] Agilent34952ADirectionEnum Direction);

	[helpstring("Returns the last 8-bit (byte) value written to the specified output channels."), helpcontext(HID_IAGILENT34952ADIGITAL_QUERYLASTBYTE)]
	HRESULT QueryLastByte([in] BSTR ChannelList, [out, retval] BYTE* val);

	[helpstring("Returns the last 16-bit value written to the specified output channels (specified channel must be either the first channel or third channel on the module)."), helpcontext(HID_IAGILENT34952ADIGITAL_QUERYLASTWORD)]
	HRESULT QueryLastWord([in] BSTR ChannelList, [out, retval] short* val);

	[helpstring("Reads the value of the specified bit location (0 through 31) on the specified digital input channels and sends the results directly to the instrument output buffer."), helpcontext(HID_IAGILENT34952ADIGITAL_READBIT)]
	HRESULT ReadBit([in] BSTR ChannelList, [in] long BitNumber, [out, retval] VARIANT_BOOL* val);

	[helpstring("Performs an 8-bit read on the specified digital input channels and sends the results directly to the instrument's output buffer."), helpcontext(HID_IAGILENT34952ADIGITAL_READBYTE)]
	HRESULT ReadByte([in] BSTR ChannelList, [out, retval] BYTE* val);

	[helpstring("Performs a 16-bit read on the specified digital input channel (specified channel must be either the first channel or third channel on the module) and sends the results directly to the instrument's output buffer."), helpcontext(HID_IAGILENT34952ADIGITAL_READWORD)]
	HRESULT ReadWord([in] BSTR ChannelList, [out, retval] short* val);

	[helpstring("Performs a 32-bit read on the specified digital input channel (specified channel must be the first channel on a bank of 4 channels) and sends the results directly to the instrument's output buffer."), helpcontext(HID_IAGILENT34952ADIGITAL_READLONGWORD)]
	HRESULT ReadLongWord([in] BSTR ChannelList, [out, retval] long* val);

	[helpstring("Sets or clears individual bits on the specified digital output channels."), helpcontext(HID_IAGILENT34952ADIGITAL_WRITEBIT)]
	HRESULT WriteBit([in] BSTR ChannelList, [in] long BitNumber, [in] long Data);

	[helpstring("Outputs the specified 8-bit (byte) value on the specified digital output channels."), helpcontext(HID_IAGILENT34952ADIGITAL_WRITEBYTE)]
	HRESULT WriteByte([in] BSTR ChannelList, [in] BYTE Data);

	[helpstring("Outputs the specified 16-bit pattern on the specified digital output channels (must be either first or third channel on a module)."), helpcontext(HID_IAGILENT34952ADIGITAL_WRITEWORD)]
	HRESULT WriteWord([in] BSTR ChannelList, [in] short Data);

	[helpstring("Outputs the specified 32-bit pattern on the specified digital output channels (must be the first channel on a bank of 4 channels)."), helpcontext(HID_IAGILENT34952ADIGITAL_WRITELONGWORD)]
	HRESULT WriteLongWord([in] BSTR ChannelList, [in] long Data);

	[propget, helpstring("Sets or gets the data bit pattern for comparisons on the digital modules"), helpcontext(HID_IAGILENT34952ADIGITAL_COMPARISONDATA)]
	HRESULT ComparisonData([in] BSTR ChannelList, [out, retval] BYTE* val);

	[propput, helpstring("Sets or gets the data bit pattern for comparisons on the digital modules"), helpcontext(HID_IAGILENT34952ADIGITAL_COMPARISONDATA)]
	HRESULT ComparisonData(BSTR ChannelList, BYTE val);

	[propget, helpstring("Disables or enables the pattern comparison mode on the digital modules. This command applies to digital input operations on the specified bank (DIO1 or DIO2)."), helpcontext(HID_IAGILENT34952ADIGITAL_COMPARISONENABLE)]
	HRESULT ComparisonEnable([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Disables or enables the pattern comparison mode on the digital modules. This command applies to digital input operations on the specified bank (DIO1 or DIO2)."), helpcontext(HID_IAGILENT34952ADIGITAL_COMPARISONENABLE)]
	HRESULT ComparisonEnable(BSTR ChannelList, VARIANT_BOOL val);

	[propget, helpstring("Sets or gets mask bit pattern for specified channels."), helpcontext(HID_IAGILENT34952ADIGITAL_COMPARISONMASK)]
	HRESULT ComparisonMask([in] BSTR ChannelList, [out, retval] long* val);

	[propput, helpstring("Sets or gets mask bit pattern for specified channels."), helpcontext(HID_IAGILENT34952ADIGITAL_COMPARISONMASK)]
	HRESULT ComparisonMask(BSTR ChannelList, long val);

	[propget, helpstring("Sets or gets the comparison type used on the specified channels."), helpcontext(HID_IAGILENT34952ADIGITAL_COMPARISONTYPE)]
	HRESULT ComparisonType([in] BSTR ChannelList, [out, retval] Agilent34952AComparisonTypeEnum* val);

	[propput, helpstring("Sets or gets the comparison type used on the specified channels."), helpcontext(HID_IAGILENT34952ADIGITAL_COMPARISONTYPE)]
	HRESULT ComparisonType(BSTR ChannelList, Agilent34952AComparisonTypeEnum val);

	[propget, helpstring("Returns the present state (INPut or OUTput) of the specified channel."), helpcontext(HID_IAGILENT34952ADIGITAL_STATE)]
	HRESULT State([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propget, helpstring("Sets or gets the state of the channel - input or output."), helpcontext(HID_IAGILENT34952ADIGITAL_DIRECTION)]
	HRESULT Direction([in] BSTR ChannelList, [out, retval] Agilent34952ADirectionEnum* val);

	[propput, helpstring("Sets or gets the state of the channel - input or output."), helpcontext(HID_IAGILENT34952ADIGITAL_DIRECTION)]
	HRESULT Direction(BSTR ChannelList, Agilent34952ADirectionEnum val);

	[propget, helpstring("Sets or gets the data bit pattern for comparisons on the digital modules."), helpcontext(HID_IAGILENT34952ADIGITAL_COMPARISONDATABYTE)]
	HRESULT ComparisonDataByte([in] BSTR ChannelList, [out, retval] BYTE* val);

	[propput, helpstring("Sets or gets the data bit pattern for comparisons on the digital modules."), helpcontext(HID_IAGILENT34952ADIGITAL_COMPARISONDATABYTE)]
	HRESULT ComparisonDataByte(BSTR ChannelList, BYTE val);

	[propget, helpstring("Sets or gets the data bit pattern for comparisons on the digital modules."), helpcontext(HID_IAGILENT34952ADIGITAL_COMPARISONDATAWORD)]
	HRESULT ComparisonDataWord([in] BSTR ChannelList, [out, retval] short* val);

	[propput, helpstring("Sets or gets the data bit pattern for comparisons on the digital modules."), helpcontext(HID_IAGILENT34952ADIGITAL_COMPARISONDATAWORD)]
	HRESULT ComparisonDataWord(BSTR ChannelList, short val);

	[propget, helpstring("Sets or gets the data bit pattern for comparisons on the digital modules."), helpcontext(HID_IAGILENT34952ADIGITAL_COMPARISONDATALONGWORD)]
	HRESULT ComparisonDataLongWord([in] BSTR ChannelList, [out, retval] long* val);

	[propput, helpstring("Sets or gets the data bit pattern for comparisons on the digital modules."), helpcontext(HID_IAGILENT34952ADIGITAL_COMPARISONDATALONGWORD)]
	HRESULT ComparisonDataLongWord(BSTR ChannelList, long val);

	[propget, helpstring("Sets or gets the data bit pattern for comparisons on the digital modules."), helpcontext(HID_IAGILENT34952ADIGITAL_COMPARISONMASKBYTE)]
	HRESULT ComparisonMaskByte([in] BSTR ChannelList, [out, retval] BYTE* val);

	[propput, helpstring("Sets or gets the data bit pattern for comparisons on the digital modules."), helpcontext(HID_IAGILENT34952ADIGITAL_COMPARISONMASKBYTE)]
	HRESULT ComparisonMaskByte(BSTR ChannelList, BYTE val);

	[propget, helpstring("Sets or gets the data bit pattern for comparisons on the digital modules."), helpcontext(HID_IAGILENT34952ADIGITAL_COMPARISONMASKWORD)]
	HRESULT ComparisonMaskWord([in] BSTR ChannelList, [out, retval] short* val);

	[propput, helpstring("Sets or gets the data bit pattern for comparisons on the digital modules."), helpcontext(HID_IAGILENT34952ADIGITAL_COMPARISONMASKWORD)]
	HRESULT ComparisonMaskWord(BSTR ChannelList, short val);

	[propget, helpstring("Sets or gets the data bit pattern for comparisons on the digital modules."), helpcontext(HID_IAGILENT34952ADIGITAL_COMPARISONMASKLONGWORD)]
	HRESULT ComparisonMaskLongWord([in] BSTR ChannelList, [out, retval] long* val);

	[propput, helpstring("Sets or gets the data bit pattern for comparisons on the digital modules."), helpcontext(HID_IAGILENT34952ADIGITAL_COMPARISONMASKLONGWORD)]
	HRESULT ComparisonMaskLongWord(BSTR ChannelList, long val);
};

[
	object, 
	library_block,
	uuid("f49ec2bd-13ba-4a03-8d53-63a1f7f5338d"),
	helpstring("IAgilent34952ATotalize interface."), 
	helpcontext(HID_IAGILENT34952ATOTALIZE),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34952ATotalize : IUnknown
{
	[helpstring("Immediately clears the count on the specified totalizer channels"), helpcontext(HID_IAGILENT34952ATOTALIZE_CLEARTOTAL)]
	HRESULT ClearTotal([in] BSTR ChannelList);

	[helpstring("Configures specified channels on a 34952A module."), helpcontext(HID_IAGILENT34952ATOTALIZE_CONFIGURE)]
	HRESULT Configure([in] BSTR ChannelList, [in] Agilent34952ATotalizeTypeEnum Type, [in] Agilent34952ATotalizeThresholdModeEnum Mode, [in] Agilent34952ATotalizeSlopeEnum Slope);

	[helpstring("Reads the count on the specified totalizer channel."), helpcontext(HID_IAGILENT34952ATOTALIZE_READDATA)]
	HRESULT ReadData([in] BSTR ChannelList, [out, retval] double* val);

	[propget, helpstring("Sets or gets the threshold at which an edge is detected on the specified totalizer channels."), helpcontext(HID_IAGILENT34952ATOTALIZE_MODE)]
	HRESULT Mode([in] BSTR ChannelList, [out, retval] Agilent34952ATotalizeThresholdModeEnum* val);

	[propput, helpstring("Sets or gets the threshold at which an edge is detected on the specified totalizer channels."), helpcontext(HID_IAGILENT34952ATOTALIZE_MODE)]
	HRESULT Mode(BSTR ChannelList, Agilent34952ATotalizeThresholdModeEnum val);

	[propget, helpstring("Enables or disables an automatic reset of the count on the specified totalizer channels."), helpcontext(HID_IAGILENT34952ATOTALIZE_READTYPE)]
	HRESULT ReadType([in] BSTR ChannelList, [out, retval] Agilent34952ATotalizeTypeEnum* val);

	[propput, helpstring("Enables or disables an automatic reset of the count on the specified totalizer channels."), helpcontext(HID_IAGILENT34952ATOTALIZE_READTYPE)]
	HRESULT ReadType(BSTR ChannelList, Agilent34952ATotalizeTypeEnum val);

	[propget, helpstring("Sets or gets the specified totalizer channels to count on the rising edge (positive) or falling edge (negative) of the input signal."), helpcontext(HID_IAGILENT34952ATOTALIZE_SLOPE)]
	HRESULT Slope([in] BSTR ChannelList, [out, retval] Agilent34952ATotalizeSlopeEnum* val);

	[propput, helpstring("Sets or gets the specified totalizer channels to count on the rising edge (positive) or falling edge (negative) of the input signal."), helpcontext(HID_IAGILENT34952ATOTALIZE_SLOPE)]
	HRESULT Slope(BSTR ChannelList, Agilent34952ATotalizeSlopeEnum val);
};


#endif // __INTERFACES_NIMBUS_H__
