Matlab API LabOne Modules

sweep

handle = ziDAQ('sweep', timeout);

timeout = Poll timeout in [ms] - DEPRECATED, ignored
Creates a sweep class. The thread is not yet started.
Before the thread start subscribe and set command have
to be called. To start the real measurement use the
execute function.

deviceSettings

handle = ziDAQ('deviceSettings', timeout);

timeout = Poll timeout in [ms] - DEPRECATED, ignored
Creates a device settings class for saving/loading device
settings to/from a file. Before starting the module, set the path,
filename and command parameters. To run the command, use the
execute function.

pidAdvisor

handle = ziDAQ('pidAdvisor', timeout);

timeout = Poll timeout in [ms] - DEPRECATED, ignored
Creates a PID Advisor class for simulating the PID in the
device. Before the thread start, set the command parameters,
call execute() and then set the "calculate" parameter to start
the simulation.

awgModule

handle = ziDAQ('awgModule');

Creates an AWG compiler class for compiling the AWG sequence and
pattern downloaded to the device .

impedanceModule

handle = ziDAQ('impedanceModule');

Creates a impedance class for executing a user compenastion.

scopeModule

handle = ziDAQ('scopeModule');

handle = Matlab handle (reference) specifying an instance of
         the DataAcquisitionModule class.
Create an instance of the Scope Module class
and return a Matlab handle with which to access it.

multiDeviceSyncModule

handle = ziDAQ('multiDeviceSyncModule');

handle = Matlab handle (reference) specifying an instance of
         the DataAcquisitionModule class.
Create an instance of the Multi-Device Sync Module class
and return a Matlab handle with which to access it.

dataAcquisitionModule

handle = ziDAQ('dataAcquisitionModule');

handle = Matlab handle (reference) specifying an instance of
         the DataAcquisitionModule class.
Create an instance of the Data Acquisition Module class
and return a Matlab handle with which to access it.
Before the thread can actually be started (via 'execute'):
- the desired data to record must be specified via the module's
  'subscribe' command,
- the device serial (e.g., dev100) that will be used must be
  set.
The real measurement is started upon calling the 'execute'
function. After that the module will start recording data and
verifying for incoming triggers.
Force a trigger to manually record one duration of the
subscribed data.

precompensationAdvisor

handle = ziDAQ('precompensationAdvisor');

handle = Matlab handle (reference) specifying an instance of
         the DataAcquisitionModule class.
Create an instance of the Precompensation Advisor Module class
and return a Matlab handle with which to access it.

record

handle = ziDAQ('record' duration, timeout);

duration (double) = The module's internal buffersize to use when
                    recording data [s]. The recommended size is
                    2*/0/duration parameter. Note that
                    this can be modified via the
                    buffersize parameter.
                    DEPRECATED, set 'buffersize' param instead.
timeout (int64) = Poll timeout [ms]. - DEPRECATED, ignored
Create an instance of the ziDAQRecorder and return a Matlab
handle with which to access it.
Before the thread can actually be started (via 'execute'):
- the desired data to record must be specified via the module's
  'subscribe' command,
- the device serial (e.g., dev100) that will be used must be
  set.
The real measurement is started upon calling the 'execute'
function. After that the trigger will start recording data and
verifying for incoming triggers.

trigger

ziDAQ('trigger', handle);

handle = Matlab handle (reference) specifying an instance of
         the ziDAQRecorder class.
Force a trigger to manually record one duration of the
subscribed data.

zoomFFT

handle = ziDAQ('zoomFFT', timeout);

timeout = Poll timeout in [ms] - DEPRECATED, ignored
Creates a zoom FFT class. The thread is not yet started.
Before the thread start subscribe and set command have
to be called. To start the real measurement use the
execute function.