unit wdaq;
interface
uses WinTypes;
(* The following type declaration is required to define *
* the double pointer type used in these functions. *)
type
PDouble = ^Double;
(*************************************************************************
*
* NI-DAQ Windows - Function Prototypes
* Copyright (C) National Instruments 1994.
*
*************************************************************************)
function A2000_Calibrate(device,saveNewValues,calMethod,channel:Integer;
extRefVoltage:Double):integer;
function A2000_Config(device,sampClkSrc,sampClkDrv,dither:Integer)
:integer;
function A2150_Calibrate(device,ref0,ref1:Integer):integer;
function AI_Check(device:Integer; var status,value:Integer):integer;
function AI_Clear(device:Integer):integer;
function AI_Configure(device,chan,inputMode,inputRange: Integer;
unipolar: Bool; driveAIS:Integer):integer;
function AI_Mux_Config(device,numMuxBrds:Integer):integer;
function AI_Read(device,chan,gain:Integer; var value:Integer) :
integer;
function AI_Read_Scan(device:Integer; reading:PInteger):integer;
function AI_Setup(device,chan,gain:Integer):integer;
function AI_VRead(device,chan,gain:Integer; var volts:Double) :
integer;
function AI_VRead_Scan(device:Integer; reading:PDouble):integer;
function AI_VScale(device,chan,gain:Integer; gainAdjust,offset :
Double; reading:Integer; var voltage:Double):integer;
function Align_DMA_Buffer(device,resource:Integer; buffer:Pointer;
cnt,bufSize:Longint; var alignIndex:Longint):integer;
function AO_Calibrate(device,operation,EEPROMloc:Integer):integer;
function AO_Change_Parameter(device,channel:Integer; paramID,paramValue
:Longint):integer;
function AO_Configure(device,chan: Integer; unipolar: Bool;
intOrExtRef:Integer; refVoltage:Double; updateMode:Integer):integer;
function AO_Update(device:Integer):integer;
function AO_VScale(device,chan:Integer; voltage:Double; var value
:Integer):integer;
function AO_VWrite(device,chan:Integer; voltage:Double):integer;
function AO_Write(device,chan,value:Integer):integer;
function Calibrate_E_Series(device:Integer; calOP,setofCalConst:Longint;
calRefVolts:Double):integer;
function Config_Alarm_Deadband(device,mode:Integer; chanStr:PChar;
trigLvl,deadbandWidth:Double; handle,alarmOnMsg,alarmOffMsg:Integer;
callbackAddr:Longint):integer;
function Config_ATrig_Event_Message(device,mode:Integer; chanStr :
PChar; trigLvl,winSize:Double; trigSlope:Integer; skipCnt,preTrigScans,
postTrigScans:Longint; handle,msg:Integer; callBackAddr:Longint)
:integer;
function Config_DAQ_Event_Message(device,mode:Integer; chanStr:PChar;
DAQEvent:Integer; trigVal0,trigVal1:Longint; skipCnt,preTrigScans,
postTrigScans:Longint; handle,msg:Integer; callBackAddr:Longint)
:integer;
function Configure_HW_Analog_Trigger(device:Integer; onOrOff:Longint;
lowValue,highValue:Longint; mode,trigSource:Longint):integer;
function CTR_Config(device,ctr,edgeMode,gateMode,outType,outPolarity
:Integer):integer;
function CTR_EvCount(device,ctr,timebase,cont:Integer):integer;
function CTR_EvRead(device,ctr:Integer; var overflow:Integer; var
counts:Word):integer;
function CTR_FOUT_Config(device,FOUT,mode,timebase,division:Integer)
:integer;
function CTR_Period(device,ctr,timebase:Integer):integer;
function CTR_Pulse(device,ctr,timebase:Integer; delay,pulseWidth
:Word):integer;
function CTR_Rate(freq,duty:Double; var timebase:Integer; var period1,
period2:Word):integer;
function CTR_Reset(device,ctr,outState:Integer):integer;
function CTR_Restart(device,ctr:Integer):integer;
function CTR_Simul_Op(device,numCtrs:Integer; ctrList:PInteger; mode
:Integer):integer;
function CTR_Square(device,ctr,timebase:Integer; period1,period2
:Word):integer;
function CTR_State(device,ctr:Integer; var outState:Integer):integer;
function CTR_Stop(device,ctr:Integer):integer;
function DAQ_Check(device:Integer; var status:Integer; var retrieved
:Longint):integer;
function DAQ_Clear(device:Integer):integer;
function DAQ_Config(device,startTrig,extConv:Integer):integer;
function DAQ_DB_Config(device:Integer; dbMode:Bool):integer;
function DAQ_DB_HalfReady(device:Integer; var halfReady,status:Bool)
:integer;
function DAQ_DB_StrTransfer(device:Integer; buffer:PChar; var ptsTfr
:Longint; var status:Bool):integer;
function DAQ_DB_Transfer(device:Integer; hbuffer:Pointer; var ptsTfr
:Longint; var status:Bool):integer;
function DAQ_Monitor(device,chan:Integer; seq:Bool; monitorCnt:Longint;
monitorBuf:PInteger; var newestIndex:Longint; var status:Bool)
:integer;
function DAQ_Op(device,chan,gain:Integer; buffer:Pointer; cnt:
Longint; sampleRate:Double):integer;
function DAQ_Rate(rate:Double; units:Bool; var timebase:Integer;
var sampleInt:Word):integer;
function DAQ_Start(device,chan,gain:Integer; buffer:Pointer; cnt
:Longint; timebase:Integer; sampInt:Word):integer;
function DAQ_StopTrigger_Config(device,preTrig:Integer; preTrigCnt
:Longint):integer;
function DAQ_to_Disk(device,chan,gain:Integer; fileName:PChar; cnt
:Longint; sampleRate:Double; concat:Bool):integer;
function DAQ_VScale(device,chan,gain:Integer; gainAdjust,offset:
Double; cnt:Longint; binArray:PInteger; voltArray:PDouble):integer;
function DIG_Block_Check(device,grp:Integer; var remaining:Longint)
:integer;
function DIG_Block_Clear(device,grp:Integer):integer;
function DIG_Block_In(device,grp:Integer; buffer:Pointer; cnt:Longint)
:integer;
function DIG_Block_Out(device,grp:Integer; buffer:Pointer; cnt :
Longint):integer;
function DIG_Block_PG_Config(device,grp,PGmode,reqSource,timebase
:Integer; interval:Word; externalGate:Integer):integer;
function DIG_DB_Config(device,grp,DBMode,oldDataStop,partialTransfer
:Integer):integer;
function DIG_DB_HalfReady(device,grp:Integer; var halfReady:Integer)
:integer;
function DIG_DB_StrTransfer(device,grp:Integer; halfBuffer:PChar;
ptsTfr:Longint):integer;
function DIG_DB_Transfer(device,grp:Integer; halfBuffer:Pointer;
ptsTfr:Longint):integer;
function DIG_Grp_Config(device,grp,grpsize,port,direction:Integer)
:integer;
function DIG_Grp_Mode(device,grp,sigType,edge,reqpol,ackpol,settleTime
:Integer):integer;
function DIG_Grp_Status(device,grp:Integer; var status:Integer) :
integer;
function DIG_In_Grp(device,grp:Integer; var grp_pat:Integer):integer;
function DIG_In_Line(device,port,linenum:Integer; var status:Integer)
:integer;
function DIG_In_Port(device,port:Integer; var pattern:Integer) :
integer;
function DIG_Line_Config(device,port,linenum,direction:Integer) :
integer;
function DIG_Out_Grp(device,grp,grp_pat:Integer):integer;
function DIG_Out_Line(device,port,linenum,status:Integer):integer;
function DIG_Out_Port(device,port,pattern:Integer):integer;
function DIG_Prt_Config(device,port,latch_mode,direction:Integer)
:integer;
function DIG_Prt_Status(device,port:Integer; var status:Integer)
:integer;
function DIG_SCAN_Setup(device,grp,numPorts:Integer; portList:PInteger;
direction:Integer):integer;
function DSP2200_Calibrate(device,mode,ADCref:Integer):integer;
function DSP2200_Config(device,aitranslate,aotranslate,demux:Integer)
:integer;
function Get_DAQ_Device_Info(device:Integer; infoType:Longint; var
infoVal:Longint):integer;
function Get_DAQ_Event(timeOut:Longint; var handle,msg,wParam:Integer;
var lParam:Longint):integer;
function Get_NI_DAQ_Version(var version:Longint):integer;
function GPCTR_Change_Parameter(device:Integer; gpCounterNumber,paramID,
paramValue:Longint):integer;
function GPCTR_Config_Buffer(device:Integer; gpCounterNumber,reserved,
numPoints:Longint; buffer:Pointer):integer;
function GPCTR_Control(device:Integer; gpCounterNumber,action:Longint)
:integer;
function GPCTR_Set_Application(device:Integer; gpCounterNumber,application
:Longint):integer;
function GPCTR_Watch(device:Integer; gpCounterNumber,watchID:Longint;
var watchValue:Longint):integer;
function ICTR_Read(device,counter:Integer; var count:Word):integer;
function ICTR_Reset(device,counter,state:Integer):integer;
function ICTR_Setup(device,counter,mode:Integer; cnt:Word; binBCD
:Integer):integer;
function Init_DA_Brds(device:Integer; var brdCode:Integer):integer;
function Lab_ISCAN_Check(device:Integer; var status:Integer; var retrieved
:Longint; finalScanOrder:PInteger):integer;
function Lab_ISCAN_Op(device,numChans,gain:Integer; buffer:Pointer;
cnt:Longint; sampleRate,scanRate:Double; finalScanOrder:PInteger)
:integer;
function Lab_ISCAN_Start(device,numChans,gain:Integer; buffer:Pointer;
cnt:Longint; timebase:Integer; sampleInt,scanInt:Word):integer;
function Lab_ISCAN_to_Disk(device,numChans,gain:Integer; fileName
:PChar; cnt:Longint; sampleRate,scanRate:Double; concat:Integer)
:integer;
function LPM16_Calibrate(device:Integer):integer;
function MAI_Arm(device,onOff:Integer):integer;
function MAI_Clear(device:Integer):integer;
function MAI_Coupling(device,numChans:Integer; coupling:PInteger)
:integer;
function MAI_Read(device:Integer; reading:PInteger):integer;
function MAI_Scale(device:Integer; numScans:Longint; values:PInteger;
volts:PDouble):integer;
function MAI_Setup(device,numChans:Integer; chanList,gainList:PInteger;
muxInterval:Word; timebase,muxMode:Integer):integer;
function Master_Slave_Config(device,numSlaves:Integer; saveList:PInteger)
:integer;
function MDAQ_Check(device,fullCheck:Integer; var acqDone:Integer;
var framesDone,scansDone:Longint):integer;
function MDAQ_Clear(device:Integer):integer;
function MDAQ_Get(device,scansOrFrames,getOrTap:Integer; numToGet,
startFrame,startScan:Longint; timeout:Longint; getBuffer:Pointer;
var numGotten,lastFrame,lastScan:Longint; var acqDone:Integer) :
integer;
function MDAQ_ScanRate(device:Integer; interval:Word; timebase:Integer)
:integer;
function MDAQ_Setup(device:Integer; bufferSize:Longint; scansOrFrames
:Integer; preTrigScans,postTrigScans:Longint; acqBuffer:Pointer)
:integer;
function MDAQ_Start(device:Integer; numTriggers:Longint):integer;
function MDAQ_Stop(device:Integer):integer;
function MDAQ_StrGet(device,scansOrFrames,getOrTap:Integer; numToGet,
startFrame,startScan:Longint; timeout:Longint; getBuffer:PChar;
var numGotten,lastFrame,lastScan:Longint; var acqDone:Integer) :
integer;
function MDAQ_Trig_Delay(device:Integer; postTrigDelay:Word; timebase
:Integer):integer;
function MDAQ_Trig_Select(device,dTrigMode,dEdge,aTrigMode,aSlope,
aLevel,aTrigChan:Integer):integer;
function MIO_Calibrate(device,calOP,saveNewCal,EEPROMloc,CalRefChan,
DAC0Chan,DAC1Chan:Integer; calRefVolts:Double; refLoc:Integer) :
integer;
function MIO_Config(device,dither,useAMUX:Integer):integer;
function NI_DAQ_Mem_Alloc(var handle:Integer; elementSize:Integer;
numElements:Longint; memType,memSource:Integer):integer;
function NI_DAQ_Mem_Attributes(handle:Integer; var elementSize:Integer;
var numElements:Longint; var lockCnt,memType,memSource:Integer) :
integer;
function NI_DAQ_Mem_Copy(handle:Integer; buffer:Pointer; startIndex,
numEl:Longint; CopyDirection:Integer):integer;
function NI_DAQ_Mem_Free(handle:Integer):integer;
function NI_DAQ_Mem_Lock(handle:Integer; var address:Pointer):integer;
function NI_DAQ_Mem_Unlock(handle:Integer):integer;
function Peek_DAQ_Event(timeOut:Longint; var handle,msg,wParam:Integer;
var lParam:Longint):integer;
function REG_Level_Read(device,registerIndex:Integer; var registerValue
:Longint):integer;
function REG_Level_Write(device,registerIndex:Integer; bitsAffected,
bitSettings:Longint; var registerValue:Longint):integer;
function RTSI_Clear(device:Integer):integer;
function RTSI_Clock(device,connect,direction:Integer):integer;
function RTSI_Conn(device,brdSignal,busLine,direction:Integer) :
integer;
function RTSI_DisConn(device,brdSignal,busLine:Integer):integer;
function SC_2040_Config(device,channel,sc2040Gain:Integer):integer;
function SCAN_Demux(buffer:PInteger; cnt:Longint; numChans,muxMode
:Integer):integer;
function SCAN_Op(device,numChans:Integer; chans,gains:PInteger;
buffer:Pointer; cnt:Longint; sampleRate,scanRate:Double):integer;
function SCAN_Sequence_Demux(numChans:Integer; chanVector:PInteger;
bufferSize:Longint; buffer:PInteger; samplesPerSequence:Integer;
scanSequenceVector:PInteger; samplesPerChanVector:PLongint):integer;
function SCAN_Sequence_Retrieve(device,samplesPerSequence:Integer;
scanSequenceVector:PInteger):integer;
function SCAN_Sequence_Setup(device,numChans:Integer; chanVector,gainVector,
scanRateDivVector:PInteger; var scansPerSequence,samplesPerSequence
:Integer):integer;
function SCAN_Setup(device,num_chans:Integer; chans,gains:PInteger)
:integer;
function SCAN_Start(device:Integer; buffer:Pointer; cnt:Longint;
tb1:Integer; si1:Word; tb2:Integer; si2:Word):integer;
function SCAN_to_Disk(device,numChans:Integer; chans,gains:PInteger;
fileName:PChar; cnt:Longint; sampleRate,scanRate:Double; concat
:Integer):integer;
function SCXI_1200_Calibrate(device,calOP,saveNewCal,EEPROMloc,calRefChan,
grndRefChan,DAC0chan,DAC1chan:Integer; calRefVolts,gain:Double)
:integer;
function SCXI_AO_Write(chassisID,module,DACchannel,rangeCode,opCode
:Integer; voltCurrentData:Double; binaryDat:Integer; var binaryWritten
:Integer):integer;
function SCXI_Cal_Constants(chassisID,module,SCXIchannel,operation,
calArea,rangeCode:Integer; SCXIgain:Double; DAQdevice,DAQchannel,
DAQgain:Integer; TBgain,volt1,binary1,volt2,binary2:Double; var
binEEprom1,binEEprom2:Double):integer;
function SCXI_Calibrate_Setup(chassisID,module,calOp:Integer):integer;
function SCXI_Change_Chan(chassisID,module,chan:Integer):integer;
function SCXI_Configure_Filter(chassisID,module,channel,filterMode
:Integer; freq:Double; cutoffDivDown,outClkDivDown:Word; var actFreq
:Double):integer;
function SCXI_Get_Chassis_Info(chassisID:Integer; var chassisType,address,
commMode,commPath,numSlots:Integer):integer;
function SCXI_Get_Module_Info(chassisID,device:Integer; var modulePresent
:Longint; var opMode,DAQdevice:Integer):integer;
function SCXI_Get_State(chassisID,module,port,channel:Integer; var
data:Longint):integer;
function SCXI_Get_Status(chassisID,module,wait:Integer; var data :
Longint):integer;
function SCXI_Load_Config(chassisID:Integer):integer;
function SCXI_MuxCtr_Setup(device,enable,scanDiv:Integer; muxCtrVal
:Word):integer;
function SCXI_Reset(chassisID,moduleSlot:Integer):integer;
function SCXI_Scale(chassisID,module,SCXIchannel:Integer; SCXIgain,
TBgain:Double; DAQdevice,DAQchannel,DAQgain:Integer; numPoints :
Longint; binArray:PInteger; voltArray:PDouble):integer;
function SCXI_SCAN_Setup(chassisID,numModules:Integer; modules,numChans,
startChans:PInteger; DAQdevice,modeFlag:Integer):integer;
function SCXI_Set_Config(chassisID,chassisType,address,commMode,slotOrCOMM,
numSlots:Integer; moduleTypes:PLongint; opModes,DAQdevices:PInteger)
:integer;
function SCXI_Set_Gain(chassisID,module,channel:Integer; gain:Double)
:integer;
function SCXI_Set_Input_Mode(chassisID,module,inputMode:Integer) :
integer;
function SCXI_Set_State(chassisID,module,port,channel:Integer; data
:Longint):integer;
function SCXI_Single_Chan_Setup(chassisID,module,chan,DAQdevice:Integer)
:integer;
function SCXI_Track_Hold_Control(chassisID,module,state,DAQdevice :
Integer):integer;
function SCXI_Track_Hold_Setup(chassisID,module,mode,source,send,
holdCnt,DAQdevice:Integer):integer;
function Select_Signal(device:Integer; signal,source,sourceSpec :
Longint):integer;
function Set_DAQ_Device_Info(device:Integer; infoType,infoVal:Longint)
:integer;
function Timeout_Config(device:Integer; numTicks:Longint):integer;
function Trigger_Window_Config(device,mode:Integer; windowSize:Word)
:integer;
function WFM_Chan_Control(device,channel,operation:Integer):integer;
function WFM_Check(device,channel:Integer; var status:Bool; var
pointsDone,itersDone:Longint):integer;
function WFM_ClockRate(device,group,whickClock,timebase:Integer;
updateInterval:Longint; mode:Integer):integer;
function WFM_DB_Config(device,numChans:Integer; chanVect:PInteger;
DBMode,oldDataStop,partialTransfer:Integer):integer;
function WFM_DB_HalfReady(device,numChans:Integer; chanVect:PInteger;
var halfReady:Integer):integer;
function WFM_DB_Transfer(device,numChans:Integer; chanVect:PInteger;
buffer:Pointer; count:Longint):integer;
function WFM_DB_StrTransfer(device,numChans:Integer; chanVect:PInteger;
strBuffer:PChar; count:Longint):integer;
function WFM_from_Disk(device,numChans:Integer; chanVect:PInteger;
fileName:PChar; startPts,endPts,iterations:Longint; rate:Double)
:integer;
function WFM_Group_Control(device,group,operation:Integer):integer;
function WFM_Group_Setup(device,numChans:Integer; chanVect:PInteger;
group:Integer):integer;
function WFM_Load(device,numChans:Integer; chanVect:PInteger; buffer
:Pointer; count,iterations:Longint; mode:Integer):integer;
function WFM_Op(device,numChans:Integer; chanVect:PInteger; buffer
:Pointer; count,iterations:Longint; rate:Double):integer;
function WFM_Rate(rate:Double; units:Integer; var timebase:Integer;
var updateInterval:Longint):integer;
function WFM_Scale(device,chan:Integer; count:Longint; gain:Double;
voltArray:PDouble; binArray:PInteger):integer;
(*************************************************************************
*
* NI-DAQ Windows - Obsolete Function Prototypes
*
*************************************************************************)
function AI_Scale(device,gain,value:Integer; var voltage:Double)
:integer;
function AI_Config(device,singOrDiff,range,uniOrBi:Integer):integer;
function AO_Config(device,chan,outputPolarity:Integer; refVoltage
:Double; updateMode:Integer):integer;
function DAQ_Scale(device,gain:Integer; cnt:Longint; rawData:PInteger;
scaledData:PDouble):integer;
function DAQ_Trigger_Config(device,preTrig:Integer; preTrigCnt:Longint)
:integer;
function Get_DA_Brds_Info(device:Integer; var brdCode,baseAddr,irq1Lvl,
irq2Lvl,irqTrigMode,dma1Lvl,dma2Lvl,daqMode:Integer):integer;
function Lab_SCAN_Check(device:Integer; var status:Integer; var retrieved
:Longint; finalScanOrder:PInteger):integer;
function Lab_SCAN_Op(device,numChans,gain:Integer; buffer:PInteger;
cnt:Longint; sampleRate:Double; finalScanOrder:PInteger):integer;
function Lab_SCAN_Start(device,numChans,gain:Integer; buffer:PInteger;
cnt:Longint; timebase:Integer; sampleInt:Word):integer;
function Lab_SCAN_to_Disk(device,numChans,gain:Integer; fileName :
PChar; cnt:Longint; sampleRate:Double; concat:Integer):integer;
function MDAQ_Ext_Setup(device:Integer; bufferSize:Longint; scansOrFrames
:Integer; preTrigScans,postTrigScans,extMemAddr:Longint):integer;
function MIO16_F5_Config(device,dither:Integer):integer;
function MIO16_F5_Calibrate(device,calOP,saveNewCal,EEPROMloc,CalRefChan,
DAC0Chan,DAC1Chan:Integer; calRefVolts:Double; refLoc:Integer) :
integer;
function SCXI_Set_Filter(chassisID,module,channel:Integer; extDivideDown
:Word; freq:Double; var actFreq:Double):integer;
function SCXI_Set_Module_Gain(chassisID,module,gain:Integer):integer;
function Set_DAQ_Mode(device,newDaqMode:Integer):integer;
function WF_Check(device,chan:Integer; var status:Integer; var itersDone,
nextPoint:Longint):integer;
function WF_Clear(device:Integer):integer;
function WF_DB_Config(device,chan,DBmode,oldDataStop:Integer):integer;
function WF_DB_StrTransfer(device,chan:Integer; buffer:PChar; cnt
:Longint):integer;
function WF_DB_Transfer(device,chan:Integer; buffer:PInteger; cnt
:Longint):integer;
function WF_from_Disk(device,chan:Integer; fileName:PChar; iters
:Longint; rate:Double; startPt,endPt:Longint):integer;
function WF_Load(device,chan:Integer; buffer:PInteger; cnt,iterations
:Longint):integer;
function WF_Op(device,chan:Integer; buf0,buf1:PInteger; cnt0,cnt1,
iters0,iters1:Longint; rate:Double):integer;
function WF_Pause(device:Integer):integer;
function WF_Rate(rate:Double; units:Integer; var timebase:Integer;
var updateInt:Word):integer;
function WF_Resume(device:Integer):integer;
function WF_Scale(device,chan:Integer; cnt:Longint; gain:Double;
realArray:PDouble; intArray:PInteger):integer;
function WF_Start(device,timebase:Integer; updateInt:Word):integer;
function WFM_UpdateRate(device,group,timebase:Integer; updateInterval
:Longint; mode:Integer):integer;
(*************************************************************************
*
* NI-DAQ Windows - Compatibility with NI-DAQ DOS
*
*************************************************************************)
function USE_E_Series : integer;
function USE_E_Series_AI : integer;
function USE_E_Series_AO : integer;
function USE_E_Series_DAQ : integer;
function USE_E_Series_DIO : integer;
function USE_E_Series_GPCTR : integer;
function USE_E_Series_GPCTR_Simple : integer;
function USE_E_Series_Misc : integer;
function USE_E_Series_WFM : integer;
implementation
function A2000_Calibrate; external 'NIDAQ';
function A2000_Config; external 'NIDAQ';
function A2150_Calibrate; external 'NIDAQ';
function AI_Check; external 'NIDAQ';
function AI_Clear; external 'NIDAQ';
function AI_Configure; external 'NIDAQ';
function AI_Mux_Config; external 'NIDAQ';
function AI_Read; external 'NIDAQ';
function AI_Read_Scan; external 'NIDAQ';
function AI_Setup; external 'NIDAQ';
function AI_VRead; external 'NIDAQ';
function AI_VRead_Scan; external 'NIDAQ';
function AI_VScale; external 'NIDAQ';
function Align_DMA_Buffer; external 'NIDAQ';
function AO_Calibrate; external 'NIDAQ';
function AO_Change_Parameter; external 'NIDAQ';
function AO_Configure; external 'NIDAQ';
function AO_Update; external 'NIDAQ';
function AO_VScale; external 'NIDAQ';
function AO_VWrite; external 'NIDAQ';
function AO_Write; external 'NIDAQ';
function Calibrate_E_Series; external 'NIDAQ';
function Config_Alarm_Deadband; external 'NIDAQ';
function Config_ATrig_Event_Message; external 'NIDAQ';
function Config_DAQ_Event_Message; external 'NIDAQ';
function Configure_HW_Analog_Trigger; external 'NIDAQ';
function CTR_Config; external 'NIDAQ';
function CTR_EvCount; external 'NIDAQ';
function CTR_EvRead; external 'NIDAQ';
function CTR_FOUT_Config; external 'NIDAQ';
function CTR_Period; external 'NIDAQ';
function CTR_Pulse; external 'NIDAQ';
function CTR_Rate; external 'NIDAQ';
function CTR_Reset; external 'NIDAQ';
function CTR_Restart; external 'NIDAQ';
function CTR_Simul_Op; external 'NIDAQ';
function CTR_Square; external 'NIDAQ';
function CTR_State; external 'NIDAQ';
function CTR_Stop; external 'NIDAQ';
function DAQ_Check; external 'NIDAQ';
function DAQ_Clear; external 'NIDAQ';
function DAQ_Config; external 'NIDAQ';
function DAQ_DB_Config; external 'NIDAQ';
function DAQ_DB_HalfReady; external 'NIDAQ';
function DAQ_DB_StrTransfer; external 'NIDAQ';
function DAQ_DB_Transfer; external 'NIDAQ';
function DAQ_Monitor; external 'NIDAQ';
function DAQ_Op; external 'NIDAQ';
function DAQ_Rate; external 'NIDAQ';
function DAQ_Start; external 'NIDAQ';
function DAQ_StopTrigger_Config; external 'NIDAQ';
function DAQ_to_Disk; external 'NIDAQ';
function DAQ_VScale; external 'NIDAQ';
function DIG_Block_Check; external 'NIDAQ';
function DIG_Block_Clear; external 'NIDAQ';
function DIG_Block_In; external 'NIDAQ';
function DIG_Block_Out; external 'NIDAQ';
function DIG_Block_PG_Config; external 'NIDAQ';
function DIG_DB_Config; external 'NIDAQ';
function DIG_DB_HalfReady; external 'NIDAQ';
function DIG_DB_StrTransfer; external 'NIDAQ';
function DIG_DB_Transfer; external 'NIDAQ';
function DIG_Grp_Config; external 'NIDAQ';
function DIG_Grp_Mode; external 'NIDAQ';
function DIG_Grp_Status; external 'NIDAQ';
function DIG_In_Grp; external 'NIDAQ';
function DIG_In_Line; external 'NIDAQ';
function DIG_In_Port; external 'NIDAQ';
function DIG_Line_Config; external 'NIDAQ';
function DIG_Out_Grp; external 'NIDAQ';
function DIG_Out_Line; external 'NIDAQ';
function DIG_Out_Port; external 'NIDAQ';
function DIG_Prt_Config; external 'NIDAQ';
function DIG_Prt_Status; external 'NIDAQ';
function DIG_SCAN_Setup; external 'NIDAQ';
function DSP2200_Calibrate; external 'NIDAQ';
function DSP2200_Config; external 'NIDAQ';
function Get_DAQ_Device_Info; external 'NIDAQ';
function Get_DAQ_Event; external 'NIDAQ';
function Get_NI_DAQ_Version; external 'NIDAQ';
function GPCTR_Change_Parameter; external 'NIDAQ';
function GPCTR_Config_Buffer; external 'NIDAQ';
function GPCTR_Control; external 'NIDAQ';
function GPCTR_Set_Application; external 'NIDAQ';
function GPCTR_Watch; external 'NIDAQ';
function ICTR_Read; external 'NIDAQ';
function ICTR_Reset; external 'NIDAQ';
function ICTR_Setup; external 'NIDAQ';
function Init_DA_Brds; external 'NIDAQ';
function Lab_ISCAN_Check; external 'NIDAQ';
function Lab_ISCAN_Op; external 'NIDAQ';
function Lab_ISCAN_Start; external 'NIDAQ';
function Lab_ISCAN_to_Disk; external 'NIDAQ';
function LPM16_Calibrate; external 'NIDAQ';
function MAI_Arm; external 'NIDAQ';
function MAI_Clear; external 'NIDAQ';
function MAI_Coupling; external 'NIDAQ';
function MAI_Read; external 'NIDAQ';
function MAI_Scale; external 'NIDAQ';
function MAI_Setup; external 'NIDAQ';
function Master_Slave_Config; external 'NIDAQ';
function MDAQ_Check; external 'NIDAQ';
function MDAQ_Clear; external 'NIDAQ';
function MDAQ_Get; external 'NIDAQ';
function MDAQ_ScanRate; external 'NIDAQ';
function MDAQ_Setup; external 'NIDAQ';
function MDAQ_Start; external 'NIDAQ';
function MDAQ_Stop; external 'NIDAQ';
function MDAQ_StrGet; external 'NIDAQ';
function MDAQ_Trig_Delay; external 'NIDAQ';
function MDAQ_Trig_Select; external 'NIDAQ';
function MIO_Calibrate; external 'NIDAQ';
function MIO_Config; external 'NIDAQ';
function NI_DAQ_Mem_Alloc; external 'NIDAQ';
function NI_DAQ_Mem_Attributes; external 'NIDAQ';
function NI_DAQ_Mem_Copy; external 'NIDAQ';
function NI_DAQ_Mem_Free; external 'NIDAQ';
function NI_DAQ_Mem_Lock; external 'NIDAQ';
function NI_DAQ_Mem_Unlock; external 'NIDAQ';
function Peek_DAQ_Event; external 'NIDAQ';
function REG_Level_Read; external 'NIDAQ';
function REG_Level_Write; external 'NIDAQ';
function RTSI_Clear; external 'NIDAQ';
function RTSI_Clock; external 'NIDAQ';
function RTSI_Conn; external 'NIDAQ';
function RTSI_DisConn; external 'NIDAQ';
function SC_2040_Config; external 'NIDAQ';
function SCAN_Demux; external 'NIDAQ';
function SCAN_Op; external 'NIDAQ';
function SCAN_Sequence_Demux; external 'NIDAQ';
function SCAN_Sequence_Retrieve; external 'NIDAQ';
function SCAN_Sequence_Setup; external 'NIDAQ';
function SCAN_Setup; external 'NIDAQ';
function SCAN_Start; external 'NIDAQ';
function SCAN_to_Disk; external 'NIDAQ';
function SCXI_1200_Calibrate; external 'NIDAQ';
function SCXI_AO_Write; external 'NIDAQ';
function SCXI_Cal_Constants; external 'NIDAQ';
function SCXI_Calibrate_Setup; external 'NIDAQ';
function SCXI_Change_Chan; external 'NIDAQ';
function SCXI_Configure_Filter; external 'NIDAQ';
function SCXI_Get_Chassis_Info; external 'NIDAQ';
function SCXI_Get_Module_Info; external 'NIDAQ';
function SCXI_Get_State; external 'NIDAQ';
function SCXI_Get_Status; external 'NIDAQ';
function SCXI_Load_Config; external 'NIDAQ';
function SCXI_MuxCtr_Setup; external 'NIDAQ';
function SCXI_Reset; external 'NIDAQ';
function SCXI_Scale; external 'NIDAQ';
function SCXI_SCAN_Setup; external 'NIDAQ';
function SCXI_Set_Config; external 'NIDAQ';
function SCXI_Set_Gain; external 'NIDAQ';
function SCXI_Set_Input_Mode; external 'NIDAQ';
function SCXI_Set_State; external 'NIDAQ';
function SCXI_Single_Chan_Setup; external 'NIDAQ';
function SCXI_Track_Hold_Control; external 'NIDAQ';
function SCXI_Track_Hold_Setup; external 'NIDAQ';
function Select_Signal; external 'NIDAQ';
function Set_DAQ_Device_Info; external 'NIDAQ';
function Timeout_Config; external 'NIDAQ';
function Trigger_Window_Config; external 'NIDAQ';
function WFM_Chan_Control; external 'NIDAQ';
function WFM_Check; external 'NIDAQ';
function WFM_ClockRate; external 'NIDAQ';
function WFM_DB_Config; external 'NIDAQ';
function WFM_DB_HalfReady; external 'NIDAQ';
function WFM_DB_Transfer; external 'NIDAQ';
function WFM_DB_StrTransfer; external 'NIDAQ';
function WFM_from_Disk; external 'NIDAQ';
function WFM_Group_Control; external 'NIDAQ';
function WFM_Group_Setup; external 'NIDAQ';
function WFM_Load; external 'NIDAQ';
function WFM_Op; external 'NIDAQ';
function WFM_Rate; external 'NIDAQ';
function WFM_Scale; external 'NIDAQ';
function AI_Scale; external 'NIDAQ';
function AI_Config; external 'NIDAQ';
function AO_Config; external 'NIDAQ';
function DAQ_Scale; external 'NIDAQ';
function DAQ_Trigger_Config; external 'NIDAQ';
function Get_DA_Brds_Info; external 'NIDAQ';
function Lab_SCAN_Check; external 'NIDAQ';
function Lab_SCAN_Op; external 'NIDAQ';
function Lab_SCAN_Start; external 'NIDAQ';
function Lab_SCAN_to_Disk; external 'NIDAQ';
function MDAQ_Ext_Setup; external 'NIDAQ';
function MIO16_F5_Config; external 'NIDAQ';
function MIO16_F5_Calibrate; external 'NIDAQ';
function SCXI_Set_Filter; external 'NIDAQ';
function SCXI_Set_Module_Gain; external 'NIDAQ';
function Set_DAQ_Mode; external 'NIDAQ';
function WF_Check; external 'NIDAQ';
function WF_Clear; external 'NIDAQ';
function WF_DB_Config; external 'NIDAQ';
function WF_DB_StrTransfer; external 'NIDAQ';
function WF_DB_Transfer; external 'NIDAQ';
function WF_from_Disk; external 'NIDAQ';
function WF_Load; external 'NIDAQ';
function WF_Op; external 'NIDAQ';
function WF_Pause; external 'NIDAQ';
function WF_Rate; external 'NIDAQ';
function WF_Resume; external 'NIDAQ';
function WF_Scale; external 'NIDAQ';
function WF_Start; external 'NIDAQ';
function WFM_UpdateRate; external 'NIDAQ';
function USE_E_Series; external 'NIDAQ';
function USE_E_Series_AI; external 'NIDAQ';
function USE_E_Series_AO; external 'NIDAQ';
function USE_E_Series_DAQ; external 'NIDAQ';
function USE_E_Series_DIO; external 'NIDAQ';
function USE_E_Series_GPCTR; external 'NIDAQ';
function USE_E_Series_GPCTR_Simple; external 'NIDAQ';
function USE_E_Series_Misc; external 'NIDAQ';
function USE_E_Series_WFM; external 'NIDAQ';
end.
| Detected encoding: ASCII (7 bit) | 2
|