The following example for an ATEasy Driver text file. This driver is an IO Table driver for Agilent 3441A digital multimeter:
ATEasy 14.0 Driver
================================================================================
Summary
================================================================================
File =
DefaultName = DMM
Company = "Marvin Test Solutions"
Programmers = "Vic Bro"
HelpFile = ""
HelpTopic = ""
ATEasyVersion = "14.0.165.0"
AutoSaveVersion = False
PromptVersionOnSave = False
Versions =
{
Version1 = Create,victorb,Tue Dec 17 13 08:11:26
Version2 = LastSaved,Ronniey,Tue Dec 06 22 18:57:50
}
Manufacturer = Agilent Technologies
Parameters = {SkipOnInit, Number}
Description =
! Description : Agilent 34410A/11A/L4411A 6 Digit Multimeter Driver
! Manufacturer : Agilent Technologies
! Driver File : Ag3441x.drv
! Driver Type : IOTable
! Example : Ag3441x.prj, Ag3441x.prg, Ag3441x.sys
!
! Initialization:
! 1. Set the Interface type to Winsock, USB, or GPIB from the Driver Shortcut
! Interface page.
! 2. Update the current name or address of the instrument in the Interface page.
!
! Set the parameter "SkipOnInit" to 1 to not Initialize the driver in the OnInit
! event.
! By default, if this variable is left blank (or set to 0) then the driver will
! initialize the instrument in the OnInit event when you start your application.
!
! Changes:
! > Jan 18, 2017
! - Impedence commands changed to Impedance (fixed).
! - Set/GetFunctionImpedanceAuto added to set/get impedance for VDC
! measurements (new).
! - Set/GetFunctionRangeAuto added to set/get range for VDC measurements (new).
! - Command spelling of DMM Utility Message Receive was Recive. (fixed)
! - admmTriggerSourceInternal added to enumDmmTriggerSource Type.
! - Command added DMM Set Trigger Source Internal() and modify SetTriggerSource.
! - Procedure SetTriggerLevel and command DMM Set Trigger Level() added.
! - Procedure MeasureFetch and command DMM Measure Fetch() added.
! > Oct 24, 2016
! - SetFunctionIDC/IAC overwriting auto range setup (fixed).
! > Apr 29, 2015
! - SetFunctionVDC, SetFunctionVAC, SetFunctionIDC, SetFunctionIAC added
! support for AUTO range command.
! > Feb 27, 2015
! - MeasureArray - Resize the array if lMaxArraySize is greater than the array
! size.
Interfaces
================================================================================
Interface
{
Type = None
}
Interface
{
Type = Gpib
InputTerminator = "\r\n"
OutputTerminator = "\r\n"
Send Timeout = 5000
Receive Timeout = 5000
TrigTimeout = 5000
Delay = 250
ReceiveBufferSize = 2048
InputEOI = True
OutputEOI = True
}
Interface
{
Type = Usb
InputTerminator = "\n"
OutputTerminator = "\n"
Send Timeout = 5000
Receive Timeout = 5000
TrigTimeout = 5000
Delay = 250
ReceiveBufferSize = 2048
USBTMC = True
}
Interface
{
Type = WinSock
InputTerminator = "\n"
OutputTerminator = "\n"
Send Timeout = 10000
Receive Timeout = 10000
TrigTimeout = 10000
Delay = 250
ReceiveBufferSize = 2048
Protocol = 1
Server = False
ConnectTimeout = 1000
OpenOnAccess = False
}
Libraries
================================================================================
Types
================================================================================
enumDmmThermistorType: Enum Public
{
admmThermistorType2252: Long Const = 0 ! 4-Wire Thermistor 2252 Ohm
admmThermistorType5000: Long Const = 1 ! 4-Wire Thermistor 5000 Ohm
admmThermistorType10000: Long Const = 2 ! 4-Wire Thermistor 10000 Ohm
}
enumDmmReferenceFrequency: Enum Public
{
admmReferenceFrequency50or400Hz: Long Const = 0
admmReferenceFrequency60Hz: Long Const = 1
}
enumDmmReferenceResistance: Enum Public
{
admmReferenceResistance50Ohm: Long Const = 0
admmReferenceResistance75Ohm: Long Const = 1
admmReferenceResistance93Ohm: Long Const = 2
admmReferenceResistance110Ohm: Long Const = 3
admmReferenceResistance124Ohm: Long Const = 4
admmReferenceResistance125Ohm: Long Const = 5
admmReferenceResistance135Ohm: Long Const = 6
admmReferenceResistance150Ohm: Long Const = 7
admmReferenceResistance250Ohm: Long Const = 8
admmReferenceResistance300Ohm: Long Const = 9
admmReferenceResistance500Ohm: Long Const = 10
admmReferenceResistance600Ohm: Long Const = 11
admmReferenceResistance800Ohm: Long Const = 12
admmReferenceResistance900Ohm: Long Const = 13
admmReferenceResistance1000Ohm: Long Const = 14
admmReferenceResistance1200Ohm: Long Const = 15
admmReferenceResistance8000Ohm: Long Const = 16
}
enumDmmFormatBorder: Enum Public
{
admmFormatBorderNormal: Long Const = 0
admmFormatBorderSwapped: Long Const = 1
}
enumDmmFormatData: Enum Public
{
admmFormatDataAscii: Long Const = 0
admmFormatDataReal: Long Const = 1
}
enumDmmFormatPhase: Enum Public
{
admmFormatPhaseAuto: Long Const = 0
admmFormatPhasePositive: Long Const = 1
admmFormatPhaseCentered: Long Const = 2
}
enumDmmDisplayFeed: Enum Public
{
admmDisplayFeedCalcAverage: Long Const = 0
admmDisplayFeedCalcMin: Long Const = 1
admmDisplayFeedCalcMax: Long Const = 2
admmDisplayFeedCalcStdDev: Long Const = 3
admmDisplayFeedCalcCount: Long Const = 4
admmDisplayFeedVoltMax: Long Const = 5
admmDisplayFeedVoltMin: Long Const = 6
admmDisplayFeedVoltPeakToPeak: Long Const = 7
admmDisplayFeedVoltACPeakToPeak: Long Const = 8
admmDisplayFeedCurrentMax: Long Const = 9
admmDisplayFeedCurrentMin: Long Const = 10
admmDisplayFeedCurrentPeakToPeak: Long Const = 11
admmDisplayFeedCurrentACPeakToPeak: Long Const = 12
admmDisplayFeedVoltAC: Long Const = 13
admmDisplayFeed2WireRes: Long Const = 14
admmDisplayFeed4WireRes: Long Const = 15
}
enumDmmTransducerType: Enum Public
{
admmTransducerType4WireRTD: Long Const = 0
admmTransducerType2WireRTD: Long Const = 3
admmTransducerType4WireThermistor: Long Const = 1
admmTransducerType2WireThermistor: Long Const = 2
}
enumDmmTriggerSlope: Enum Public
{
admmTriggerSlopePositive: Long Const = 0
admmTriggerSlopeNegative: Long Const = 1
}
enumDmmTriggerSource: Enum Public
{
admmTriggerSourceImmediate: Long Const = 0
admmTriggerSourceBus: Long Const = 2
admmTriggerSourceExternal: Long Const = 1
admmTriggerSourceInternal: Long Const = 3
}
enumDmmStatusRegisterOperation: Enum Public
{
admmStatusRegisterOperationCalibrationInProgress: Long Const = 1
admmStatusRegisterOperationMeasuring: Long Const = 16
admmStatusRegisterOperationWaitingForTrigger: Long Const = 32
admmStatusRegisterOperationConfigurationChange: Long Const = 256
admmStatusRegisterOperationMemoryThreshold: Long Const = 512
admmStatusRegisterOperationInstrumentLocked: Long Const = 1024
}
enumDmmStatusRegisterQuestionable: Enum Public
{
admmStatusRegisterQuestionableVoltageOverload: Long Const = 1
admmStatusRegisterQuestionableCurrentOverload: Long Const = 2
admmStatusRegisterQuestionableSampleTimingViolation: Long Const = 4
admmStatusRegisterQuestionableTemperatureOverload: Long Const = 16
admmStatusRegisterQuestionableFrequencyOverload: Long Const = 32
admmStatusRegisterQuestionableCalibrationCorrupt: Long Const = 256
admmStatusRegisterQuestionableResistanceOverload: Long Const = 512
admmStatusRegisterQuestionableLowerLimitFailed: Long Const = 2048
admmStatusRegisterQuestionableUpperLimitFailed: Long Const = 4096
admmStatusRegisterQuestionableCapacitanceOverload: Long Const = 16384
admmStatusRegisterQuestionableMemoryOverflow: Long Const = 8
}
enumDmmMemoryType: Enum Public
{
admmMemoryTypeReading: Long Const = 0
admmMemoryTypeNonVolatile: Long Const = 1
}
enumDmmMemoryLocation: Enum Public
{
admmMemoryLocation0: Long Const = 0
admmMemoryLocation1: Long Const = 1
admmMemoryLocation2: Long Const = 2
admmMemoryLocation3: Long Const = 3
admmMemoryLocation4: Long Const = 4
}
enumDmmTemperatureUnits: Enum Public
{
admmTemperatureUnitsCelsius: Long Const = 0
admmTemperatureUnitsFahrenheit: Long Const = 1
admmTemperatureUnitsKelvin: Long Const = 2
}
enumDmmDataFormat: Enum Public
{
admmDataFormatAscii: Long Const = 0
admmDataFormatReal: Long Const = 1
}
enumDmmState: Enum Public
{
admmStateOff: Long Const = 0
admmStateOn: Long Const = 1
}
enumDmmACBandwidth: Enum Public
{
admmACBandwidth3Hz: Long Const = 0
admmACBandwidth20Hz: Long Const = 1
admmACBandwidth200Hz: Long Const = 2
}
enumDmmAttrOperation: Enum Public
{
admmAttrOperationGet: Long Const = 0
admmAttrOperationSet: Long Const = 1
}
enumDmmCalculateFunction: Enum Public
{
admmCalculateFunctionNull: Long Const = 0
admmCalculateFunctionDB: Long Const = 1
admmCalculateFunctionDBM: Long Const = 2
admmCalculateFunctionAverage: Long Const = 3
admmCalculateFunctionLimit: Long Const = 4
}
enumDmmHardwareInterface: Enum Public
{
admmHardwareInterfaceGPIB: Long Const = 0
admmHardwareInterfaceUSB: Long Const = 1
admmHardwareInterfaceSockets: Long Const = 2
admmHardwareInterfaceTelnet: Long Const = 3
admmHardwareInterfaceVXI: Long Const = 4
admmHardwareInterfaceWeb: Long Const = 5
admmHardwareInterfaceLAN: Long Const = 6
}
enumDmmFunction: Enum Public
{
admmFunctionCapacitance: Long Const = 0
admmFunctionContinuity: Long Const = 1
admmFunctionCurrentAC: Long Const = 2
admmFunctionCurrentDC: Long Const = 3
admmFunctionDiode: Long Const = 4
admmFunctionFrequency: Long Const = 5
admmFunction4WireResistance: Long Const = 6
admmFunctionPeriod: Long Const = 7
admmFunction2WireResistance: Long Const = 8
admmFunctionTemperature: Long Const = 9
admmFunctionVoltageAC: Long Const = 10
admmFunctionVoltageDC: Long Const = 11
}
enumDmmSampleTriggerSource: Enum Public
{
admmSampleTriggerSourceImmediate: Long Const = 0
admmSampleTriggerSourceTimer: Long Const = 1
}
Forms
================================================================================
Commands
================================================================================
Set
{
AC
{
Frequency: SetACFrequency()
FrequencyVoltageRange: SetACFrequencyVoltageRange()
}
AutoZero: SetAutoZero()
{
Off: SetAutoZero(admmStateOff)
On: SetAutoZero(admmStateOn)
}
Aperture: SetAperture()
{
Min: SetAperture(0.00002)
Max: SetAperture(1)
}
Format
{
Border: SetFormatBorder()
Data: SetFormatData()
Phase: SetFormatPhase()
}
Function
{
VAC: SetFunctionVAC(,)
{
Auto: SetFunctionVAC(-1,0)
100mV: SetFunctionVAC(0.1,0)
1V: SetFunctionVAC(1,0)
10V: SetFunctionVAC(10,0)
100V: SetFunctionVAC(100,0)
1000V: SetFunctionVAC(1000,0)
}
VDC: SetFunctionVDC(,)
{
Auto: SetFunctionVDC(-1,)
100mV: SetFunctionVDC(0.1,)
1V: SetFunctionVDC(1,)
10V: SetFunctionVDC(10,)
100V: SetFunctionVDC(100,)
1000V: SetFunctionVDC(1000,)
Impedance
{
Auto: SetFunctionVDCImpedanceAuto()
{
On: SetFunctionVDCImpedanceAuto(admmStateOn)
Off: SetFunctionVDCImpedanceAuto(admmStateOff)
}
}
Range
{
Auto: SetFunctionVDCRangeAuto()
{
On: SetFunctionVDCRangeAuto(admmStateOn)
Off: SetFunctionVDCRangeAuto(admmStateOff)
}
}
}
IAC: SetFunctionIAC(,)
{
Auto: SetFunctionIAC(-1,0)
100uA: SetFunctionIAC(0.0001,0)
1mA: SetFunctionIAC(0.001,0)
10mA: SetFunctionIAC(0.01,0)
100mA: SetFunctionIAC(0.1,0)
1A: SetFunctionIAC(1,0)
3A: SetFunctionIAC(3,0)
}
IDC: SetFunctionIDC(,)
{
Auto: SetFunctionIDC(-1,0)
100uA: SetFunctionIDC(0.0001,0)
1mA: SetFunctionIDC(0.001,0)
10mA: SetFunctionIDC(0.01,0)
100mA: SetFunctionIDC(0.1,0)
1A: SetFunctionIDC(1,0)
3A: SetFunctionIDC(3,0)
}
Resistance
{
2Wire: SetFunctionResistanceTwoWire(,)
{
Auto: SetFunctionResistanceTwoWire(-1,0)
100Ohm: SetFunctionResistanceTwoWire(100,0.01)
1KOhm: SetFunctionResistanceTwoWire(1000,0.1)
10KOhm: SetFunctionResistanceTwoWire(10000,1)
100KOhm: SetFunctionResistanceTwoWire(100000,10)
1MOhm: SetFunctionResistanceTwoWire(1000000,100)
10MOhm: SetFunctionResistanceTwoWire(10000000,1000)
100MOhm: SetFunctionResistanceTwoWire(100000000,10000)
1GOhm: SetFunctionResistanceTwoWire(1000000000,100000)
}
4Wire: SetFunctionResistanceFourWire(,)
{
Auto: SetFunctionResistanceFourWire(-1,0)
100Ohm: SetFunctionResistanceFourWire(100,0.01)
1KOhm: SetFunctionResistanceFourWire(1000,0.1)
10KOhm: SetFunctionResistanceFourWire(10000,1)
100KOhm: SetFunctionResistanceFourWire(100000,10)
1MOhm: SetFunctionResistanceFourWire(1000000,100)
10MOhm: SetFunctionResistanceFourWire(10000000,1000)
100MOhm: SetFunctionResistanceFourWire(100000000,10000)
1GOhm: SetFunctionResistanceFourWire(1000000000,100000)
}
}
Diode: SetFunctionDiode()
Continuity: SetFunctionContinuity()
Capacitance: SetFunctionCapacitance(,)
{
Auto: SetFunctionCapacitance(-1,0)
1nF: SetFunctionCapacitance(0.000000001,0)
10nF: SetFunctionCapacitance(0.00000001,0)
100nF: SetFunctionCapacitance(0.0000001,0)
1uF: SetFunctionCapacitance(0.000001,0)
10uF: SetFunctionCapacitance(0.00001,0)
}
Frequency: SetFunctionFrequency(,)
{
3Hz: SetFunctionFrequency(3,0.003)
20Hz: SetFunctionFrequency(20,0.02)
100Hz: SetFunctionFrequency(100,0.1)
1KHz: SetFunctionFrequency(1000,1)
10KHz: SetFunctionFrequency(10000,10)
100KHz: SetFunctionFrequency(100000,100)
300KHz: SetFunctionFrequency(300000,300)
}
Period: SetFunctionPeriod(,)
{
3_336uS: SetFunctionPeriod(0.000003336,0.0000000003336)
1mS: SetFunctionPeriod(0.001,0.0000001)
50mS: SetFunctionPeriod(0.05,0.000005)
333_33mS: SetFunctionPeriod(0.33333,0.00033333)
}
Temperature
{
2WireRTD: SetFunctionTemperatureTwoWireRTD()
2WireThermistor: SetFunctionTemperatureTwoWireThermistor(,)
{
2252: SetFunctionTemperatureTwoWireThermistor(admmThermistorType2252,0)
5000: SetFunctionTemperatureTwoWireThermistor(admmThermistorType5000,0)
10000: SetFunctionTemperatureTwoWireThermistor(admmThermistorType10000,0)
}
4WireRTD: SetFunctionTemperatureFourWireRTD()
4WireThermistor: SetFunctionTemperatureFourWireThermistor(,)
{
2252: SetFunctionTemperatureFourWireThermistor(admmThermistorType2252,0)
5000: SetFunctionTemperatureFourWireThermistor(admmThermistorType5000,0)
10000: SetFunctionTemperatureFourWireThermistor(admmThermistorType10000,0)
}
TransducerType: SetFunctionTemperatureTransducerType()
{
Thermistor: SetFunctionTemperatureTransducerType(admmTransducerType2WireThermistor)
2WireRTD: SetFunctionTemperatureTransducerType(admmTransducerType2WireRTD)
4WireRTD: SetFunctionTemperatureTransducerType(admmTransducerType4WireRTD)
}
}
}
Math
{
dB_Reference: SetCalculateMathDBReference()
dBm_Reference: SetCalculateMathDBMReference()
Function: SetCalculateMathFunction()
NullOffset: SetCalculateMathNullOffset()
State: SetCalculateMathState()
Clear: SetCalculateMathClear()
}
LineFrequency: SetLineFrequency()
Sample
{
Count: SetSampleCount()
Interval: SetSampleInterval()
Mode: SetSampleMode()
{
Immediate: SetSampleMode(admmSampleTriggerSourceImmediate)
Timer: SetSampleMode(admmSampleTriggerSourceTimer)
}
Rate: SetSampleRate()
{
0_001_Cycles: SetSampleRate(0.001)
0_002_Cycles: SetSampleRate(0.002)
0_006_Cycles: SetSampleRate(0.006)
0_02_Cycles: SetSampleRate(0.02)
0_06_Cycles: SetSampleRate(0.06)
0_2_Cycles: SetSampleRate(0.2)
1_Cycle: SetSampleRate(1)
2_Cycles: SetSampleRate(2)
10_Cycles: SetSampleRate(10)
100_Cycles: SetSampleRate(100)
}
}
Status
{
Operation
{
Enable: SetStatusOperationEnable()
}
Preset: SetStatusPreset()
Questionable
{
Enable: SetStatusQuestionableEnable()
}
}
Transient
{
IAC
{
State: SetTransientIACState()
}
IDC
{
State: SetTransientIDCState()
}
VAC
{
State: SetTransientVACState()
}
VDC
{
State: SetTransientVDCState()
}
}
Trigger
{
Count: SetTriggerCount()
Delay: SetTriggerDelay()
Level: SetTriggerLevel()
Slope: SetTriggerSlope()
{
Positive: SetTriggerSlope(admmTriggerSlopePositive)
Negative: SetTriggerSlope(admmTriggerSlopeNegative)
}
Source: SetTriggerSource(,)
{
Immediate: SetTriggerSource(admmTriggerSourceImmediate,)
Internal: SetTriggerSource(admmTriggerSourceInternal,)
External: SetTriggerSource(admmTriggerSourceExternal,)
Bus: SetTriggerSource(admmTriggerSourceBus,)
}
}
}
Get
{
AC
{
Frequency: GetACFrequency()
FrequencyVoltageRange: GetACFrequencyVoltageRange()
}
Aperture: GetAperture()
AutoZero: GetAutoZero()
Format
{
Border: GetFormatBorder()
Data: GetFormatData()
Phase: GetFormatPhase()
}
Function: GetFunction()
{
Impedance
{
Auto: GetFunctionImpedanceAuto()
}
Range
{
Auto: GetFunctionRangeAuto()
}
}
LineFrequency: GetLineFrequency()
{
Actual: GetLineFrequencyActual()
}
Math
{
State: GetMathState()
dB_Reference: GetMathDBReference()
dBm_Reference: GetMathDBMReference()
NullOffset: GetMathNullOffset()
Limit
{
Lower: GetMathLimitLower()
Upper: GetMathLimitUpper()
}
Count: GetMathCount()
Average: GetMathAverage()
PeakToPeak: GetMathPeakToPeak()
Max: GetMathMax()
Min: GetMathMin()
StandardDeviation: GetMathStandardDeviation()
Transient
{
IAC
{
PeakToPeak: GetTransientIACPeakToPeak()
}
IDC
{
Maximum: GetTransientIDCMaximum()
Minimum: GetTransientIDCMinimum()
PeakToPeak: GetTransientIDCPeakToPeak()
}
VAC
{
PeakToPeak: GetTransientVACPeakToPeak()
}
VDC
{
Maximum: GetTransientVDCMaximum()
Minimum: GetTransientVDCMinimum()
PeakToPeak: GetTransientVDCPeakToPeak()
}
}
}
Memory: GetMemory(,)
{
TotalReading: GetMemory(admmMemoryTypeReading,)
TotalReadingNonVolatile: GetMemory(admmMemoryTypeNonVolatile,)
}
Range: GetRange()
ReadingRate: GetReadingRate()
Sample
{
Count: GetSampleCount()
Source: GetSampleSource()
Interval: GetSampleInterval()
}
Status
{
Operation
{
Condition: GetStatusOperationCondition()
Enable: GetStatusOperationEnable()
Event: GetStatusOperationEvent()
}
Questionable
{
Condition: GetStatusQuestionableCondition()
Enable: GetStatusQuestionableEnable()
Event: GetStatusQuestionableEvent()
}
}
Trigger
{
Count: GetTriggerCount()
Delay: GetTriggerDelay()
Source: GetTriggerSource(,)
Slope: GetTriggerSlope()
}
IsReady: GetIsReady()
}
Measure: Measure()
{
Abort: MeasureAbort()
Array: MeasureArray(,)
Get
{
Last: MeasureGetLast()
AllReadingsFromNonVolatile: MeasureGetAllReadingsFromNonVolatile()
}
Fetch: MeasureFetch()
Initiate: MeasureInitiate()
}
Trigger: Trigger()
Reset: _Reset()
Initialize: Initialize()
Utility
{
Configuration
{
Delete: UtilityConfigurationDelete(enMemoryLocation)
{
0: UtilityConfigurationDelete(admmMemoryLocation0)
1: UtilityConfigurationDelete(admmMemoryLocation1)
2: UtilityConfigurationDelete(admmMemoryLocation2)
3: UtilityConfigurationDelete(admmMemoryLocation3)
4: UtilityConfigurationDelete(admmMemoryLocation4)
All: UtilityConfigurationDeleteAll()
}
GetName: UtilityConfigurationGetName(,)
{
0: UtilityConfigurationGetName(admmMemoryLocation0,)
1: UtilityConfigurationGetName(admmMemoryLocation1,)
2: UtilityConfigurationGetName(admmMemoryLocation2,)
3: UtilityConfigurationGetName(admmMemoryLocation3,)
4: UtilityConfigurationGetName(admmMemoryLocation4,)
}
IsValid: UtilityConfigurationIsValid(,)
{
0: UtilityConfigurationIsValid(admmMemoryLocation0,)
1: UtilityConfigurationIsValid(admmMemoryLocation1,)
2: UtilityConfigurationIsValid(admmMemoryLocation2,)
3: UtilityConfigurationIsValid(admmMemoryLocation3,)
4: UtilityConfigurationIsValid(admmMemoryLocation4,)
}
Recall: UtilityConfigurationRecall()
{
0: UtilityConfigurationRecall(admmMemoryLocation0)
1: UtilityConfigurationRecall(admmMemoryLocation1)
2: UtilityConfigurationRecall(admmMemoryLocation2)
3: UtilityConfigurationRecall(admmMemoryLocation3)
4: UtilityConfigurationRecall(admmMemoryLocation4)
}
SetName: UtilityConfigurationSetName(,)
{
0: UtilityConfigurationSetName(admmMemoryLocation0,)
1: UtilityConfigurationSetName(admmMemoryLocation1,)
2: UtilityConfigurationSetName(admmMemoryLocation2,)
3: UtilityConfigurationSetName(admmMemoryLocation3,)
4: UtilityConfigurationSetName(admmMemoryLocation4,)
}
Save: UtilityConfigurationSave()
{
0: UtilityConfigurationSave(admmMemoryLocation0)
1: UtilityConfigurationSave(admmMemoryLocation1)
2: UtilityConfigurationSave(admmMemoryLocation2)
3: UtilityConfigurationSave(admmMemoryLocation3)
4: UtilityConfigurationSave(admmMemoryLocation4)
}
}
Calibration
{
Get
{
Count: UtilityCalibrationGetCount()
Security
{
State: UtilityCalibrationGetSecurityState()
}
Label: UtilityCalibrationGetLabel()
Value: UtilityCalibrationGetValue()
}
Set
{
Security
{
Code: UtilityCalibrationSetSecurityCode()
State: UtilityCalibrationSetSecurityState(,)
{
Enable: UtilityCalibrationSetSecurityState(admmStateOn,)
Disable: UtilityCalibrationSetSecurityState(admmStateOff,)
}
}
Label: UtilityCalibrationSetLabel()
Value: UtilityCalibrationSetValue()
}
Save: UtilityCalibrationSave()
ADC: UtilityCalibrationADC()
All: UtilityCalibrationAll()
}
Message
{
Receive: ReceiveString()
Send: SendString()
}
Memory
{
CopyReadingsToNonVolatile: MemoryCopyReadingsToNonVolatile()
DeleteReadingsFromNonVolatile: MemoryDeleteReadingsFromNonVolatile()
}
System
{
Get
{
Identification: SystemGetIdentification()
InterfaceEnabled: SystemGetInterfaceEnabled(,)
{
GPIB: SystemGetInterfaceEnabled(admmHardwareInterfaceGpib,)
USB: SystemGetInterfaceEnabled(admmHardwareInterfaceUsb,)
LAN: SystemGetInterfaceEnabled(admmHardwareInterfaceLan,)
Sockets: SystemGetInterfaceEnabled(admmHardwareInterfaceSockets,)
Telnet: SystemGetInterfaceEnabled(admmHardwareInterfaceTelnet,)
VXI11: SystemGetInterfaceEnabled(admmHardwareInterfaceVxi,)
Web: SystemGetInterfaceEnabled(admmHardwareInterfaceWeb,)
}
}
SelfTest: SystemSelfTest()
}
}
Events
================================================================================
Procedure OnInit(): Void Public! Occurs when the driver is started.
--------------------------------------------------------------------------------
{
if Driver.Parameters("SkipOnInit")=0
Driver Initialize()
endif
}
Procedures
================================================================================
Procedure _GetLastError(lError): Void
--------------------------------------------------------------------------------
lError: Var Long
{
lError=m_iLastStatus
}
Procedure _Reset(): Void ! Places the instrument in a known state and configures instrument options on which the IVI specific driver depends (for example, enabling/disabling headers). For an IEEE 488.2 instrument, Reset sends the command string *RST to the instrument.
--------------------------------------------------------------------------------
{
SendString("*RST")
CheckError()
!Enable all registers
SetStatusOperationEnable(0xFFFF)
SetStatusQuestionableEnable(0xFFFF)
m_enLastFunction=admmFunctionVoltageDC
}
Procedure CheckError(): Void
--------------------------------------------------------------------------------
{
GetStringToLongCommaString("SYST:ERR?", m_iLastStatus, m_sLastError)
if m_iLastStatus<>0
error m_iLastStatus, m_sLastError
endif
}
Procedure ConfigureMeasurement(enFunction, dRange, dResolution): Void ! Configures the Function, Range, and Resolution properties. If the value of the Range parameter is Auto Range On, then the Resolution parameter is ignored.
--------------------------------------------------------------------------------
enFunction: Val enumDmmFunction! Determines the units for the Range and Resolution Absolute parameters, and the measurement values that are returned by the Read, Read Multiple Point, Fetch, and Fetch Multiple Point methods.
dRange: Val Double ! The measurement range. Positive values represent the absolute value of the maximum measurement expected. The driver coerces this value to the appropriate range for the instrument. Negative values represent the Auto Range mode.
dResolution: Val Double ! The measurement resolution in absolute units.
{
select enFunction
case admmFunction2WireResistance
SetFunctionResistanceTwoWire(dRange, dResolution)
case admmFunction4WireResistance
SetFunctionResistanceFourWire(dRange, dResolution)
case admmFunctionCapacitance
SetFunctionCapacitance(dRange, dResolution)
case admmFunctionContinuity
SetFunctionContinuity()
case admmFunctionCurrentAC
SetFunctionIAC(dRange, dResolution)
case admmFunctionCurrentDC
SetFunctionIDC(dRange, dResolution)
case admmFunctionDiode
SetFunctionDiode()
case admmFunctionFrequency
SetFunctionFrequency(dRange, dResolution)
case admmFunctionPeriod
SetFunctionPeriod(dRange, dResolution)
case admmFunctionTemperature
case admmFunctionVoltageAC
SetFunctionVAC(dRange, dResolution)
case admmFunctionVoltageDC
SetFunctionVDC(dRange, dResolution)
endselect
}
Procedure GetACFrequency(pdMinFreq): Void ! This command sets the ac bandwidth used to detect the signal during frequency and period measurements. The instrument uses three different ac filters. The instrument selects the slow (3 Hz), medium (20 Hz), or fast (200 Hz) filter based on the cutoff frequency that you specify with this command. Set the lowest expected frequency that you expect to encounter. The default is 20 Hz (medium).
--------------------------------------------------------------------------------
pdMinFreq: Var Double ! The minimum frequency component of the input signal for AC measurements.
{
GetStringToDouble("SENS:FREQ:RANG:LOW?", pdMinFreq)
CheckError()
}
Procedure GetACFrequencyVoltageRange(pdFrequencyVoltageRange): Void ! This function configures the frequency voltage range of the DMM.
--------------------------------------------------------------------------------
pdFrequencyVoltageRange: Var Double ! Specifies the expected maximum value of the input signal. The driver uses this value to set the Frequency Voltage Range attribute. See the attribute description for more details.
{
GetStringToDouble("SENS:FREQ:VOLT:RANG:UPP?", pdFrequencyVoltageRange)
CheckError()
}
Procedure GetAperture(pdApertureTime): Void ! Returns the aperture time and the aperture time units.
--------------------------------------------------------------------------------
pdApertureTime: Var Double ! Returns the value of the Aperture Time attribute in seconds. See the attribute description for more details.
s: String
enFunction: enumDmmFunction
{
GetFunction(enFunction)
select enFunction
case admmFunctionCurrentDC
s="SENS:CURR:DC:APER?"
case admmFunctionFrequency
s="SENS:FREQ:APER?"
case admmFunction4WireResistance
s="SENS:FRES:APER?"
case admmFunctionPeriod
s="SENS:PER:APER?"
case admmFunction2WireResistance
s="SENS:RES:APER?"
case admmFunctionTemperature
s="SENS:TEMP:APER?"
case admmFunctionVoltageDC
s="SENS:VOLT:DC:APER?"
endselect
GetStringToDouble(s, pdApertureTime)
CheckError()
}
Procedure GetAutoZero(penState): Void ! This function configures the auto zero mode of the DMM.
--------------------------------------------------------------------------------
penState: Var enumDmmState ! Specifies the auto-zero mode The driver uses this value to set the Auto Zero attribute. See the attribute description for more details.
sResponse: String
s: String
enFunction: enumDmmFunction
{
GetFunction(enFunction)
select enFunction
case admmFunctionCurrentDC
s="SENS:CURR:DC:ZERO:AUTO?"
case admmFunction2WireResistance
s="SENS:RES:ZERO:AUTO?"
case admmFunctionTemperature
s="SENS:TEMP:ZERO:AUTO?"
case admmFunctionVoltageDC
s="SENS:VOLT:DC:ZERO:AUTO?"
case else
return
endselect
GetStringToString(s, sResponse)
CheckError()
if sResponse="OFF"
penState=admmStateOff
elseif sResponse="ON"
penState=admmStateOn
endif
}
Procedure GetCalculateFunction(penCalculateFunction): Void ! This command selects the calculation function to be used. The default function is NULL.
--------------------------------------------------------------------------------
penCalculateFunction: Var enumDmmCalculateFunction
s: String
{
GetStringToString("CALC:FUNC?", s)
CheckError()
select s
case "NULL"
penCalculateFunction=admmCalculateFunctionNull
case "DB"
penCalculateFunction=admmCalculateFunctionDB
case "DBM"
penCalculateFunction=admmCalculateFunctionDBM
case "AVER"
penCalculateFunction=admmCalculateFunctionAverage
case "LIM"
penCalculateFunction=admmCalculateFunctionLimit
endselect
}
Procedure GetDisplayEnabled(lDisplayLine, penState): Void ! Enables or disables the instrument's front-panel display.
--------------------------------------------------------------------------------
lDisplayLine: Val Long ! Display line to enable or disable.
penState: Var enumDmmState ! Enables or disables the instrument's front-panel display.
s: String
{
s="DISP:WIND"+Str(lDisplayLine)+":STAT?"
GetStringToLong(s, penState)
CheckError()
}
Procedure GetDisplayText(lDisplayLine, psRetVal): Void ! Displays a text message on the top line or bottom line of the instrument's front-panel display.
--------------------------------------------------------------------------------
lDisplayLine: Val Long ! Display line on which to display the specified text.
psRetVal: Var String ! Displays a text message on the top line or bottom line of the instrument's front-panel display.
s: String
{
s="DISP:WIND"+Str(lDisplayLine)+":TEXT:DATA?"
GetStringToString(s, psRetVal)
CheckError()
}
Procedure GetFormatBorder(penFormatBorder): Void ! This command selects the byte order for binary block transfers using the MEASure?, READ?, FETCh?, DATA:REMove? and R? commands.
--------------------------------------------------------------------------------
penFormatBorder: Var enumDmmFormatBorder ! In normal, the most-significant byte is sent first. In swapped, the least-significant byte is sent first.
s: String
{
GetStringToString("FORM:BORD?", s)
if s="NORM"
penFormatBorder=admmFormatBorderNormal
elseif s="SWAP"
penFormatBorder=admmFormatBorderSwapped
endif
CheckError()
}
Procedure GetFormatData(psFormat): Void ! Specifies the data format to be either ASCII or REAL. This command affects the data format of the MEASure?, READ?, FETCh?, DATA:REMove? and R? commands.
--------------------------------------------------------------------------------
psFormat: Var String ! Returns the data format.
{
GetStringToString("FORM:DATA?", psFormat)
CheckError()
}
Procedure GetFormatPhase(penFormatPhase): Void ! This command selects whether phase measurements are displayed in the fixed range of ±180° or 0° to 360°, or whether the instrument will automatically switch between these ranges based on the measurement history.
--------------------------------------------------------------------------------
penFormatPhase: Var enumDmmFormatPhase
s: String
{
GetStringToString("FORM:PHAS?", s)
select s
case "CENT"
penFormatPhase=admmFormatPhaseCentered
case "POS"
penFormatPhase=admmFormatPhasePositive
case "AUTO"
penFormatPhase=admmFormatPhaseAuto
endselect
CheckError()
}
Procedure GetFunction(penFunction): Void ! This routine is used to access low-level settings of the instrument. See the attributeID parameter for a link to all attributes of the instrument.
--------------------------------------------------------------------------------
penFunction: Var enumDmmFunction
s: String ! Used only by Get Attribute
{
GetStringToString("FUNC?", s)
CheckError()
select s
case "\"CAP\""
penFunction=admmFunctionCapacitance
case "\"CONT\""
penFunction=admmFunctionContinuity
case "\"CURR:AC\""
penFunction=admmFunctionCurrentAC
case "\"CURR\""
penFunction=admmFunctionCurrentDC
case "\"DIOD\""
penFunction=admmFunctionDiode
case "\"FREQ\""
penFunction=admmFunctionFrequency
case "\"FRES\""
penFunction=admmFunction4WireResistance
case "\"PER\""
penFunction=admmFunctionPeriod
case "\"RES\""
penFunction=admmFunction2WireResistance
case "\"TEMP\""
penFunction=admmFunctionTemperature
case "\"VOLT:AC\""
penFunction=admmFunctionVoltageAC
case "\"VOLT\""
penFunction=admmFunctionVoltageDC
endselect
!CONF? will return non-default ranges and resolutions. Get them off the buffer.
try
ReceiveString(s)
catch
endtry
}
Procedure GetFunctionImpedanceAuto(penState): Void ! The query returns the current state of the automatic input impedance mode: "0" (OFF) or "1" (ON).
--------------------------------------------------------------------------------
penState: Var enumDmmState ! State of Impedance Auto
s: String
{
GetStringToString("SENS:VOLT:DC:RANG:AUTO?", s)
CheckError()
select s
case "ON"
penState=admmStateOn
case "OFF"
penState=admmStateOff
case else
return
endselect
}
Procedure GetFunctionRangeAuto(penState): Void ! Retreives the current state of the VDC Auto Range
--------------------------------------------------------------------------------
penState: Var enumDmmState ! State of the VDC Auto Range
s: String
{
GetStringToString("SENS:VOLT:DC:RANG:AUTO?", s)
CheckError()
select s
case "ON"
penState=admmStateOn
case "OFF"
penState=admmStateOff
case else
return
endselect
}
Procedure GetIsReady(): Bool ! Returns True if the device is ready to make another measurement, returns False if busy.
--------------------------------------------------------------------------------
lFailureCount: Long
l: Long
{
repeat
try
GetStringToLong("*OPC?", l)
catch
lFailureCount=lFailureCount+1
endtry
until l=1
while lFailureCount>0
ReceiveLong(l)
lFailureCount=lFailureCount-1
endwhile
return True
}
Procedure GetLineFrequency(penReferenceFrequency): Void ! The query returns the power-line reference frequency currently used by the 34410A/11A/L4411A analog-to-digital converter (50 or 60 Hz). When you apply power to the instrument, the instrument automatically detects the power-line frequency and uses this value to determine the integration time used.
--------------------------------------------------------------------------------
penReferenceFrequency: Var enumDmmReferenceFrequency
l: Long
{
GetStringToLong("CAL:LFR?", l)
CheckError()
if l=50
penReferenceFrequency=admmReferenceFrequency50or400Hz
elseif l=60
penReferenceFrequency=admmReferenceFrequency60Hz
endif
}
Procedure GetLineFrequencyActual(pdActualFreq): Void ! This command returns the actual power-line frequency.
--------------------------------------------------------------------------------
pdActualFreq: Var Double ! Returns the actual power line frequency measured at power up.
{
GetStringToDouble("CAL:LFR:ACT?", pdActualFreq)
CheckError()
}
Procedure GetMathAverage(pdAverage): Void ! This query returns the mathematical average (mean) of all measurements taken since the last time statistics were cleared.
--------------------------------------------------------------------------------
pdAverage: Var Double ! Returns the average of the readings taken, or "0" if no data is available.
{
GetStringToDouble("CALC:AVER:AVER?", pdAverage)
CheckError()
}
Procedure GetMathCount(plCount): Void ! This query returns the number of measurements used to compute the current statistics values since the last time statistics were cleared.
--------------------------------------------------------------------------------
plCount: Var Long ! Returns the count since statistics were enabled. If no data is available , "0" is returned.
{
GetStringToLong("CALC:AVER:COUN?", plCount)
CheckError()
}
Procedure GetMathDBMReference(pdReferenceValue): Void ! This command selects the dBm reference resistance. The default is 600 ohms. This reference value affects both the dBm and dB functions in the CALCulate:FUNCtion command.
--------------------------------------------------------------------------------
pdReferenceValue: Var Double ! dBm reference value. Choose from: 50, 75, 93, 110, 124, 125, 135, 150, 250, 300, 500, 600, 800, 900, 1000, 1200, or 8000 ohms.
{
GetStringToDouble("CALC:DBM:REF?", pdReferenceValue)
CheckError()
}
Procedure GetMathDBReference(pdReferenceValue): Void ! This command stores a relative value in the meter's dB Relative Register, which is used for the dB function in the CALCulate:FUNCtion command.
--------------------------------------------------------------------------------
pdReferenceValue: Var Double ! Relative value. Range ±200 dBm.
{
GetStringToDouble("CALC:DB:REF?", pdReferenceValue)
CheckError()
}
Procedure GetMathLimitLower(pdLowerLimit): Void ! This command sets the lower limit for limit testing.
--------------------------------------------------------------------------------
pdLowerLimit: Val Double ! Gain value, from -1.0e+15 to -1.0-15, 0.0, 1.0e-15 to 1.0e+15
{
GetStringToDouble("CALC1:LIM:LOW:DATA?", pdLowerLimit)
CheckError()
}
Procedure GetMathLimitUpper(pdUpperLimit): Void ! This command sets the upper limit for limit testing.
--------------------------------------------------------------------------------
pdUpperLimit: Val Double ! Gain value, from -1.0e+15 to -1.0-15, 0.0, 1.0e-15 to 1.0e+15
{
GetStringToDouble("CALC1:LIM:UPP:DATA?", pdUpperLimit)
CheckError()
}
Procedure GetMathMax(pdMaximum): Void ! This query returns the maximum value of all measurements taken since the last time statistics were cleared.
--------------------------------------------------------------------------------
pdMaximum: Var Double ! Returns the maximum of the readings taken, or "0" if no data is available.
{
GetStringToDouble("CALC:AVER:MAX?", pdMaximum)
CheckError()
}
Procedure GetMathMin(pdMinimum): Void ! This query returns the minimum value of all measurements taken since the last time statistics were cleared.
--------------------------------------------------------------------------------
pdMinimum: Var Double ! Returns the maximum of the readings taken, or "0" if no data is available.
{
GetStringToDouble("CALC:AVER:MIN?", pdMinimum)
CheckError()
}
Procedure GetMathNullOffset(pdOffset): Void ! This command stores a null value in the multimeter's Null Register.
--------------------------------------------------------------------------------
pdOffset: Var Double ! Null offset. Any value between -120% and +120% of the highest range for the present measurement function.
{
GetStringToDouble("CALC:NULL:OFFS?", pdOffset)
CheckError()
}
Procedure GetMathPeakToPeak(pdPeakToPeak): Void ! This query returns the peak-to-peak value of all measurements taken since the last time statistics were cleared.
--------------------------------------------------------------------------------
pdPeakToPeak: Var Double ! Returns the peak-to-peak value of all readings taken since statistics were enabled.
{
GetStringToDouble("CALC:AVER:PTP?", pdPeakToPeak)
CheckError()
}
Procedure GetMathStandardDeviation(pdStdDeviation): Void ! This query returns the standard deviation of all measurements taken since the last time statistics were cleared.
--------------------------------------------------------------------------------
pdStdDeviation: Var Double ! Returns the standard deviation of all readings taken since statistics were enabled.
{
GetStringToDouble("CALC:AVER:SDEV?", pdStdDeviation)
CheckError()
}
Procedure GetMathState(penState): Void ! This command enables or disables the entire CALCulate1 subsystem.
--------------------------------------------------------------------------------
penState: Var enumDmmState
s: String
{
GetStringToString("CALC1?", s)
CheckError()
if s="OFF"
penState=admmStateOff
elseif s="ON"
penState=admmStateOn
endif
}
Procedure GetMemory(enMemoryType, plRetVal): Void ! Gets the total number of readings currently stored in reading memory or non-volatile memory.
--------------------------------------------------------------------------------
enMemoryType: Val enumDmmMemoryType ! Indicates whether readings should be taken from reading memory or non-volatile memory.
plRetVal: Var Long ! Gets the total number of readings currently stored in reading memory or non-volatile memory.
s: String
{
if enMemoryType=admmMemoryTypeReading
s="DATA:POIN? RDG_STORE"
elseif enMemoryType=admmMemoryTypeNonVolatile
s="DATA:POIN? NVMEM"
endif
GetStringToLong(s, plRetVal)
CheckError()
}
Procedure GetRange(pdRange): Void ! This command selects the measurement range for the current measurement mode.
--------------------------------------------------------------------------------
pdRange: Var Double ! The current measurement range.
s: String ! Used only by Get Attribute
{
select m_enLastFunction
case admmFunctionCapacitance
s="SENS:CAP:RANG:UPP?"
case admmFunctionCurrentAC
s="SENS:CURR:AC:RANG:UPP?"
case admmFunctionCurrentDC
s="SENS:CURR:DC:RANG:UPP?"
case admmFunctionFrequency
s="SENS:FREQ:VOLT:RANG:UPP?"
case admmFunction4WireResistance
s="SENS:FRES:RANG:UPP?"
case admmFunctionPeriod
s="SENS:PER:VOLT:RANG:UPP?"
case admmFunction2WireResistance
s="SENS:RES:RANG:UPP?"
case admmFunctionVoltageAC
s="SENS:VOLT:AC:RANG:UPP?"
case admmFunctionVoltageDC
s="SENS:VOLT:DC:RANG:UPP?"
case else
return
endselect
GetStringToDouble(s, pdRange)
CheckError()
}
Procedure GetReadingRate(pdPowerLineCycles): Void ! This command gets the integration time in number of power line cycles (PLCs) for the active function mode. Integration time affects the measurement resolution (for better resolution, use a longer integration time) and measurement speed (for faster measurements, use a shorter integration time).
--------------------------------------------------------------------------------
pdPowerLineCycles: Var Double ! The number of power line cycles. Will return -1 if the active function mode doesn't use the PLC register.
s: String
enFunction: enumDmmFunction
{
Driver Get Function(enFunction)
CheckError()
select enFunction
case admmFunctionCurrentDC
s="SENS:CURR:DC:NPLC?"
case admmFunction4WireResistance
s="SENS:FRES:NPLC?"
case admmFunction2WireResistance
s="SENS:RES:NPLC?"
case admmFunctionTemperature
s="SENS:TEMP:NPLC?"
case admmFunctionVoltageDC
s="SENS:VOLT:DC:NPLC?"
case else
pdPowerLineCycles=-1
return
endselect
GetStringToDouble(s, pdPowerLineCycles)
CheckError()
}
Procedure GetSampleCount(plCount): Void ! This command selects the number of triggers that will be accepted by the meter before returning to the "idle" trigger state.
--------------------------------------------------------------------------------
plCount: Var Long ! From 1 to 1000000 triggers.
{
GetStringToLong("SAMP:COUN?", plCount)
CheckError()
}
Procedure GetSampleInterval(pdInterval): Void
--------------------------------------------------------------------------------
! This command sets a sample interval for timed sampling when the sample count is greater than one. Use the SAMPle:SOURce command to set the TIMer option for timed sampling.
!
! The first sample is taken one trigger delay time after the trigger (the delay being set with the TRIGger:DELay command). The second sample starts one sample interval after the start of the first sample.
pdInterval: Var Double ! Up to 3600 seconds. Min is dependent on measurement.
{
GetStringToDouble("SAMP:TIM?", pdInterval)
CheckError()
}
Procedure GetSampleSource(penSampleTriggerSource): Void ! This command works in conjunction with the TRIGger:DELay command and the SAMPle:TIMer command to determine sample timing when the sample count is greater than one. In all cases, the first sample is taken one trigger delay time after the trigger (the delay being set with the TRIGger:DELay command). Beyond that, the timing mechanism depends on whether you select IMMediate or TIMer as the source:
--------------------------------------------------------------------------------
penSampleTriggerSource: Var enumDmmSampleTriggerSource
s: String
{
GetStringToString("SAMP:SOUR?", s)
CheckError()
if s="IMM"
penSampleTriggerSource=admmSampleTriggerSourceImmediate
elseif s="TIM"
penSampleTriggerSource=admmSampleTriggerSourceTimer
endif
}
Procedure GetStatusOperationCondition(pwRegister): Void ! This query returns the value of the Operation Status Condition register. The Condition register is a read-only register, which holds the live (unlatched) operational status of the instrument. Reading the Operation Condition register does not clear it.
--------------------------------------------------------------------------------
pwRegister: Var Word ! Returns the condition register
s: String
{
s="STAT:OPER:COND?"
GetStringToShort(s, pwRegister)
CheckError()
}
Procedure GetStatusOperationEnable(pwEnableRegister): Void ! Checks Enable bits in the enable register for the Standard Operation Register group. The selected bits are then reported to the Status Byte as the standard operation summary bit.
--------------------------------------------------------------------------------
pwEnableRegister: Var Word ! enable register
{
GetStringToShort(":STAT:OPER:ENAB?", pwEnableRegister)
CheckError()
}
Procedure GetStatusOperationEvent(pwEventRegister): Void ! Queries the event register for the Standard Operation Register group. This is a read-only register; the bits are cleared when you read the register.
--------------------------------------------------------------------------------
pwEventRegister: Var Word ! returns event register
{
GetStringToShort(":STAT:OPER:EVEN?", pwEventRegister)
CheckError()
}
Procedure GetStatusQuestionableCondition(pwRegister): Void ! This query returns the value of the Questionable Status Condition register. The Condition register is a read-only register, which holds the live (unlatched) questionable status of the instrument. Reading the Questionable Condition register does not clear it.
--------------------------------------------------------------------------------
pwRegister: Var Word ! Returns the condition register
s: String
{
s="STAT:QUES:COND?"
GetStringToShort(s, pwRegister)
CheckError()
}
Procedure GetStatusQuestionableEnable(pwEnableRegister): Void
--------------------------------------------------------------------------------
! queries enable bits in the enable register for the Questionable Data Register group. The selected bits are then reported to the
! Status Byte.
pwEnableRegister: Var Word ! returns enable register
{
GetStringToShort(":STAT:QUES:ENAB?", pwEnableRegister)
CheckError()
}
Procedure GetStatusQuestionableEvent(pwEventRegister): Void
--------------------------------------------------------------------------------
! Queries the event register for the Questionable Data Register group. This is a read-only register; the bits are cleared
! when you read the register.
pwEventRegister: Var Word ! returns event register
{
GetStringToShort(":STAT:QUES:EVEN?", pwEventRegister)
CheckError()
}
Procedure GetTransientIACPeakToPeak(pdCurrent): Void ! This command returns the difference between the highest and lowest transient voltage levels detected in the most recent ac voltage measurement.
--------------------------------------------------------------------------------
pdCurrent: Var Double ! The difference between the highest and lowest transient voltage levels
{
GetStringToDouble("FETC:VOLT:AC:PTP?", pdCurrent)
CheckError()
}
Procedure GetTransientIDCMaximum(pdCurrent): Void ! This command returns the highest transient current level detected in the most recent dc current measurement.
--------------------------------------------------------------------------------
pdCurrent: Var Double ! The highest transient level detected in the last measurement
{
GetStringToDouble("FETC:CURR:DC:PEAK:MAX?", pdCurrent)
CheckError()
}
Procedure GetTransientIDCMinimum(pdCurrent): Void ! This command returns the highest transient current level detected in the most recent dc current measurement.
--------------------------------------------------------------------------------
pdCurrent: Var Double ! The lowest transient level detected in the last measurement
{
GetStringToDouble("FETC:CURR:DC:PEAK:MIN?", pdCurrent)
CheckError()
}
Procedure GetTransientIDCPeakToPeak(pdVoltage): Void ! This command returns the difference between the highest and lowest transient voltage levels detected in the most recent ac voltage measurement.
--------------------------------------------------------------------------------
pdVoltage: Var Double ! The difference between the highest and lowest transient voltage levels
{
GetStringToDouble("FETC:VOLT:DC:PTP?", pdVoltage)
CheckError()
}
Procedure GetTransientVACPeakToPeak(pdCurrent): Void ! This command returns the difference between the highest and lowest transient current levels detected in the most recent ac current measurement.
--------------------------------------------------------------------------------
pdCurrent: Var Double ! The difference between the highest and lowest transient current levels
{
GetStringToDouble("FETC:CURR:AC:PTP?", pdCurrent)
CheckError()
}
Procedure GetTransientVDCMaximum(pdVoltage): Void ! This command returns the highest transient voltage level detected in the most recent dc voltage measurement.
--------------------------------------------------------------------------------
pdVoltage: Var Double ! The highest transient level detected in the last measurement
{
GetStringToDouble("FETC:VOLT:DC:PEAK:MAX?", pdVoltage)
CheckError()
}
Procedure GetTransientVDCMinimum(pdVoltage): Void ! This command returns the lowest transient voltage level detected in the most recent dc voltage measurement.
--------------------------------------------------------------------------------
pdVoltage: Var Double ! The lowest transient level detected in the last measurement
{
GetStringToDouble("FETC:VOLT:DC:PEAK:MIN?", pdVoltage)
CheckError()
}
Procedure GetTransientVDCPeakToPeak(pdCurrent): Void ! This command returns the difference between the highest and lowest transient current levels detected in the most recent dc current measurement.
--------------------------------------------------------------------------------
pdCurrent: Var Double ! The difference between the highest and lowest transient current levels
{
GetStringToDouble("FETC:CURR:DC:PTP?", pdCurrent)
CheckError()
}
Procedure GetTriggerCount(plCount): Void ! This command selects the number of triggers that will be accepted by the meter before returning to the "idle" trigger state.
--------------------------------------------------------------------------------
plCount: Var Long ! From 1 to 1000000 triggers. If -1, the instrument will trigger indefinately.
{
GetStringToLong("TRIG:COUN?", plCount)
CheckError()
}
Procedure GetTriggerDelay(pdDelay): Void ! This command sets the delay time in seconds between the trigger signal and enabling the gate open for the first measurement. This may be useful in applications where the signal you want to measure is delayed with respect to the trigger.
--------------------------------------------------------------------------------
pdDelay: Var Double ! The trigger delay, from 0.0 to 3600 seconds with 1 us resolution.
s: String
{
s="TRIG:DEL?"
GetStringToDouble(s, pdDelay)
CheckError()
}
Procedure GetTriggerSlope(penTriggerSlope): Void ! This function configures the polarity of the external trigger source of the DMM.
--------------------------------------------------------------------------------
penTriggerSlope: Var enumDmmTriggerSlope ! Specifies the trigger slope. The driver uses this value to set the Trigger Slope attribute. See the attribute description for more details.
s: String
{
GetStringToString("TRIG:SLOP?", s)
CheckError()
if s="POS"
penTriggerSlope=admmTriggerSlopePositive
elseif s="NEG"
penTriggerSlope=admmTriggerSlopeNegative
endif
}
Procedure GetTriggerSource(penTriggerSource, pdTriggerDelay): Void ! Configures the trigger Source and Delay properties.
--------------------------------------------------------------------------------
penTriggerSource: Var enumDmmTriggerSource ! Trigger source.
pdTriggerDelay: Var Double ! The length of time between when the DMM receives the trigger and when it takes a measurement. Use positive values to set the trigger delay in seconds. Negative values are reserved for the auto delay mode.
s: String
{
GetStringToString("TRIG:SOUR?", s)
CheckError()
select s
case "IMM"
penTriggerSource=admmTriggerSourceImmediate
case "EXT"
penTriggerSource=admmTriggerSourceExternal
case "BUS"
penTriggerSource=admmTriggerSourceBus
endselect
GetStringToDouble("TRIG:DEL?", pdTriggerDelay)
CheckError()
}
Procedure Initialize(): Void ! Initializes the instrument using the specified interface.
--------------------------------------------------------------------------------
s: String
{
m_iLastStatus=0
m_sLastError=""
!Check driver shortcut configuration
if Driver.InterfaceType=aioNone
error -1, "Please configure the driver interface type from the driver shortcut property page"
endif
!Try a simple function, if it fails notify user.
try
Driver Utility System Get Identification(s)
catch
error GetErrorNum(), "Initialization failure: "+GetErrorMsg()
endtry
!Enable all registers
SetStatusOperationEnable(0xFFFF)
SetStatusQuestionableEnable(0xFFFF)
Driver Get Function(m_enLastFunction)
}
Procedure InitiateMeas(): Void ! Initiates a measurement. Changes the state of the triggering system from the 'idle' state to the 'wait-for-trigger' state.
--------------------------------------------------------------------------------
{
SendString("INIT")
CheckError()
}
Procedure Measure(pdReading): Void ! Initiates a measurement, waits for the DMM to return to the idle state, and returns the measured value. If an overrange condition occurs, the value contains IEEE NaN and the method returns an overrange error.
--------------------------------------------------------------------------------
pdReading: Var Double ! Measurement value.
{
GetStringToDouble("READ?", pdReading)
}
Procedure MeasureAbort(): Void ! Aborts a previously initiated measurement and returns the DMM to the idle state.
--------------------------------------------------------------------------------
{
SendString("ABOR")
CheckError()
}
Procedure MeasureArray(lMaxArraySize, padReadingArray): Void ! Returns an array of values from a measurement that the Initiate method initiates. If an overrange condition occurs, the corresponding element of the array contains IEEE NaN and the method returns an overrange error.
--------------------------------------------------------------------------------
lMaxArraySize: Val Long ! Maximum number of values to read back from the device.
padReadingArray: Var Double[] ! Array of measured values.
s: String
{
s="R? "+Str(lMaxArraySize)
if sizeof(padReadingArray)/sizeof(double)<lMaxArraySize
redim padReadingArray[lMaxArraySize]
endif
SendStringAndReceiveArray(s, ",", padReadingArray)
}
Procedure MeasureDestructiveRead(lMaxCount, padRetVal): Void ! Reads and erases readings from volatile memory up to the specified MaxCount.
--------------------------------------------------------------------------------
lMaxCount: Val Long ! Number of readings to be read and erased from memory.
padRetVal: Var Double[] ! The erased values.
s: String
{
SendString("INIT")
CheckError()
s="DATA:REM? "+Str(lMaxCount)
GetStringToDoubleArray(s, padRetVal)
CheckError()
}
Procedure MeasureFetch(pdReading): Void ! This command transfers readings to the instrument's output buffer where you can read them into your computer. The readings are not erased from memory when you read them. You can send the command multiple times to retrieve the same data in reading memory.
--------------------------------------------------------------------------------
pdReading: Var Double ! Measurement value.
{
GetStringToDouble("FETC?", pdReading)
CheckError()
}
Procedure MeasureFunctionCapacitance(dRange, dResolution, pdRetVal): Void ! Performs a single capacitance measurement.
--------------------------------------------------------------------------------
dRange: Val Double ! Desired range in Farads or -1 for auto range. Valid values are from 1 nF to 10 uF.
dResolution: Val Double ! Measurement resolution. Desired resolution in Farads.
pdRetVal: Var Double ! The measured value in F (farads).
{
SetFunctionCapacitance(dRange, dResolution)
Measure(pdRetVal)
}
Procedure MeasureFunctionCurrentAC(dRange, dResolution, pdRetVal): Void ! This resets all AC current measurement parameters and trigger parameters to their default values. Then, it configures the meter for AC current measurements and immediately triggers a measurement.
--------------------------------------------------------------------------------
dRange: Val Double ! Desired range in amps or -1 for auto range. Valid values are 100 uA to 3A.
dResolution: Val Double ! Measurement resolution. Desired resolution in amperes.
pdRetVal: Var Double ! The measured value in amps.
{
SetFunctionIAC(dRange, dResolution)
Measure(pdRetVal)
}
Procedure MeasureFunctionCurrentDC(dRange, dResolution, pdRetVal): Void ! This resets all DC current measurement parameters and trigger parameters to their default values. Then, it configures the meter for DC current measurements and immediately triggers a measurement.
--------------------------------------------------------------------------------
dRange: Val Double ! Desired range in Amps or -1 for auto range. Valid values are from 100 uA to 3 A.
dResolution: Val Double ! Measurement resolution. Desired resolution in amperes.
pdRetVal: Var Double ! The measured value in amps.
{
SetFunctionIDC(dRange, dResolution)
Measure(pdRetVal)
}
Procedure MeasureFunctionContinuity(pdRetVal): Void ! Performs a single continuity measurement.
--------------------------------------------------------------------------------
pdRetVal: Var Double ! The measured value in ohms.
{
SetFunctionContinuity()
Measure(pdRetVal)
}
Procedure MeasureFunctionDiode(pdRetVal): Void ! Performs a single diode measurement using the default diode test parameters values.
--------------------------------------------------------------------------------
pdRetVal: Var Double ! The measured value.
{
SetFunctionDiode()
Measure(pdRetVal)
}
Procedure MeasureFunctionFourWireResistance(dRange, dResolution, pdRetVal): Void ! Performs a single 4-wire resistance measurement.
--------------------------------------------------------------------------------
dRange: Val Double ! Desired range in Ohms or -1 for auto range. Valid values are from 1 kOhm to 1 GOhm.
dResolution: Val Double ! Measurement resolution. Desired resolution in ohms.
pdRetVal: Var Double ! The measured value in ohms.
{
SetFunctionResistanceFourWire(dRange, dResolution)
Measure(pdRetVal)
}
Procedure MeasureFunctionFrequency(dRange, dResolution, pdRetVal): Void ! Performs a single frequency measurement using the default values for measurement and trigger parameters.
--------------------------------------------------------------------------------
dRange: Val Double ! Approximate frequency of the input signal in hertz. Range: 3 Hz to 300 kHz
dResolution: Val Double ! Measurement resolution. Desired resolution in Hertz.
pdRetVal: Var Double ! The measured value in Hz.
{
SetFunctionFrequency(dRange, dResolution)
Measure(pdRetVal)
}
Procedure MeasureFunctionPeriod(dRange, dResolution, pdRetVal): Void ! Performs a single period measurement using the default values for period measurement parameters and trigger parameters.
--------------------------------------------------------------------------------
dRange: Val Double ! Approximate period of the input signal in seconds, between 3.33 uS and 333.33 mS. Units are seconds.
dResolution: Val Double ! Measurement resolution. Desired resolution in seconds.
pdRetVal: Var Double ! The measured value.
{
SetFunctionPeriod(dRange, dResolution)
Measure(pdRetVal)
}
Procedure MeasureFunctionTemperatureFourWireRTD(dResolution, pdRetVal): Void ! Performs a single 4-wire RTD measurements.
--------------------------------------------------------------------------------
dResolution: Val Double ! Measurement resolution. Desired resolution in the selected units: C, F, or K.
pdRetVal: Var Double ! The measured value in the current IAgilent34410Temperature.ReadingUnits.
{
SetFunctionTemperatureFourWireRTD(dResolution)
Measure(pdRetVal)
}
Procedure MeasureFunctionTemperatureFourWireThermistor(enThermistorType, dResolution, pdRetVal): Void ! Performs a single 4-wire thermistor temperature measurement.
--------------------------------------------------------------------------------
enThermistorType: Val enumDmmThermistorType ! The thermistor type. Choose from 2252, 5000, or 10000 Ohm.
dResolution: Val Double ! Measurement resolution. Desired resolution in the selected units: C, F, or K.
pdRetVal: Var Double ! The measured value in the current IAgilent34410Temperature.ReadingUnits.
{
SetFunctionTemperatureFourWireThermistor(enThermistorType, dResolution)
Measure(pdRetVal)
}
Procedure MeasureFunctionTemperatureTwoWireRTD(dResolution, pdRetVal): Void ! Performs a single RTD temperature measurement using the default values for measurement and trigger parameters.
--------------------------------------------------------------------------------
dResolution: Val Double ! Measurement resolution. Desired resolution in the selected units: C, F, or K.
pdRetVal: Var Double ! The measured value in the current IAgilent34410Temperature.ReadingUnits.
{
SetFunctionTemperatureTwoWireRTD()
Measure(pdRetVal)
}
Procedure MeasureFunctionTemperatureTwoWireThermistor(enThermistorType, dResolution, pdRetVal): Void ! Performs a single thermistor temperature measurement using the default values for measurement and trigger parameters.
--------------------------------------------------------------------------------
enThermistorType: Val enumDmmThermistorType ! The thermistor type. Choose from 2252, 5000, or 10000 Ohm.
dResolution: Val Double ! Measurement resolution. Desired resolution in the currently selected units: C, F, or K.
pdRetVal: Var Double ! The measured value in the current IAgilent34410Temperature.ReadingUnits.
{
SetFunctionTemperatureTwoWireThermistor(enThermistorType, dResolution)
Measure(pdRetVal)
}
Procedure MeasureFunctionTwoWireResistance(dRange, dResolution, pdRetVal): Void ! Performs a single 2-wire resistance measurement.
--------------------------------------------------------------------------------
dRange: Val Double ! Desired range in Ohms or -1 for auto range. Valid values are from 100 Ohms to 1 GOhm.
dResolution: Val Double ! Measurement resolution. Desired resolution in ohms.
pdRetVal: Var Double ! The measured value in ohms.
{
SetFunctionResistanceTwoWire(dRange, dResolution)
Measure(pdRetVal)
}
Procedure MeasureFunctionVoltageAC(dRange, dResolution, pdRetVal): Void ! This resets all AC voltage measurement parameters and trigger parameters to their default values. Then, it configures the meter for AC voltage measurements and immediately triggers a measurement.
--------------------------------------------------------------------------------
dRange: Val Double ! Desired range in Volts or -1 for auto range. Valid values are from 100 mV to 1000 V.
dResolution: Val Double ! Measurement resolution. Desired resolution in volts.
pdRetVal: Var Double ! The measured value in volts.
{
SetFunctionVAC(dRange, dResolution)
Measure(pdRetVal)
}
Procedure MeasureFunctionVoltageDC(dRange, dResolution, pdRetVal): Void ! This resets all DC voltage measurement parameters and trigger parameters to their default values. Then, it configures the meter for DC voltage measurements and immediately triggers a measurement.
--------------------------------------------------------------------------------
dRange: Val Double ! Desired range in Volts or -1 for auto range. Valid values are from 100 mV to 1000 V.
dResolution: Val Double ! Measurement resolution. Desired resolution in volts.
pdRetVal: Var Double ! The measured value in volts.
{
SetFunctionVDC(dRange, dResolution)
Measure(pdRetVal)
}
Procedure MeasureGetAllReadingsFromNonVolatile(padRetVal): Void ! Returns all readings in non-volatile memory.
--------------------------------------------------------------------------------
padRetVal: Var Double[] ! The measured values.
{
!This doesn't work, this command doesn't have a header.
!SendStringAndReceiveArray("DATA:DATA? NVMEM", ",", padRetVal)
SendStringAndReceiveArrayNoHeader("DATA:DATA? NVMEM", ",", padRetVal)
CheckError()
}
Procedure MeasureGetLast(pdRetVal): Void ! This command returns the last measurement taken. You can execute this command at any time, even during a series of measurements.
--------------------------------------------------------------------------------
pdRetVal: Var Double ! The measured value.
{
GetStringToDouble("DATA:LAST?", pdRetVal)
CheckError()
}
Procedure MeasureInitiate(): Void ! Initiates a measurement. When this method executes, the DMM leaves the idle state and waits for a trigger.
--------------------------------------------------------------------------------
{
SendString("INIT")
CheckError()
}
Procedure MemoryCopyReadingsToNonVolatile(): Void ! Copies the readings in reading memory into non-volatile memory.
--------------------------------------------------------------------------------
{
SendString("DATA:COPY NVMEM, RDG_STORE")
CheckError()
}
Procedure MemoryDeleteReadingsFromNonVolatile(): Void ! Deletes all readings from non-volatile memory.
--------------------------------------------------------------------------------
{
SendString("DATA:DEL NVMEM")
CheckError()
}
Procedure SendStringAndReceiveArray(sCmd, sDelimiter, padData): Void
--------------------------------------------------------------------------------
sCmd: Val String
sDelimiter: Val String
padData: Var Double[]
vt: Variant
sData: String
lCharRemaining: Long
lByteSize: Long
s: String
{
SendString(sCmd)
Sleep(1)
ReceiveString(s)
lByteSize=Val(Mid(s, 1, 1))
lCharRemaining=Val(Mid(s, 2, lByteSize))
sData=Mid(s, 2+lByteSize, Len(s)-2-lByteSize)
while (lCharRemaining>256)
lCharRemaining=lCharRemaining-256
ReceiveString(s)
sData=sData+s
endwhile
CheckError()
vt=Split(sData, sDelimiter)
padData=vt
}
Procedure SendStringAndReceiveArrayNoHeader(sCmd, sDelimiter, padData): Void
--------------------------------------------------------------------------------
sCmd: Val String
sDelimiter: Val String
padData: Var Double[]
vt: Variant
sData: String
s: String
{
SendString(sCmd)
Sleep(1)
try
while 1=1
ReceiveString(s)
sData=sData+s
Sleep(10)
endwhile
catch
! lReceiveError=lReceiveError+1
endtry
vt=Split(sData, sDelimiter)
padData=vt
}
Procedure SetACFrequency(dMinFreq): Void ! This command sets the ac bandwidth used to detect the signal during frequency and period measurements. The instrument uses three different ac filters. The instrument selects the slow (3 Hz), medium (20 Hz), or fast (200 Hz) filter based on the cutoff frequency that you specify with this command. Set the lowest expected frequency that you expect to encounter. The default is 20 Hz (medium).
--------------------------------------------------------------------------------
dMinFreq: Val Double ! The minimum frequency component of the input signal for AC measurements.
s: String
{
s="SENS:FREQ:RANG:LOW "+Str(dMinFreq)
SendString(s)
CheckError()
}
Procedure SetACFrequencyVoltageRange(dFrequencyVoltageRange): Void ! This function configures the frequency voltage range of the DMM.
--------------------------------------------------------------------------------
dFrequencyVoltageRange: Val Double ! Specifies the expected maximum value of the input signal. The driver uses this value to set the Frequency Voltage Range attribute. See the attribute description for more details.
s: String
{
s="SENS:FREQ:VOLT:RANG:UPP "+Str(dFrequencyVoltageRange)
SendString(s)
CheckError()
}
Procedure SetAperture(dApertureTime): Void ! This command selects the integration time in seconds (called aperture time) for dc current measurements.
--------------------------------------------------------------------------------
dApertureTime: Val Double ! Desired aperture time in seconds.
s: String
enFunction: enumDmmFunction
{
Driver Get Function(enFunction)
CheckError()
select enFunction
case admmFunctionCurrentDC
s="SENS:CURR:DC:APER "
case admmFunctionFrequency
s="SENS:FREQ:APER "
case admmFunction4WireResistance
s="SENS:FRES:APER "
case admmFunctionPeriod
s="SENS:PER:APER "
case admmFunction2WireResistance
s="SENS:RES:APER "
case admmFunctionTemperature
s="SENS:TEMP:APER "
case admmFunctionVoltageDC
s="SENS:VOLT:DC:APER "
case else
return
endselect
SetApertureState(enFunction, admmStateOn)
s=s+Str(dApertureTime)
SendString(s)
CheckError()
}
Procedure SetApertureState(enFunction, enState): Void ! This command selects the integration time in seconds (called aperture time) for dc current measurements.
--------------------------------------------------------------------------------
enFunction: Val enumDmmFunction
enState: Val enumDmmState
s: String
{
select enFunction
case admmFunctionCurrentDC
s="SENS:CURR:DC:APER:ENAB "
case admmFunction4WireResistance
s="SENS:FRES:APER:ENAB "
case admmFunction2WireResistance
s="SENS:RES:APER:ENAB "
case admmFunctionTemperature
s="SENS:TEMP:APER:ENAB "
case admmFunctionVoltageDC
s="SENS:VOLT:DC:APER:ENAB "
case else
return
endselect
if enState=admmStateOff
s=s+" OFF"
elseif enState=admmStateOn
s=s+" ON"
endif
SendString(s)
CheckError()
}
Procedure SetAutoZero(enState): Void ! This function configures the auto zero mode of the DMM.
--------------------------------------------------------------------------------
enState: Val enumDmmState ! Specifies the auto-zero mode The driver uses this value to set the Auto Zero attribute. See the attribute description for more details.
s: String
enFunction: enumDmmFunction
{
GetFunction(enFunction)
select enFunction
case admmFunctionCurrentDC
s="SENS:CURR:DC:ZERO:AUTO"
case admmFunction2WireResistance
s="SENS:RES:ZERO:AUTO"
case admmFunctionTemperature
s="SENS:TEMP:ZERO:AUTO"
case admmFunctionVoltageDC
s="SENS:VOLT:DC:ZERO:AUTO"
case else
return
endselect
if enState=admmStateOff
s=s+" OFF"
elseif enState=admmStateOn
s=s+" ON"
endif
SendString(s)
CheckError()
}
Procedure SetCalculateLimitLower(dLowerLimit): Void ! This command sets the lower limit for limit testing.
--------------------------------------------------------------------------------
dLowerLimit: Val Double ! Gain value, from -1.0e+15 to -1.0-15, 0.0, 1.0e-15 to 1.0e+15
s: String
{
s="CALC1:LIM:LOW:DATA "+Str(dLowerLimit)
SendString(s)
CheckError()
}
Procedure SetCalculateLimitUpper(dUpperLimit): Void ! This command sets the upper limit for limit testing.
--------------------------------------------------------------------------------
dUpperLimit: Val Double ! Gain value, from -1.0e+15 to -1.0-15, 0.0, 1.0e-15 to 1.0e+15
s: String
{
s="CALC1:LIM:UPP:DATA "+Str(dUpperLimit)
SendString(s)
CheckError()
}
Procedure SetCalculateMathClear(): Void ! This command clears all computed statistics values.
--------------------------------------------------------------------------------
{
SendString("CALC:AVER:CLE")
CheckError()
}
Procedure SetCalculateMathDBReference(dReferenceValue): Void ! This command stores a relative value in the meter's dB Relative Register, which is used for the dB function in the CALCulate:FUNCtion command.
--------------------------------------------------------------------------------
dReferenceValue: Val Double ! Relative value. Range ±200 dBm.
{
SendString("CALC:DB:REF "+Str(dReferenceValue))
CheckError()
}
Procedure SetCalculateMathDBMReference(dReferenceValue): Void ! This command selects the dBm reference resistance. The default is 600 ohms. This reference value affects both the dBm and dB functions in the CALCulate:FUNCtion command.
--------------------------------------------------------------------------------
dReferenceValue: Val Double ! dBm reference value. Choose from: 50, 75, 93, 110, 124, 125, 135, 150, 250, 300, 500, 600, 800, 900, 1000, 1200, or 8000 ohms.
{
SendString("CALC:DBM:REF "+Str(dReferenceValue))
CheckError()
}
Procedure SetCalculateMathFunction(enCalculateFunction): Void ! This command selects the calculation function to be used. The default function is NULL.
--------------------------------------------------------------------------------
enCalculateFunction: Val enumDmmCalculateFunction
s: String
{
s="CALC:FUNC "
select enCalculateFunction
case admmCalculateFunctionNull
s=s+"NULL"
case admmCalculateFunctionDB
s=s+"DB"
case admmCalculateFunctionDBM
s=s+"DBM"
case admmCalculateFunctionAverage
s=s+"AVER"
case admmCalculateFunctionLimit
s=s+"LIM"
endselect
SendString(s)
CheckError()
}
Procedure SetCalculateMathNullOffset(dOffset): Void ! This command stores a null value in the multimeter's Null Register.
--------------------------------------------------------------------------------
dOffset: Val Double ! Null offset. Any value between -120% and +120% of the highest range for the present measurement function.
{
SendString("CALC:NULL:OFFS "+Str(dOffset))
CheckError()
}
Procedure SetCalculateMathState(enState): Void ! This command enables or disables the entire CALCulate1 subsystem.
--------------------------------------------------------------------------------
enState: Val enumDmmState
s: String
{
if enState=admmStateOff
s="CALC1 OFF"
elseif enState=admmStateOn
s="CALC1 ON"
endif
SendString(s)
CheckError()
}
Procedure SetDisplayClear(lDisplayLine): Void ! Clears the text message displayed on the top line or bottom line of the instrument's front-panel display.
--------------------------------------------------------------------------------
lDisplayLine: Val Long ! Display line to clear. Choose a value of 1 or 2.
s: String
{
s="DISP:WIND"+Str(lDisplayLine)+":TEXT:CLE"
SendString(s)
CheckError()
}
Procedure SetDisplayEnabled(lDisplayLine, enState): Void ! Enables or disables the instrument's front-panel display.
--------------------------------------------------------------------------------
lDisplayLine: Val Long ! Display line to enable or disable.
enState: Val enumDmmState ! Enables or disables the instrument's front-panel display.
s: String
{
s="DISP:WIND"+Str(lDisplayLine)+":STAT"
if enState=admmStateOff
s=s+" OFF"
elseif enState=admmStateOn
s=s+" ON"
endif
SendString(s)
CheckError()
}
Procedure SetDisplayText(lDisplayLine, sVal): Void ! Displays a text message on the top line or bottom line of the instrument's front-panel display.
--------------------------------------------------------------------------------
lDisplayLine: Val Long ! Display line on which to display the specified text.
sVal: Val String ! Displays a text message on the top line or bottom line of the instrument's front-panel display.
s: String
{
s="DISP:WIND"+Str(lDisplayLine)+":TEXT:DATA "+sVal
SendString(s)
CheckError()
}
Procedure SetFormatBorder(enFormatBorder): Void ! This command selects the byte order for binary block transfers using the MEASure?, READ?, FETCh?, DATA:REMove? and R? commands.
--------------------------------------------------------------------------------
enFormatBorder: Val enumDmmFormatBorder ! In normal, the most-significant byte is sent first. In swapped, the least-significant byte is sent first.
{
if enFormatBorder=admmFormatBorderNormal
SendString("FORM:BORD NORM")
elseif enFormatBorder=admmFormatBorderSwapped
SendString("FORM:BORD SWAP")
endif
CheckError()
}
Procedure SetFormatData(enFormatData): Void ! Specifies the data format to be either ASCII or REAL. This command affects the data format of the MEASure?, READ?, FETCh?, DATA:REMove? and R? commands.
--------------------------------------------------------------------------------
enFormatData: Val enumDmmFormatData
{
if enFormatData=admmFormatDataAscii
SendString("FORM:DATA ASCII,15")
elseif enFormatData=admmFormatDataReal
SendString("FORM:DATA REAL,64")
endif
CheckError()
}
Procedure SetFormatPhase(enFormatPhase): Void ! This command selects whether phase measurements are displayed in the fixed range of ±180° or 0° to 360°, or whether the instrument will automatically switch between these ranges based on the measurement history.
--------------------------------------------------------------------------------
enFormatPhase: Val enumDmmFormatPhase
{
select enFormatPhase
case admmFormatPhaseCentered
SendString("FORM:PHAS CENT")
case admmFormatPhasePositive
SendString("FORM:PHAS POS")
case admmFormatPhaseAuto
SendString("FORM:PHAS AUTO")
endselect
CheckError()
}
Procedure SetFunctionCapacitance(dRange, dResolution): Void ! Configures the meter for capacitance measurements.
--------------------------------------------------------------------------------
dRange: Val Double ! Desired range in Farads or -1 for auto range. Valid values are from 1 nF to 10 uF.
dResolution: [Val] Double = 0 ! Measurement resolution. Desired resolution in farads.
s: String
{
if dRange=-1
s="CONF:CAP AUTO,"
else
s="CONF:CAP "+Str(dRange)+","
endif
if dResolution=0
s=s+"DEF"
else
s=s+Str(dResolution)
endif
SendString(s)
CheckError()
m_enLastFunction=admmFunctionCapacitance
}
Procedure SetFunctionContinuity(): Void ! Configures the meter for continuity measurements.
--------------------------------------------------------------------------------
{
SendString("CONF:CONT")
CheckError()
m_enLastFunction=admmFunctionContinuity
}
Procedure SetFunctionDiode(): Void ! Configure the meter for diode measurements.
--------------------------------------------------------------------------------
{
SendString("CONF:DIOD")
CheckError()
m_enLastFunction=admmFunctionDiode
}
Procedure SetFunctionFrequency(dRange, dResolution): Void ! Configure the meter for a frequency measurement.
--------------------------------------------------------------------------------
dRange: Val Double ! Approximate frequency of the input signal in hertz. Range: 3 Hz to 300 kHz.
dResolution: [Val] Double = 0 ! Measurement resolution. Desired resolution in hertz.
s: String
{
s="CONF:FREQ "+Str(dRange)+","
if dResolution=0
s=s+"DEF"
else
s=s+Str(dResolution)
endif
SendString(s)
CheckError()
m_enLastFunction=admmFunctionFrequency
}
Procedure SetFunctionIAC(dRange, dResolution): Void ! Resets all measurement parameters and then configures the DMM for current measurements. This method does not initiate a scan.
--------------------------------------------------------------------------------
dRange: [Val] Double = -1 ! The expected signal value in amps or -1 for auto range.
dResolution: [Val] Double = 0 ! Measurement resolution. Desired resolution in amperes. (Default Fixed at 6.5 Digits)
s: String
{
s="CONF:CURR:AC "
if dRange=-1
s=s+"AUTO"
else
s=s+Str(dRange)+","
if dResolution=0
s=s+"DEF"
else
s=s+Str(dResolution)
endif
endif
SendString(s)
CheckError()
m_enLastFunction=admmFunctionCurrentAC
}
Procedure SetFunctionIDC(dRange, dResolution): Void ! Resets all measurement parameters and then configures the DMM for DC current measurements. This method does not initiate a scan.
--------------------------------------------------------------------------------
dRange: [Val] Double = -1 ! The expected signal value in amps or -1 for auto range.
dResolution: [Val] Double = 0 ! Measurement resolution. Desired resolution in volts. (Default 0.3 ppm times the range)
s: String
{
s="CONF:CURR:DC "
if dRange=-1
s=s+"AUTO"
else
s=s+Str(dRange)+","
if dResolution=0
s=s+"DEF"
else
s=s+Str(dResolution)
endif
endif
SendString(s)
CheckError()
m_enLastFunction=admmFunctionCurrentDC
}
Procedure SetFunctionVAC(dRange, dResolution): Void ! Resets all measurement parameters and then configures the DMM for current measurements. This method does not initiate a scan.
--------------------------------------------------------------------------------
dRange: [Val] Double = -1 ! The expected signal value in volts or -1 for auto range.
dResolution: [Val] Double = 0 ! Measurement resolution. Desired resolution in volts. (Default Fixed at 6.5 Digits)
s: String
{
s="CONF:VOLT:AC "
if dRange=-1
s=s+"AUTO"
else
s=s+Str(dRange)+","
if dResolution=0
s=s+"DEF"
else
s=s+Str(dResolution)
endif
endif
SendString(s)
CheckError()
m_enLastFunction=admmFunctionVoltageAC
}
Procedure SetFunctionVDC(dRange, dResolution): Void ! Resets all measurement parameters and then configures the DMM for voltage measurements. This method does not initiate a scan.
--------------------------------------------------------------------------------
dRange: [Val] Double = -1 ! The expected signal value in volts or -1 for auto range.
dResolution: [Val] Double = 0 ! Measurement resolution. Desired resolution in volts. (Default 0.3 ppm times the range)
s: String
{
s="CONF:VOLT:DC "
if dRange=-1
s=s+"AUTO"
else
s=s+Str(dRange)+","
if dResolution=0
s=s+"DEF"
else
s=s+Str(dResolution)
endif
endif
SendString(s)
CheckError()
m_enLastFunction=admmFunctionVoltageDC
}
Procedure SetFunctionVDCImpedanceAuto(enState): Void
--------------------------------------------------------------------------------
! This command disables or enables the automatic input impedance mode for dc voltage measurements. Normally, the instrument's input resistance is fixed at 10 MO for all dc voltage measurements to minimize noise pickup. In the automatic input impedance mode ("AUTO ON"), the input impedance is automatically varied according to range. For the 100 mV, 1 V, and 10 V ranges the input impedance is automatically set to "HI-Z" (>10 GO) to reduce the effects of measurement loading errors on these lower ranges. For the 100 V and 1000 V ranges, the input impedance remains at 10 MO.
! [SENSe:]VOLTage[:DC]:IMPedance:AUTO {OFF|0|ON|1}
! Remarks
! This command affects dc voltage measurements only.
!
! With "AUTO OFF" (default), the input impedance for dc voltage measurements is fixed at 10 MO for all ranges.
!
! With "AUTO ON", the input impedance for dc voltage measurements is automatically selected according to range. The impedance is set to "HI-Z" (>10 GO) for the 100 mV, 1 V, and 10 V ranges. The 100 V and 1000 V ranges remain at a 10 MO input impedance.
!
! The CONFigure and MEASure? commands automatically select "AUTO OFF" (fixed at 10 MO for all ranges).
!
! This setting is reset to the default (fixed, 10 MO) by the *RST and SYSTem:PRESet commands.
enState: Val enumDmmState ! State of Auto Impedance
s: String
{
s="SENS:VOLT:DC:IMP:AUTO"
select enState
case admmStateOn
s=s+" ON"
case admmStateOff
s=s+" OFF"
case else
return
endselect
SendString(s)
CheckError()
}
Procedure SetFunctionVDCRangeAuto(enState): Void
--------------------------------------------------------------------------------
enState: Val enumDmmState ! State of Auto Range
s: String
{
s="SENS:VOLT:DC:RANG:AUTO"
select enState
case admmStateOn
s=s+" ON"
case admmStateOff
s=s+" OFF"
case else
return
endselect
SendString(s)
CheckError()
}
Procedure SetFunctionPeriod(dRange, dResolution): Void ! Configures the meter for period measurements.
--------------------------------------------------------------------------------
dRange: Val Double ! Approximate period of the input signal in seconds, between 3.33 uS and 333.33 mS. Units are seconds.
dResolution: [Val] Double = 0 ! Measurement resolution. Desired resolution in seconds.
s: String
{
s="CONF:PER "+Str(dRange)+","
if dResolution=0
s=s+"DEF"
else
s=s+Str(dResolution)
endif
SendString(s)
CheckError()
m_enLastFunction=admmFunctionPeriod
}
Procedure SetFunctionResistanceFourWire(dRange, dResolution): Void ! Configures the meter for 4-wire resistance measurements.
--------------------------------------------------------------------------------
dRange: Val Double ! Desired range in Ohms or -1 for auto range. Valid values are from 1 kOhm to 1 GOhm.
dResolution: [Val] Double = 0 ! Measurement resolution. Desired resolution in ohms.
s: String
{
s="CONF:FRES "
if dRange=-1
s=s+"AUTO"
else
s=s+Str(dRange)+","
if dResolution=0
s=s+Str(dResolution)
endif
endif
SendString(s)
CheckError()
m_enLastFunction=admmFunction4WireResistance
}
Procedure SetFunctionResistanceTwoWire(dRange, dResolution): Void ! Configures the meter for 2-wire resistance measurements.
--------------------------------------------------------------------------------
dRange: Val Double ! Desired range in Ohms or -1 for auto range. Valid values are from 100 Ohms to 1 GOhm.
dResolution: [Val] Double = 0 ! Measurement resolution. Desired resolution in ohms.
s: String
{
s="CONF:RES "
if dRange=-1
s=s+"AUTO"
else
s=s+Str(dRange)+","
if dResolution=0
s=s+"DEF"
else
s=s+Str(dResolution)
endif
endif
SendString(s)
CheckError()
m_enLastFunction=admmFunction2WireResistance
}
Procedure SetFunctionTemperatureFourWireRTD(dResolution): Void ! Configures the meter for 4-wire RTD measurements.
--------------------------------------------------------------------------------
dResolution: [Val] Long = 0 ! Measurement resolution. Desired resolution in the selected units: C, F, or K.
s: String
{
s="CONF:TEMP FRTD,85,"
if dResolution=0
s=s+"DEF"
else
s=s+Str(dResolution)
endif
SendString(s)
CheckError()
m_enLastFunction=admmFunctionTemperature
}
Procedure SetFunctionTemperatureFourWireThermistor(enThermistorType, dResolution): Void ! Configures the meter for 4-wire thermistor temperature measurements.
--------------------------------------------------------------------------------
enThermistorType: Val enumDmmThermistorType ! The thermistor type. Choose from 2252, 5000, or 10000 Ohm.
dResolution: Val Long ! Measurement resolution. Desired resolution in the selected units: C, F, or K.
s: String
{
s="CONF:TEMP FTH,"
select enThermistorType
case admmThermistorType2252
s=s+"2252,"
case admmThermistorType5000
s=s+"5000,"
case admmThermistorType10000
s=s+"10000,"
endselect
if dResolution=0
s=s+"DEF"
else
s=s+Str(dResolution)
endif
SendString(s)
CheckError()
m_enLastFunction=admmFunctionTemperature
}
Procedure SetFunctionTemperatureTransducerType(enTransducerType): Void ! This function configures the DMM to take temperature measurements from a specified transducer type.
--------------------------------------------------------------------------------
enTransducerType: Val enumDmmTransducerType ! Specifies the device used to measure the temperature. The driver uses this value to set the Temperature Transducer Type attribute. See the attribute description for more details.
s: String
{
s="SENS:TEMP:TRAN:TYPE "
select enTransducerType
case admmTransducerType4WireRTD
s=s+"FRTD"
case admmTransducerType2WireRTD
s=s+"RTD"
case admmTransducerType4WireThermistor
s=s+"FTH"
case admmTransducerType2WireThermistor
s=s+"THER"
endselect
SendString(s)
CheckError()
}
Procedure SetFunctionTemperatureTwoWireRTD(): Void ! Configures the meter for RTD temperature measurements.
--------------------------------------------------------------------------------
s: String
{
s="CONF:TEMP RTD,85,"
!if dResolution=0
s=s+"DEF"
!else
! s=s+Str(dResolution)
!endif
SendString(s)
CheckError()
m_enLastFunction=admmFunctionTemperature
}
Procedure SetFunctionTemperatureTwoWireThermistor(enThermistorType, dResolution): Void ! Configures the meter for thermistor temperature measurements.
--------------------------------------------------------------------------------
enThermistorType: Val enumDmmThermistorType ! The thermistor type. Choose from 2252, 5000, or 10000 Ohm.
dResolution: [Val] Double = 0 ! Measurement resolution. Desired resolution in the currently selected units: C, F, or K.
s: String
{
s="CONF:TEMP THER,"
select enThermistorType
case admmThermistorType2252
s=s+"2252,"
case admmThermistorType5000
s=s+"5000,"
case admmThermistorType10000
s=s+"10000,"
endselect
if dResolution=0
s=s+"DEF"
else
s=s+Str(dResolution)
endif
SendString(s)
CheckError()
m_enLastFunction=admmFunctionTemperature
}
Procedure SetLineFrequency(enReferenceFrequency): Void
--------------------------------------------------------------------------------
! The query returns the power-line reference frequency currently used by the 34410A/11A/L4411A analog-to-digital converter (50 or 60 Hz). When you apply power to the instrument, the instrument automatically detects the power-line frequency and uses this value to determine the integration time used.
!
! The command form allows you to override automatic detection and set either 50 or 60 Hz. However, it is recommended that you use automatic detection to ensure that the calibration is performed with the reference frequency set to the line frequency in use. In special cases, the dominant noise source in the operating environment may be at the other frequency (or harmonic thereof) and an override may be appropriate.
enReferenceFrequency: Val enumDmmReferenceFrequency
s: String
{
s="CAL:LFR "
if enReferenceFrequency=admmReferenceFrequency50or400Hz
s=s+"50"
elseif enReferenceFrequency=admmReferenceFrequency60Hz
s=s+"60"
endif
SendString(s)
CheckError()
}
Procedure SetMultiPoint(lTriggerCount, lSampleCount, enSampleTriggerSource, dSampleInterval): Void ! Configures multipoint trigger Count, SampleCount, SampleTrigger and SampleInterval properties.
--------------------------------------------------------------------------------
lTriggerCount: Val Long ! The number of triggers the DMM accepts before it returns to the idle state.
lSampleCount: Val Long ! The number of measurements the DMM takes each time it receives a trigger.
enSampleTriggerSource: Val enumDmmSampleTriggerSource ! The sample trigger source.
dSampleInterval: Val Double ! The interval between samples in seconds.
s: String
{
s="TRIG:COUN "+Str(lTriggerCount)
SendString(s)
CheckError()
s="SAMP:COUN "+Str(lSampleCount)
SendString(s)
CheckError()
if enSampleTriggerSource=admmSampleTriggerSourceImmediate
s="SAMP:SOUR IMM"
else
s="SAMP:SOUR TIM"
endif
SendString(s)
CheckError()
s="SAMP:TIM "+Str(dSampleInterval)
SendString(s)
CheckError()
}
Procedure SetSampleCount(lCount): Void ! This command selects the number of readings (samples) the meter will take per trigger.
--------------------------------------------------------------------------------
lCount: Val Long ! From 1 to 1000000 samples.
s: String
{
s="SAMP:COUN "+Str(lCount)
SendString(s)
CheckError()
}
Procedure SetSampleInterval(dInterval): Void
--------------------------------------------------------------------------------
! This command sets a sample interval for timed sampling when the sample count is greater than one. Use the SAMPle:SOURce command to set the TIMer option for timed sampling.
!
! The first sample is taken one trigger delay time after the trigger (the delay being set with the TRIGger:DELay command). The second sample starts one sample interval after the start of the first sample.
dInterval: Val Double ! Up to 3600 seconds. Min is dependent on measurement.
s: String
{
s="SAMP:TIM "+Str(dInterval)
SendString(s)
CheckError()
}
Procedure SetSampleMode(enSampleTriggerSource): Void ! This command works in conjunction with the TRIGger:DELay command and the SAMPle:TIMer command to determine sample timing when the sample count is greater than one. In all cases, the first sample is taken one trigger delay time after the trigger (the delay being set with the TRIGger:DELay command). Beyond that, the timing mechanism depends on whether you select IMMediate or TIMer as the source:
--------------------------------------------------------------------------------
enSampleTriggerSource: Val enumDmmSampleTriggerSource
s: String
{
if enSampleTriggerSource=admmSampleTriggerSourceImmediate
s="SAMP:SOUR IMM"
elseif enSampleTriggerSource=admmSampleTriggerSourceTimer
s="SAMP:SOUR TIM"
endif
SendString(s)
CheckError()
}
Procedure SetSampleRate(dPowerLineCycles): Void ! This command sets the integration time in number of power line cycles (PLCs) for the active function mode. Integration time affects the measurement resolution (for better resolution, use a longer integration time) and measurement speed (for faster measurements, use a shorter integration time).
--------------------------------------------------------------------------------
dPowerLineCycles: Val Double ! The number of power line cycles to determine the integration time. From 0.001 to 100 PLC.
s: String
enFunction: enumDmmFunction
{
Driver Get Function(enFunction)
CheckError()
select enFunction
case admmFunctionCurrentDC
s="SENS:CURR:DC:NPLC "
case admmFunction4WireResistance
s="SENS:FRES:NPLC "
case admmFunction2WireResistance
s="SENS:RES:NPLC "
case admmFunctionTemperature
s="SENS:TEMP:NPLC "
case admmFunctionVoltageDC
s="SENS:VOLT:DC:NPLC "
case else
return
endselect
s=s+Str(dPowerLineCycles)
SendString(s)
CheckError()
SetApertureState(enFunction, admmStateOff)
}
Procedure SetStatusOperationEnable(enStatusRegisterOperation): Void ! Enables bits in the enable register for the Status Byte Register group.
--------------------------------------------------------------------------------
enStatusRegisterOperation: Val enumDmmStatusRegisterOperation ! This parameter indicates which bits in the Status Byte Register group to enable. Several different values for this enumDmm can be OR'd together to set multiple bits at one time.
s: String
{
s="STAT:OPER:ENAB "+Str(enStatusRegisterOperation)
SendString(s)
CheckError()
}
Procedure SetStatusQuestionableEnable(enStatusRegisterQuestionable): Void ! This query returns the value of the Questionable Status Condition register. The Condition register is a read-only register, which holds the live (unlatched) questionable status of the instrument. Reading the Questionable Condition register does not clear it.
--------------------------------------------------------------------------------
enStatusRegisterQuestionable: Val enumDmmStatusRegisterQuestionable ! This parameter indicates which bits in the Status Byte Register group to enable. Several different values for this enumDmm can be OR'd together to set multiple bits at one time.
s: String
{
s="STAT:QUES:ENAB "+Str(enStatusRegisterQuestionable)+","
SendString(s)
CheckError()
}
Procedure SetStatusClear(): Void ! Clears the event registers in all register groups.
--------------------------------------------------------------------------------
{
SendString("*CLS")
CheckError()
}
Procedure SetStatusPreset(): Void ! This command clears all bits in the Questionable Data enable register and the Standard Operation enable register.
--------------------------------------------------------------------------------
{
SendString("STAT:PRES")
CheckError()
}
Procedure SetSystemBeep(): Void! Issues a single beep immediately from the instrument.
--------------------------------------------------------------------------------
{
SendString("SYST:BEEP:IMM")
CheckError()
}
Procedure SetSystemDisableInterface(enHardwareInterface): Void ! Disables a specified remote interface.
--------------------------------------------------------------------------------
enHardwareInterface: Val enumDmmHardwareInterface ! Hardware interface to disable.
s: String
{
s="SYST:COMM:ENAB OFF,"
select enHardwareInterface
case admmHardwareInterfaceGPIB
s=s+"GPIB"
case admmHardwareInterfaceSockets
s=s+"SOCK"
case admmHardwareInterfaceTelnet
s=s+"TELN"
case admmHardwareInterfaceUSB
s=s+"USB"
case admmHardwareInterfaceVXI
s=s+"VXI11"
case admmHardwareInterfaceWeb
s=s+"WEB"
case admmHardwareInterfaceLAN
s=s+"LAN"
endselect
SendString(s)
CheckError()
}
Procedure SetSystemEnableInterface(enHardwareInterface): Void ! Enables a specified remote interface.
--------------------------------------------------------------------------------
enHardwareInterface: Val enumDmmHardwareInterface ! Hardware interface to enable.
s: String
{
s="SYST:COMM:ENAB ON,"
select enHardwareInterface
case admmHardwareInterfaceGPIB
s=s+"GPIB"
case admmHardwareInterfaceSockets
s=s+"SOCK"
case admmHardwareInterfaceTelnet
s=s+"TELN"
case admmHardwareInterfaceUSB
s=s+"USB"
case admmHardwareInterfaceVXI
s=s+"VXI11"
case admmHardwareInterfaceWeb
s=s+"WEB"
case admmHardwareInterfaceLAN
s=s+"LAN"
endselect
SendString(s)
CheckError()
}
Procedure SetSystemLockRelease(): Void ! Decrements the lock count by one and may release the I/O interface from which the command is executed.
--------------------------------------------------------------------------------
{
SendString("SYST:LOCK:REL")
CheckError()
}
Procedure SetSystemLockRequest(pbRetVal): Void ! Requests a lock of the current I/O interface.
--------------------------------------------------------------------------------
pbRetVal: Var Bool ! Returns true if the lock request is granted or false if denied.
l: Long
{
GetStringToLong("SYST:LOCK:REQ?", l)
CheckError()
if (l=1)
pbRetVal=True
else
pbRetVal=False
endif
}
Procedure SetSystemWaitForOperationComplete(): Void ! Blocks the calling application until the current operation is complete.
--------------------------------------------------------------------------------
l: Long
{
GetStringToLong("*OPC?", l)
}
Procedure SetTriggerCount(lCount): Void ! This command selects the number of triggers that will be accepted by the meter before returning to the "idle" trigger state.
--------------------------------------------------------------------------------
lCount: [Val] Long = -1 ! From 1 to 1000000 triggers. If -1, the instrument will trigger indefinately.
s: String
{
if lCount=-1
s="TRIG:COUN INF"
else
s="TRIG:COUN "+Str(lCount)
endif
SendString(s)
CheckError()
}
Procedure SetTriggerDelay(dDelay): Void ! This command sets the delay time in seconds between the trigger signal and enabling the gate open for the first measurement. This may be useful in applications where the signal you want to measure is delayed with respect to the trigger.
--------------------------------------------------------------------------------
dDelay: Val Double ! The trigger delay, from 0.0 to 3600 seconds with 1 us resolution.
s: String
{
s="TRIG:DEL "+Str(dDelay)
SendString(s)
CheckError()
}
Procedure SetTriggerLevel(dLevel): Void
--------------------------------------------------------------------------------
! The 34411A and L4411A (but not the 34410A) allow you to trigger on a defined level of the input signal.
! This command sets the level on which a trigger occurs when the trigger source is set to INTernal
!
! If autoranging is off, the level can take any value between -120% and +120% of the present range for the
! currently selected function. The <value> is entered in the fundamental units for the function (that is volts,
! ohms, or amperes). MIN = -120% and MAX = +120%. Default = 0. This is a required parameter.
!
! If autoranging is on, <value> can take any value between -120% and +120% of the highest range
! for the currently selected function. For example, for dc volts with autoranging, the highest range
! is 1000 volts, and the MAX value is 120% of that: 1200 volts.
dLevel: Val Double ! The trigger level.
s: String
{
s="TRIG:LEV "+Str(dLevel)
SendString(s)
CheckError()
}
Procedure SetTriggerSource(enTriggerSource, dTriggerDelay): Void ! Configures the trigger Source and Delay properties.
--------------------------------------------------------------------------------
enTriggerSource: Val enumDmmTriggerSource ! Trigger source.
dTriggerDelay: Val Double ! The length of time between when the DMM receives the trigger and when it takes a measurement. Use positive values to set the trigger delay in seconds. Negative values are reserved for the auto delay mode.
s: String
{
select enTriggerSource
case admmTriggerSourceImmediate
s="TRIG:SOUR IMM"
case admmTriggerSourceExternal
s="TRIG:SOUR EXT"
case admmTriggerSourceBus
s="TRIG:SOUR BUS"
case admmTriggerSourceInternal
s="TRIG:SOUR INT"
endselect
SendString(s)
CheckError()
s="TRIG:DEL "+Str(dTriggerDelay)
SendString(s)
CheckError()
}
Procedure SetTriggerSlope(enTriggerSlope): Void ! This function configures the polarity of the external trigger source of the DMM.
--------------------------------------------------------------------------------
enTriggerSlope: Val enumDmmTriggerSlope ! Specifies the trigger slope. The driver uses this value to set the Trigger Slope attribute. See the attribute description for more details.
s: String
{
if enTriggerSlope=admmTriggerSlopePositive
s="TRIG:SLOP POS"
elseif enTriggerSlope=admmTriggerSlopeNegative
s="TRIG:SLOP NEG"
endif
SendString(s)
CheckError()
}
Procedure SetTransientIACState(enState): Void ! This command (when STATe= ON) configures the ac current measurement function to also produce peak-to-peak measurements, which may be retrieved separately from the main voltage measurement.
--------------------------------------------------------------------------------
enState: Val enumDmmState
{
if enState=admmStateOff
SendString("SENS:CURR:AC:PEAK:STAT OFF")
elseif enState=admmStateOn
SendString("SENS:CURR:AC:PEAK:STAT ON")
endif
CheckError()
}
Procedure SetTransientIDCState(enState): Void ! This command (when STATe= ON) configures the dc current measurement function to also produce peak-to-peak measurements, which may be retrieved separately from the main voltage measurement.
--------------------------------------------------------------------------------
enState: Val enumDmmState
{
if enState=admmStateOff
SendString("SENS:CURR:DC:PEAK:STAT OFF")
elseif enState=admmStateOn
SendString("SENS:CURR:DC:PEAK:STAT ON")
endif
CheckError()
}
Procedure SetTransientVACState(enState): Void ! This command (when STATe= ON) configures the ac voltage measurement function to also produce peak-to-peak measurements, which may be retrieved separately from the main voltage measurement.
--------------------------------------------------------------------------------
enState: Val enumDmmState
{
if enState=admmStateOff
SendString("SENS:VOLT:AC:PEAK:STAT OFF")
elseif enState=admmStateOn
SendString("SENS:VOLT:AC:PEAK:STAT ON")
endif
CheckError()
}
Procedure SetTransientVDCState(enState): Void ! This command (when STATe= ON) configures the dc voltage measurement function to also produce peak-to-peak measurements, which may be retrieved separately from the main voltage measurement.
--------------------------------------------------------------------------------
enState: Val enumDmmState
{
if enState=admmStateOff
SendString("SENS:VOLT:DC:PEAK:STAT OFF")
elseif enState=admmStateOn
SendString("SENS:VOLT:DC:PEAK:STAT ON")
endif
CheckError()
}
Procedure SystemGetIdentification(psIdentification): Void ! Retrieves revision information from the instrument.
--------------------------------------------------------------------------------
psIdentification: Var String ! Returns the revision of the IVI specific driver, which is the value held in the Specific Driver Revision attribute. Refer to the Specific Driver Revision attribute for more information.
{
GetStringToString("*IDN?", psIdentification)
}
Procedure SystemGetInterfaceEnabled(enHardwareInterface, penState): Void ! Indicates if the specified interface is enabled.
--------------------------------------------------------------------------------
enHardwareInterface: Val enumDmmHardwareInterface ! Hardware interface to enable.
penState: Var enumDmmState
l: Long
s: String
{
s="SYST:COMM:ENAB?"
select enHardwareInterface
case admmHardwareInterfaceGPIB
s=s+" GPIB"
case admmHardwareInterfaceSockets
s=s+" SOCK"
case admmHardwareInterfaceTelnet
s=s+" TELN"
case admmHardwareInterfaceUSB
s=s+" USB"
case admmHardwareInterfaceVXI
s=s+" VXI11"
case admmHardwareInterfaceWeb
s=s+" WEB"
case admmHardwareInterfaceLAN
s=s+" LAN"
endselect
GetStringToLong(s, l)
CheckError()
if l=0
penState=admmStateOff
elseif l=1
penState=admmStateOn
endif
}
Procedure SystemSelfTest(pnTestResult): Void ! Performs an instrument self test, waits for the instrument to complete the test, and queries the instrument for the results. If the instrument passes the test, TestResult is zero and TestMessage is 'Self test passed'.
--------------------------------------------------------------------------------
pnTestResult: Var Short ! The numeric result from the self test operation. 0 = no error (test passed)
{
GetStringToShort("*TST?", pnTestResult)
CheckError()
}
Procedure Trigger(): Void ! Sends a software trigger, which causes the DMM to take a measurement.
--------------------------------------------------------------------------------
{
SendString("*TRG")
CheckError()
}
Procedure UtilityCalibrationADC(pbSuccess): Void ! Performs a low-level calibration of the ADC (analog-to-digital converter) circuitry
--------------------------------------------------------------------------------
pbSuccess: Var Bool ! Returns True if calibration was successful.
lResponse: Long
{
GetStringToLong("CAL:ADC?", lResponse)
CheckError()
if (lResponse=0)
pbSuccess=True
else
pbSuccess=False
endif
}
Procedure UtilityCalibrationAll(pbCalibrationPassed): Void ! Performs a calibration of the multimeter using the specified calibration value. Before you can calibrate the instrument, you must unsecure it by entering the correct security code.
--------------------------------------------------------------------------------
pbCalibrationPassed: Var Bool ! Returns true if calibration passed.
l: Long
{
GetStringToLong("CAL?", l)
CheckError()
if l=0
pbCalibrationPassed=True
elseif l=1
pbCalibrationPassed=False
endif
}
Procedure UtilityCalibrationGetCount(plCount): Void ! This command queries the instrument to determine how many calibrations have been performed. Note that your instrument was calibrated before it left the factory. When you receive your instrument, be sure to read the count to determine the initial values.
--------------------------------------------------------------------------------
plCount: Var Long ! The command returns the calibration count indicating how many calibrations have been performed.
{
GetStringToLong("CAL:COUN?", plCount)
CheckError()
}
Procedure UtilityCalibrationGetLabel(psCalStr): Void ! This command allows you to store one message in calibration memory. For example, you can store such information as the date when the last calibration was performed, the date when the next calibration is due, the instrument's serial number, or even the name and phone number of the person to contact for a new calibration.
--------------------------------------------------------------------------------
psCalStr: Var String ! A string of up to 40 characters.
{
GetStringToString("CAL:STR?", psCalStr)
CheckError()
}
Procedure UtilityCalibrationGetSecurityState(penState): Void ! Unsecures or secures the instrument for calibration.
--------------------------------------------------------------------------------
penState: Var enumDmmState ! ON secures the instrument. OFF unsecures the instrument.
l: Long
{
GetStringToLong("CAL:SEC:STAT?", l)
CheckError()
if l=1
penState=admmStateOn
elseif l=0
penState=admmStateOff
endif
}
Procedure UtilityCalibrationGetValue(pdValue): Void ! This command specifies the value of the known calibration signal as outlined in the calibration procedures in the Agilent 34410A/11A/L4411A Service Guide.
--------------------------------------------------------------------------------
pdValue: Var Double ! Desired calibration signal in the units specified by the present measurement function.
{
GetStringToDouble("CAL:VAL?", pdValue)
CheckError()
}
Procedure UtilityCalibrationSave(): Void ! Stores the calibration constants in non-volatile memory.
--------------------------------------------------------------------------------
{
SendString("CAL:STOR")
CheckError()
}
Procedure UtilityCalibrationSetLabel(sCalStr): Void ! This command allows you to store one message in calibration memory. For example, you can store such information as the date when the last calibration was performed, the date when the next calibration is due, the instrument's serial number, or even the name and phone number of the person to contact for a new calibration.
--------------------------------------------------------------------------------
sCalStr: Val String ! A string of up to 40 characters.
s: String
{
s="CAL:STR \""+sCalStr+"\""
SendString(s)
CheckError()
}
Procedure UtilityCalibrationSetSecurityCode(sCode): Void ! This command allows you to enter a new security code to prevent accidental or unauthorized calibrations. The specified code is used to unsecure calibration memory. To change the security code, you must first unsecure calibration memory using the old security code, and then enter a new code.
--------------------------------------------------------------------------------
sCode: Val String ! A string of up to 12 characters. You do not have to use all 12 characters but the first character must always be a letter (A-Z). The remaining 11 characters can be letters, numbers (0-9), or the underscore character ('_'). Blank spaces are not allowed.
s: String
{
s="CAL:SEC:CODE "+sCode
SendString(s)
CheckError()
}
Procedure UtilityCalibrationSetSecurityState(enState, sCode): Void ! Unsecures or secures the instrument for calibration.
--------------------------------------------------------------------------------
enState: Val enumDmmState ! ON secures the instrument. OFF unsecures the instrument.
sCode: [Val] String = "AT34411"! A string of up to 12 characters. You do not have to use all 12 characters but the first character must always be a letter (A-Z). The remaining 11 characters can be letters, numbers (0-9), or the underscore character ('_'). Blank spaces are not allowed.
s: String
{
s="CAL:SEC:STAT "
if enState=admmStateOn
s=s+"ON,"
elseif enState=admmStateOff
s=s+"OFF,"
endif
s=s+sCode
SendString(s)
CheckError()
}
Procedure UtilityCalibrationSetValue(dValue): Void ! This command specifies the value of the known calibration signal as outlined in the calibration procedures in the Agilent 34410A/11A/L4411A Service Guide.
--------------------------------------------------------------------------------
dValue: Val Double ! Desired calibration signal in the units specified by the present measurement function.
s: String
{
s="CAL:VAL "+Str(dValue)
SendString(s)
CheckError()
}
Procedure UtilityConfigurationDelete(enMemoryLocation): Void ! Deletes the contents of the specified storage location.
--------------------------------------------------------------------------------
enMemoryLocation: [Val] enumDmmMemoryLocation = admmMemoryLocation0 ! Store location number to delete. Valid values are from 0 to 4.
s: String
{
s="MEM:STAT:DEL "+Str(enMemoryLocation)
SendString(s)
CheckError()
}
Procedure UtilityConfigurationDeleteAll(): Void ! Deletes the contents of all storage locations (0 to 4).
--------------------------------------------------------------------------------
{
SendString("MEM:STAT:DEL:ALL")
CheckError()
}
Procedure UtilityConfigurationGetName(enMemoryLocation, psRetVal): Void ! Returns the name of the specified storage location.
--------------------------------------------------------------------------------
enMemoryLocation: [Val] enumDmmMemoryLocation = admmMemoryLocation0 ! Store location number to delete. Valid values are from 0 to 4.
psRetVal: Var String ! The storage location name.
s: String
{
s="MEM:STAT:NAME? "+Str(enMemoryLocation)
GetStringToString(s, psRetVal)
CheckError()
}
Procedure UtilityConfigurationIsValid(enMemoryLocation, pbValid): Void ! This command queries the specified storage location to determine if a valid state is currently stored in this location.
--------------------------------------------------------------------------------
enMemoryLocation: [Val] enumDmmMemoryLocation = admmMemoryLocation0 ! Store location number to delete. Valid values are from 0 to 4.
pbValid: Var Bool ! Returns True if valid state is stored in this location, returns False if no state has been stored or if it has been deleted.
l: Long
{
GetStringToLong("MEM:STAT:VAL? "+Str(enMemoryLocation), l)
CheckError()
if l=0
pbValid=False
else
pbValid=True
endif
}
Procedure UtilityConfigurationRecall(enMemoryLocation): Void ! Recalls the instrument state stored in the specified storage location.
--------------------------------------------------------------------------------
enMemoryLocation: [Val] enumDmmMemoryLocation = admmMemoryLocation0 ! Store location number to delete. Valid values are from 0 to 4.
{
SendString("*RCL "+Str(enMemoryLocation))
CheckError()
}
Procedure UtilityConfigurationSave(enMemoryLocation): Void ! Stores (saves) the current instrument state in the specified storage location.
--------------------------------------------------------------------------------
enMemoryLocation: [Val] enumDmmMemoryLocation = admmMemoryLocation0 ! Store location number to delete. Valid values are from 0 to 4.
{
SendString("*SAV "+Str(enMemoryLocation))
CheckError()
}
Procedure UtilityConfigurationSetName(enMemoryLocation, sLocationName): Void ! Sets the name for a specified storage location.
--------------------------------------------------------------------------------
enMemoryLocation: [Val] enumDmmMemoryLocation = admmMemoryLocation0 ! Store location number to delete. Valid values are from 0 to 4.
sLocationName: Val String ! A string of up to 12 characters. The first character must be a letter (A-Z), but the remaining 11 characters can be letters, numbers (0-9), or the underscore character. Blank spaces are not allowed.
s: String
{
s="MEM:STAT:NAME "
s=s+Str(enMemoryLocation)
s=s+","+sLocationName
SendString(s)
CheckError()
}
IOTables
================================================================================
IoTable GetStringToShort(s, nData): Void
--------------------------------------------------------------------------------
IoOperation Output:String
{
Mode = ParameterToAscii
Argument = "s"
MaxSize = 0
}
IoOperation Send
{
}
IoOperation Delay
{
Delay = 1
}
IoOperation Receive
{
}
IoOperation Input:Short
{
Mode = AsciiToParameter
Argument = "nData"
}
IoTable GetStringToLong(s, x): Void Public
--------------------------------------------------------------------------------
IoOperation Output:String
{
Mode = ParameterToAscii
Argument = "s"
MaxSize = 0
}
IoOperation Send
{
Timeout = 5000
}
IoOperation Delay
{
Delay = 1
}
IoOperation Receive
{
Timeout = 20000
}
IoOperation Input:Long
{
Mode = AsciiToParameter
Argument = "x"
}
IoTable GetStringToDoubleArray(s, x): Void Public
--------------------------------------------------------------------------------
IoOperation Output:String
{
Mode = ParameterToAscii
Argument = "s"
MaxSize = 0
}
IoOperation Send
{
}
IoOperation Delay
{
Delay = 1
}
IoOperation Receive
{
}
IoOperation Input:Double
{
Mode = AsciiToParameter
Argument = "x"
DimMin = {1}
DimMax = {50000}
DimDelimiter =
{
","
}
}
IoTable GetStringToDouble(s, x): Void Public
--------------------------------------------------------------------------------
IoOperation Output:String
{
Mode = ParameterToAscii
Argument = "s"
MaxSize = 0
}
IoOperation Send
{
}
IoOperation Delay
{
Delay = 1
}
IoOperation Receive
{
}
IoOperation Input:Double
{
Mode = AsciiToParameter
Argument = "x"
}
IoTable GetStringToString(s, s1): Void Public
--------------------------------------------------------------------------------
IoOperation Output:String
{
Mode = ParameterToAscii
Argument = "s"
MaxSize = 0
}
IoOperation Send
{
}
IoOperation Delay
{
Delay = 1
}
IoOperation Receive
{
Terminator = "\n"
}
IoOperation Input:String
{
Mode = AsciiToParameter
Argument = "s1"
MaxSize = 256
}
IoTable GetStringToStringDoubleDouble(sCommand, s1, d1, d2): Void
--------------------------------------------------------------------------------
IoOperation Output:String
{
Mode = ParameterToAscii
Argument = "sCommand"
MaxSize = 0
}
IoOperation Send
{
}
IoOperation Delay
{
Delay = 1
}
IoOperation Receive
{
}
IoOperation Input:String
{
Mode = AsciiToParameter
Argument = "s1"
MaxSize = 0
}
IoOperation Input:Double
{
Mode = AsciiToParameter
Argument = "d1"
}
IoOperation Input:Double
{
Mode = AsciiToParameter
Argument = "d2"
}
IoTable GetStringToStringDoubleString(sCommand, s1, d, s2): Void
--------------------------------------------------------------------------------
IoOperation Output:String
{
Mode = ParameterToAscii
Argument = "sCommand"
MaxSize = 0
}
IoOperation Send
{
}
IoOperation Delay
{
Delay = 1
}
IoOperation Receive
{
}
IoOperation Input:String
{
Mode = AsciiToParameter
Argument = "s1"
MaxSize = 0
}
IoOperation Input:Double
{
Mode = AsciiToParameter
Argument = "d"
}
IoOperation Input:String
{
Mode = AsciiToParameter
Argument = "s2"
MaxSize = 255
}
IoTable GetStringToDoubleLong(sCommand, lValue1, lValue2): Void
--------------------------------------------------------------------------------
IoOperation Output:String
{
Mode = ParameterToAscii
Argument = "sCommand"
MaxSize = 0
}
IoOperation Send
{
}
IoOperation Delay
{
Delay = 1
}
IoOperation Receive
{
}
IoOperation Input:Long
{
Mode = AsciiToParameter
Argument = "lValue1"
}
IoOperation Input:Long
{
Mode = AsciiToParameter
Argument = "lValue2"
}
IoTable GetStringToStringCommaLong(sCommand, sDescr, lValue): Void
--------------------------------------------------------------------------------
IoOperation Output:String
{
Mode = ParameterToAscii
Argument = "sCommand"
MaxSize = 0
}
IoOperation Send
{
}
IoOperation Delay
{
Delay = 1
}
IoOperation Receive
{
}
IoOperation Input:String
{
Mode = AsciiToParameter
Argument = "sDescr"
MaxSize = 255
}
IoOperation Input:Long
{
Mode = AsciiToParameter
Argument = "lValue"
}
IoTable GetStringToDoubleCommaString(sCommand, dValue, sDescr): Void
--------------------------------------------------------------------------------
IoOperation Output:String
{
Mode = ParameterToAscii
Argument = "sCommand"
MaxSize = 0
}
IoOperation Send
{
}
IoOperation Delay
{
Delay = 1
}
IoOperation Receive
{
}
IoOperation Input:Double
{
Mode = AsciiToParameter
Argument = "dValue"
}
IoOperation Input:String
{
Mode = AsciiToParameter
Argument = "sDescr"
MaxSize = 255
}
IoTable GetStringToLongCommaString(sCommand, lValue, sDescr): Void
--------------------------------------------------------------------------------
IoOperation Output:String
{
Mode = ParameterToAscii
Argument = "sCommand"
MaxSize = 0
}
IoOperation Send
{
}
IoOperation Delay
{
Delay = 2
}
IoOperation Receive
{
}
IoOperation Input:Long
{
Mode = AsciiToParameter
Argument = "lValue"
}
IoOperation Input:String
{
Mode = AsciiToParameter
Argument = "sDescr"
MaxSize = 255
}
IoTable ReceiveDouble(d): Void
--------------------------------------------------------------------------------
IoOperation Receive
{
Terminator = "\n"
}
IoOperation Input:Double
{
Mode = AsciiToParameter
Argument = "d"
}
IoTable ReceiveLong(pl): Void
--------------------------------------------------------------------------------
IoOperation Receive
{
Terminator = "\n"
}
IoOperation Input:Long
{
Mode = AsciiToParameter
Argument = "pl"
}
IoTable ReceiveString(ps): Void Public ! Receives a string from the instrument
--------------------------------------------------------------------------------
IoOperation Receive
{
Terminator = "\n"
Timeout = 250
}
IoOperation Input:String
{
Mode = AsciiToParameter
Argument = "ps"
MaxSize = 0
}
IoTable SendString(s): Void Public ! Sends a string to the instrument
--------------------------------------------------------------------------------
IoOperation Output:String
{
Mode = ParameterToAscii
Argument = "s"
MaxSize = 0
}
IoOperation Send
{
}
Variables
================================================================================
m_sLastError: String Public
m_enLastFunction: enumDmmFunction
m_iLastStatus: Long Public
END
The blue text represents keywords that the file uses.
Driver text file always start with ATEasy 14.0 Driver where the version number indicate the ATEasy version used to save the file (v14 is ATEasy 2026).
The first line is followed by a few sections representing the program sub-modules sections: Summary, Interfaces, Libraries , Types, Forms, Tests, Events, Procedures and Variables. The file ends with the END word.
The Summary section contain information about the program module creator, company, versions when the file created and last saved.
The Interfaces list all the interfaces supported by this driver and can be one or more of the following types: None, Com, File, Gpib, Isa, Usb. Vxi or WinSock. Each interface has a type and arguments used to configure the interface.
The Libraries section contains list of DLLs, ActiveX and .Net assemblies used by the program.
Types contains list of data types including structures, enumerated types and Typedefs.
Forms contains a list of forms defined in this module. Each form starts by its name, properties, variables, events procedures. Form controls are listed then, each control is listed by its Properties and then events procedures.
Events and Procedures section displays the module events procedures (for example OnInit) and the module procedures each procedure starts with the word Procedures followed by the procedure parameters names and return type. Next, the list the procedure parameters and types, and then the procedure local variables and types. The procedure code is displayed surrounded by curly brackets { }.
IoTables section provides a list of IoTables and their operations. Each IoTable Task is listed by the word IoTable followed by the IoTable name and parameters. IoOperation list is provided to each IoTable and each operation is listed with arguments passed to the operation. The operation can be Output, Send, Delay, Receive, Input and Trig.
Variables section displays a list of variables, each variables start with its name followed by its type, initial value and description.