picotech_ps4000_generic.mdd

<?xml version="1.0" encoding="utf-8"?>
<MATLABInstrumentDriver>
   <FileVersion>2.42</FileVersion>
   <DriverName>picotech_ps4000_generic.mdd</DriverName>
   <DriverType>MATLAB generic</DriverType>
   <InstrumentType>Oscilloscope</InstrumentType>
   <InstrumentManufacturer>Pico Technology Ltd.</InstrumentManufacturer>
   <InstrumentModel>PicoScope 4000 Series</InstrumentModel>
   <InstrumentVersion>1.1.12</InstrumentVersion>
   <Identify/>
   <Reset/>
   <Selftest/>
   <Error/>
   <CreateInitCode>
      <Code>function init(obj)
% This function is called after the object is created.
% OBJ is the device object.
% End of function definition - DO NOT EDIT

% Copyright © 2014-2017 Pico Technology Ltd. All rights reserved.
% You may copy and distribute this file as long as it remains unmodified. 
% SB
    
    fprintf('\nCopyright © 2014-2017 Pico Technology Ltd. All rights reserved.\n');
    fprintf('\n');
    fprintf('PicoScope 4000 Series MATLAB Instrument Driver\n');
    fprintf('\n');

    % Load libraries
    % ==============
    
    % Indentify architecture and obtain function handle for the correct
    % prototype file.
    
    archStr = computer('arch');
    
    ps4000MFile = str2func(strcat('ps4000MFile_', archStr));
    ps4000WrapMFile = str2func(strcat('ps4000WrapMFile_', archStr));
    
    % Only load library once 
    if (libisloaded('ps4000'))
       
        % Do nothing
        
    else
        
        if (ismac())
            
            [ps4000NotFound, ps4000Warnings] = loadlibrary('libps4000.dylib', ps4000MFile, 'alias', 'ps4000');
            
        elseif (isunix())
            
            [ps4000NotFound, ps4000Warnings] = loadlibrary('libps4000.so', ps4000MFile, 'alias', 'ps4000');
                
        elseif (ispc())
            
            [ps4000NotFound, ps4000Warnings] = loadlibrary('ps4000.dll', ps4000MFile);
            
        else
            
            % Do nothing
                
        end     

        
    end  
    
    % Only load library once 
    if (libisloaded('ps4000Wrap'))

        % Do nothing
        
    else
            
        if (ismac())
            
            [ps4000NotFound, ps4000Warnings] = loadlibrary('libps4000Wrap.dylib', ps4000WrapMFile, 'alias', 'ps4000Wrap');
            
        elseif (isunix())
            
            [ps4000NotFound, ps4000Warnings] = loadlibrary('libps4000Wrap.so', ps4000WrapMFile, 'alias', 'ps4000Wrap');
        
        elseif (ispc())
            
            [ps4000NotFound, ps4000Warnings] = loadlibrary('ps4000Wrap.dll', ps4000WrapMFile);
            
        else
            
            % Do nothing
                
        end  
    end
    
    % Load in enumeration and structure information
    % =============================================
    
    [~, obj.DriverData.structs, obj.DriverData.enums, ~] = ps4000MFile(); 
    [~, ~, obj.DriverData.wrapEnums, ~] = ps4000WrapMFile();
    
    % Maximum number of devices using this driver
    % -------------------------------------------
    
    obj.DriverData.constants.PS4000_MAX_UNITS = 64;
    
    % Define constant values used by this Instrument Driver
    % =====================================================
    
    % Constants from ps4000Api.h header file
    % ---------------------------------------
    
    % ETS Mode properties
    obj.DriverData.constants.PS4000_MAX_ETS_CYCLES           = 400;		
    obj.DriverData.constants.PS4000_MAX_ETS_INTERLEAVE       = 80;
        
    obj.DriverData.constants.PS4262_MAX_VALUE                = 32767;
    obj.DriverData.constants.PS4262_MIN_VALUE                = -32767;
        
    obj.DriverData.constants.PS4000_MAX_VALUE                = 32764;
    obj.DriverData.constants.PS4000_MIN_VALUE                = -32764;
        
    % External Trigger Input ADC Count
    obj.DriverData.constants.PS4000_EXT_MAX_VALUE            = 32767;
    obj.DriverData.constants.PS4000_EXT_MIN_VALUE            = -32767;
        
    obj.DriverData.constants.MAX_PULSE_WIDTH_QUALIFIER_COUNT = 16777215;
    obj.DriverData.constants.MAX_DELAY_COUNT                 = 8388607;
		
    % Function/Arbitrary Waveform Parameters
	obj.DriverData.constants.MIN_SIG_GEN_FREQ                = 0.0;
    obj.DriverData.constants.MAX_SIG_GEN_FREQ                = 100000.0;
    obj.DriverData.constants.MAX_SIG_GEN_FREQ_4262           = 20000.0;

    obj.DriverData.constants.MIN_SIG_GEN_BUFFER_SIZE         = 1;
    obj.DriverData.constants.MAX_SIG_GEN_BUFFER_SIZE         = PicoConstants.AWG_BUFFER_8KS;
    obj.DriverData.constants.MIN_DWELL_COUNT                 = 10;
        
    obj.DriverData.constants.PS4262_SIGGEN_MAXPKTOPK         = 2000000;
    obj.DriverData.constants.PS4000_SIGGEN_MAXPKTOPK         = 4000000;   
        
    obj.DriverData.constants.PS4262_MAX_WAVEFORM_BUFFER_SIZE = 4096;
    obj.DriverData.constants.PS4262_MIN_DWELL_COUNT          = 3;
        
    obj.DriverData.constants.MAX_SWEEPS_SHOTS                = pow2(30) - 1; 

    % Frequencies
        
    obj.DriverData.constants.PS4000_SINE_MAX_FREQUENCY		= 20000000;
    obj.DriverData.constants.PS4000_SQUARE_MAX_FREQUENCY    = 20000000;
    obj.DriverData.constants.PS4000_TRIANGLE_MAX_FREQUENCY	= 20000000;
    obj.DriverData.constants.PS4000_SINC_MAX_FREQUENCY		= 20000000
    obj.DriverData.constants.PS4000_RAMP_MAX_FREQUENCY		= 20000000;
    obj.DriverData.constants.PS4000_HALF_SINE_MAX_FREQUENCY	= 20000000;
    obj.DriverData.constants.PS4000_GAUSSIAN_MAX_FREQUENCY  = 20000000;
    obj.DriverData.constants.PS4000_PRBS_MAX_FREQUENCY		= 1000000;
    obj.DriverData.constants.PS4000_PRBS_MIN_FREQUENCY		= 0.03;
    obj.DriverData.constants.PS4000_MIN_FREQUENCY			= 0.03;
    
    
    % Confirm data files have been loaded
    if (exist('PicoConstants.m', 'file') == 0)
    
        error('File PicoConstants.m not found - please ensure that the location of this file is added to the MATLAB Path.')
    
    end

    if (exist('PS4000Constants.m', 'file') == 0)
    
        error('File PS4000Constants.m not found - please ensure that the location of this file is added to the MATLAB Path.')
    
    end


    % Obtain flag to indicate if functions should output text to Command
    % Window
    % -------------------------------
    
    obj.DriverData.displayOutput = obj.displayOutput;
    
    % Default external trigger range for the PicoScope 4262
    obj.DriverData.extTriggerRange = obj.DriverData.enums.enPS4000Range.PS4000_5V;
    
    % Enumerate units 
    % ---------------
    
    % Only displayed if driver is being used via command line
    
    count = int16(0);
    serials = blanks(100);
    serialLth = length(serials);
    
    [status, count, serials, serialLth] = calllib('ps4000', ...
        'ps4000EnumerateUnits',  count, serials, serialLth);
    
    if (status == PicoStatus.PICO_OK)
        
        fprintf('Number of units found: %d\n\nSerial number(s): %s\n', count, serials);
        
    elseif (status == PicoStatus.PICO_NOT_FOUND)
        
        error('Create:NoUnitsFound', 'No units found.');
        
    else
        
        error('Create:StatusNotOK', 'Status code: %d\n', status);
        
    end
    </Code>
   </CreateInitCode>
   <ConnectInitCode>
      <Type>MCode</Type>
      <Code>function init(obj)
% This function is called after the object is connected.
% OBJ is the device object.
% End of function definition - DO NOT EDIT

% Copyright (C) 2014 - 2015 Pico Technology Ltd. All rights reserved.
% You may copy and distribute this file as long as it remains unmodified.

    disp('Opening PicoScope 4000 Series device...');

    % Structure to hold status values while connecting to the device.
    % Only output when the driver is called using command line or script.
    connectStatus = [];

    % Temporary variable to store handle value
    unitHandle = 0;
    
    % PICO_OK status value (0)
    picoOK = PicoStatus.PICO_OK;

    % Obtain the serial input
    serialNum = get(obj, 'RsrcName');

    % Determine if serial number is specified or null
    if ~isempty(serialNum)

        unitSerial = serialNum;

    else

        unitSerial = [];

    end

    % Open the unit
    [connectStatus.openUnit, unitHandle, obj.UserData.unitSerial] = ...
        calllib('ps4000', 'ps4000OpenUnitEx', unitHandle, unitSerial);

     obj.DriverData.unitHandle = unitHandle;
    
    % Initial channel settings to assist with change in power source
    % Setup initial channel settings (4 x 4)
    % 4 channels consisting of enabled, coupling, range, analogue offset
    % Default will be set later via resetDevice
    
    obj.DriverData.channelSettings = zeros(PicoConstants.QUAD_SCOPE, 4);

    % Set handle and serial 
    % Unit connected if 0 or power supply not connected
    if(connectStatus.openUnit == picoOK)

        % Display object information
        obj
        
        unitHandle = obj.DriverData.unitHandle;

        infoLine = blanks(15);
        reqSize = 15;

        [connectStatus.unit_serial, unitSerial, reqSize]  = calllib('ps4000', ...
                'ps4000GetUnitInfo', unitHandle, infoLine, ... 
                length(infoLine), reqSize, PicoStatus.PICO_BATCH_AND_SERIAL);

        obj.DriverData.unitSerial = unitSerial;

        % Set variant and channel count information
        %disp('Setting variant and channel count...')

        infoLineV = blanks(15);
        reqSizeV = 15;
        
        [connectStatus.unit_variant, variant, reqSizeV]  = calllib('ps4000', ...
                'ps4000GetUnitInfo', unitHandle, infoLineV, ... 
                length(infoLineV), reqSizeV, PicoStatus.PICO_VARIANT_INFO);

        set(obj, 'InstrumentModel', variant);

        % Set device parameters
        invoke(obj, 'resetDevice');
        
        % Display unit information to user if not using TMTool
        fprintf('\n');
        fprintf('Connected to PicoScope 4000 Series device:-\n\n');
        fprintf('      Instrument Model: %s\n', get(obj, 'InstrumentModel'));
        fprintf('   Batch/Serial Number: %s\n', unitSerial);
        fprintf('     Analogue Channels: %d\n', get(obj, 'channelCount'));
        
        % Bandwidth information
        bandwidthHz = get(obj, 'bandwidth');
        
        if(bandwidthHz &gt; 0 &amp;&amp; bandwidthHz &lt; 1e9)
            
           fprintf('             Bandwidth: %d MHz\n', (bandwidthHz/1e6));
           
        elseif(bandwith_hz &gt;= 1e9)
            
           fprintf('             Bandwidth: %d GHz\n', (bandwidthHz/1e9));
           
        else
            
            % Do nothing
            
        end
        
        fprintf('         Buffer memory: %d MS\n', get(obj, 'bufferMemory')/pow2(20));
        
        % Sampling rate information
        maxSamplingRate = get(obj, 'maxSamplingRate');
        
        if(maxSamplingRate &gt; 0 &amp;&amp; maxSamplingRate &lt; 1e9)
            
            fprintf(' Maximum sampling rate: %d MS/s\n', maxSamplingRate/1e6);
            
        elseif(maxSamplingRate &gt;= 1e9)
           
            fprintf(' Maximum sampling rate: %d GS/s\n', maxSamplingRate/1e9);
            
        else
            
            % Do nothing
            
        end
        
        clear bandwidthHZ;
        clear maxSamplingRate;

        % Output the signal generator type
        sigGenType = 'None';
    
        switch (obj.DriverData.sigGenType)

            case PicoConstants.SIG_GEN_FUNCT_GEN

                sigGenType = 'Function Generator';

            case PicoConstants.SIG_GEN_AWG

                sigGenType = 'Arbitrary Waveform Generator';

            otherwise

                % Already set to none

        end
    
        fprintf(' Signal Generator Type: %s\n', sigGenType);

        fprintf('\n');

    elseif(connectStatus.openUnit == PicoStatus.PICO_NOT_FOUND)

        error('No unit found, please check connections.');

    else

        error('Status code: %d\n', connectStatus.openUnit);

    end</Code>
   </ConnectInitCode>
   <CleanupCode>
      <Type>MCode</Type>
      <Code>function cleanup(obj)
% This function is called before the object is disconnected.
% OBJ is the device object.
% End of function definition - DO NOT EDIT

    if (isfield(obj.DriverData, 'unitHandle'))

        unitHandle = obj.DriverData.unitHandle;
    
        if (isempty(unitHandle)) 
            % If no unitHandle, return without doing anything
            return;
        end

        if (~libisloaded('ps4000') &amp;&amp; ~libisloaded('ps4000Wrap'))

            % If the drivers are no longer loaded, return without doing
            % anything
            return;

        end

        % Disconnect Code:

        disconnectStatus = calllib('ps4000', 'ps4000CloseUnit', obj.DriverData.unitHandle);

    	if (disconnectStatus == PicoStatus.PICO_OK)

            fprintf(['Connection to PicoScope %s with serial number %s ' ...
                'closed successfully.\n'], obj.InstrumentModel, obj.DriverData.unitSerial);

        elseif (disconnectStatus == PicoStatus.PICO_INVALID_HANDLE)
            
            % No device with the handle, so should be disconnected.
            return;
            
        else

            if (isfield(obj.DriverData, 'unitSerial'))
                
                error('Disconnect:ConnectionNotClosed',['Connection to PicoScope %s with serial number %s ' ...
                    'not closed. Status code %d\n'], ...
                    obj.InstrumentModel, obj.DriverData.unitSerial, disconnectStatus);
            end
        end

        % Only unload libraries if there are no more connected
        % oscilloscopes
        
        % Find the first handle number for the platform
        firstHandle = 0;
        
        if (ispc())
            
            firstHandle = 16384; % Windows PC
            
        else 
           
            firstHandle = 1; % Mac OS X and Linux
            
        end
        
        % Test the connection to a range of handle values up to a maximum
        lastHandle = firstHandle + obj.DriverData.constants.PS4000_MAX_UNITS - 1;
        
        % Create an array to store status values for ping tests.
        % On Windows PCs, the first handle is 16384 so this will need to be
        % accounted for.
        if (ispc())
            
            pingStatus = zeros(lastHandle, 1);
            
        else
            
            pingStatus = zeros(obj.DriverData.constants.PS4000_MAX_UNITS, 1);
            
        end
        
        % Test the handle value ranges
        for h = firstHandle:lastHandle

            pingStatus(h, 1) = calllib('ps4000', 'ps4000PingUnit', h);
            
        end
        
        if (ispc())
                
            % Need to resize arrray as first handle is not 0
            pingStatus(1:firstHandle - 1) = [];
                
        end
        
        if (any(pingStatus == PicoStatus.PICO_OK))
         
          % Device still connected
          disp('Other PicoScope 4000 Series devices are still connected - libraries will not be unloaded.');
          
        else
        
            unloadlibrary('ps4000Wrap');
            unloadlibrary('ps4000');

            if (~libisloaded('ps4000') &amp;&amp; ~libisloaded('ps4000Wrap'))

                disp('Libraries unloaded successfully.');

            else

                error('Libraries not unloaded.');

            end
            
        end
        
    else
        
        warning('Disconnect:NoDevicesFound', 'Disconnect: No devices found.');
        
    end</Code>
   </CleanupCode>
   <GroupInfo>
      <Group>
         <Name>parent</Name>
         <Description/>
         <Command/>
         <Size>1</Size>
         <Mappings>
            <ChannelMap Command="parent1" Index="1"/>
         </Mappings>
         <PropertyInfo>
            <Property>
               <Name>bandwidth</Name>
               <Location>parent</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <GetMCode>function propertyValue = getProperty(obj, propertyName)
% Return a property value.
%   This function is called to return the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    % If bandwidth doesn't exist, create it.
    if ( ~isfield(obj.DriverData, 'bandwidth') )
        obj.DriverData.bandwidth = 0;
    end
    
    propertyValue = obj.DriverData.bandwidth;
    </GetMCode>
                  <SetMCode>function set(obj, propertyName, propertyValue)
% Set a property value.
%   This function is called to set the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.
</SetMCode>
               </Code>
               <PermissibleType>
                  <Type>Double</Type>
                  <Constraint>none</Constraint>
               </PermissibleType>
               <DefaultValue>0</DefaultValue>
               <ReadOnly>never</ReadOnly>
               <Description/>
            </Property>
            <Property>
               <Name>bufferMemory</Name>
               <Location>parent</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <GetMCode>function propertyValue = getProperty(obj, propertyName)
% Return a property value.
%   This function is called to return the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    % If bufferMemory doesn't exist, create it.
    if ( ~isfield(obj.DriverData, 'bufferMemory') )
        obj.DriverData.bufferMemory = 0;
    else
        propertyValue = obj.DriverData.bufferMemory;
    end</GetMCode>
                  <SetMCode>function set(obj, propertyName, propertyValue)
% Set a property value.
%   This function is called to set the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.</SetMCode>
               </Code>
               <PermissibleType>
                  <Type>Double</Type>
                  <Constraint>none</Constraint>
               </PermissibleType>
               <DefaultValue>268435456</DefaultValue>
               <ReadOnly>always</ReadOnly>
               <Description>Defines the size of the memory buffer on the device (in samples).</Description>
            </Property>
            <Property>
               <Name>channelCount</Name>
               <Location>parent</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <GetMCode>function propertyValue = getProperty(obj, propertyName)
% Return a property value.
%   This function is called to return the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    % If channelCount doesn't exist, create it.
    if ( ~isfield(obj.DriverData, 'channelCount') )
        obj.DriverData.channelCount = [ ];
    end

    propertyValue = obj.DriverData.channelCount;</GetMCode>
                  <SetMCode>function set(obj, propertyName, propertyValue)
% Set a property value.
%   This function is called to set the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.</SetMCode>
               </Code>
               <PermissibleType>
                  <Type>Double</Type>
                  <Constraint>none</Constraint>
               </PermissibleType>
               <DefaultValue>8</DefaultValue>
               <ReadOnly>always</ReadOnly>
               <Description>The number of analogue input channels on the device.</Description>
            </Property>
            <Property>
               <Name>channelSettings</Name>
               <Location>parent</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <GetMCode>function propertyValue = getProperty(obj, propertyName)
% Return a property value.
%   This function is called to return the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    % If channelSettings doesn't exist, create it.
    if ( ~isfield(obj.DriverData, 'channelSettings') )
        
        obj.UserData.channelSettings = [ ];
        
    end
    
    propertyValue = obj.DriverData.channelSettings;
    </GetMCode>
                  <SetMCode>function set(obj, propertyName, propertyValue)
% Set a property value.
%   This function is called to set the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.</SetMCode>
               </Code>
               <PermissibleType>
                  <Type>Object</Type>
                  <Constraint>none</Constraint>
               </PermissibleType>
               <DefaultValue/>
               <ReadOnly>always</ReadOnly>
               <Description>A matrix containing the channel settings for analogue channels.

This will consist of a 8 x 4 matrix.

The row number will correspond to the channel:

1 - Channel A
2 - Channel B
3 - Channel C
4 - Channel D
5 - Channel A
6 - Channel B
7 - Channel C
8 - Channel D

Each row will contain the following elements corresponding to:

enabled - set to 0 (off) or 1 (on).
dc - set DC/AC coupling. 
range - an enumeration representing the voltage range.
analogueOffset - the offset on the channel.

</Description>
            </Property>
            <Property>
               <Name>displayOutput</Name>
               <Location>parent</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <GetMCode>function propertyValue = getProperty(obj, propertyName)
% Return a property value.
%   This function is called to return the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    propertyValue = obj.DriverData.displayOutput;</GetMCode>
                  <SetMCode>function set(obj, propertyName, propertyValue)
% Set a property value.
%   This function is called to set the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    obj.DriverData.displayOutput = propertyValue;</SetMCode>
               </Code>
               <PermissibleType>
                  <Type>Double</Type>
                  <Constraint>enum</Constraint>
                  <ConstraintValue>
                     <Value>0.0</Value>
                     <Value>1.0</Value>
                  </ConstraintValue>
               </PermissibleType>
               <DefaultValue>1</DefaultValue>
               <ReadOnly>never</ReadOnly>
               <Description>Enumeration value to select whether to display output from function calls in the MATLAB Command Window.

Set to 1 to display output, 0 to hide output.

Note: Output will still be sent to the Command Window when calling the icdevice, connect and disconnect functions. Warning and error messages will still continue to be displayed from function calls.</Description>
            </Property>
            <Property>
               <Name>firstRange</Name>
               <Location>parent</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <GetMCode>function propertyValue = getProperty(obj, propertyName)
% Return a property value.
%   This function is called to return the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    % If firstRange doesn't exist, create it.
    if ( ~isfield(obj.DriverData, 'firstRange') )
        obj.DriverData.firstRange = [ ];
    else
        propertyValue = obj.DriverData.firstRange;
    end</GetMCode>
                  <SetMCode>function set(obj, propertyName, propertyValue)
% Set a property value.
%   This function is called to set the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.</SetMCode>
               </Code>
               <PermissibleType>
                  <Type>Double</Type>
                  <Constraint>enum</Constraint>
                  <ConstraintValue>
                     <Value>0.0</Value>
                     <Value>1.0</Value>
                     <Value>2.0</Value>
                     <Value>3.0</Value>
                     <Value>4.0</Value>
                     <Value>5.0</Value>
                     <Value>6.0</Value>
                     <Value>7.0</Value>
                     <Value>8.0</Value>
                     <Value>9.0</Value>
                     <Value>10.0</Value>
                     <Value>11.0</Value>
                  </ConstraintValue>
               </PermissibleType>
               <DefaultValue>2</DefaultValue>
               <ReadOnly>always</ReadOnly>
               <Description>Enumeration corresponding to the lowest voltage range supported by the device.</Description>
            </Property>
            <Property>
               <Name>hasHardwareEts</Name>
               <Location>parent</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <GetMCode>function propertyValue = getProperty(obj, propertyName)
% Return a property value.
%   This function is called to return the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    % If hasHardwareEts doesn't exist, create it.
    if ( ~isfield(obj.DriverData, 'hasHardwareEts') )
        obj.DriverData.hasHardwareEts = [ ];
    end
    
    propertyValue = obj.DriverData.hasHardwareEts;</GetMCode>
                  <SetMCode>function set(obj, propertyName, propertyValue)
% Set a property value.
%   This function is called to set the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.</SetMCode>
               </Code>
               <PermissibleType>
                  <Type>Double</Type>
                  <Constraint>enum</Constraint>
                  <ConstraintValue>
                     <Value>0.0</Value>
                     <Value>1.0</Value>
                  </ConstraintValue>
               </PermissibleType>
               <DefaultValue>0.0</DefaultValue>
               <ReadOnly>always</ReadOnly>
               <Description>Indicates if the device has hardware-based Equivalent Time Sampling.</Description>
            </Property>
            <Property>
               <Name>lastRange</Name>
               <Location>parent</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <GetMCode>function propertyValue = getProperty(obj, propertyName)
% Return a property value.
%   This function is called to return the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    % If lastRange doesn't exist, create it.
    if ( ~isfield(obj.DriverData, 'lastRange') )
        obj.DriverData.lastRange = [ ];
    end
    
    propertyValue = obj.DriverData.lastRange;
    </GetMCode>
                  <SetMCode>function set(obj, propertyName, propertyValue)
% Set a property value.
%   This function is called to set the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.</SetMCode>
               </Code>
               <PermissibleType>
                  <Type>Double</Type>
                  <Constraint>enum</Constraint>
                  <ConstraintValue>
                     <Value>0.0</Value>
                     <Value>1.0</Value>
                     <Value>2.0</Value>
                     <Value>3.0</Value>
                     <Value>4.0</Value>
                     <Value>5.0</Value>
                     <Value>6.0</Value>
                     <Value>7.0</Value>
                     <Value>8.0</Value>
                     <Value>9.0</Value>
                     <Value>10.0</Value>
                     <Value>11.0</Value>
                  </ConstraintValue>
               </PermissibleType>
               <DefaultValue>10</DefaultValue>
               <ReadOnly>always</ReadOnly>
               <Description>Enumeration corresponding to highest voltage range supported by device.</Description>
            </Property>
            <Property>
               <Name>maxADCValue</Name>
               <Location>parent</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <GetMCode>function propertyValue = getProperty(obj, propertyName)
% Return a property value.
%   This function is called to return the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    % If maxADCValue doesn't exist, create it.
    if ( ~isfield(obj.DriverData, 'maxADCValue') )
        obj.DriverData.maxADCValue = 0;
    end
    
    propertyValue = obj.DriverData.maxADCValue;</GetMCode>
                  <SetMCode>function set(obj, propertyName, propertyValue)
% Set a property value.
%   This function is called to set the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.</SetMCode>
               </Code>
               <PermissibleType>
                  <Type>Double</Type>
                  <Constraint>none</Constraint>
               </PermissibleType>
               <DefaultValue>32767</DefaultValue>
               <ReadOnly>always</ReadOnly>
               <Description>The maximum ADC count value for the device.</Description>
            </Property>
            <Property>
               <Name>maxSamplingRate</Name>
               <Location>parent</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <GetMCode>function propertyValue = getProperty(obj, propertyName)
% Return a property value.
%   This function is called to return the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    % If maxSamplingRate doesn't exist, create it.
    if ( ~isfield(obj.DriverData, 'maxSamplingRate') )
        obj.DriverData.maxSamplingRate = [ ];
    end
    
    propertyValue = obj.DriverData.maxSamplingRate;</GetMCode>
                  <SetMCode>function set(obj, propertyName, propertyValue)
% Set a property value.
%   This function is called to set the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.</SetMCode>
               </Code>
               <PermissibleType>
                  <Type>Double</Type>
                  <Constraint>none</Constraint>
               </PermissibleType>
               <DefaultValue>0</DefaultValue>
               <ReadOnly>always</ReadOnly>
               <Description>The maximum single shot sampling rate for the device (samples per second).</Description>
            </Property>
            <Property>
               <Name>minADCValue</Name>
               <Location>parent</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <GetMCode>function propertyValue = getProperty(obj, propertyName)
% Return a property value.
%   This function is called to return the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    % If minADCValue doesn't exist, create it.
    if ( ~isfield(obj.DriverData, 'minADCValue') )
        obj.DriverData.minADCValue = 0;
    end
    
    propertyValue = obj.DriverData.minADCValue;</GetMCode>
                  <SetMCode>function set(obj, propertyName, propertyValue)
% Set a property value.
%   This function is called to set the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.</SetMCode>
               </Code>
               <PermissibleType>
                  <Type>Double</Type>
                  <Constraint>none</Constraint>
               </PermissibleType>
               <DefaultValue>-32767</DefaultValue>
               <ReadOnly>always</ReadOnly>
               <Description>The minimum ADC count value for the device.</Description>
            </Property>
            <Property>
               <Name>numPostTriggerSamples</Name>
               <Location>parent</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <GetMCode>function propertyValue = getProperty(obj, propertyName)
% Return a property value.
%   This function is called to return the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    % If numPostTriggerSamples doesn't exist, create it.
    if ( ~isfield(obj.DriverData, 'numPostTriggerSamples') )
        obj.DriverData.numPostTriggerSamples = [ ];
    end
    
    propertyValue = obj.DriverData.numPostTriggerSamples;</GetMCode>
                  <SetMCode>function set(obj, propertyName, propertyValue)
% Set a property value.
%   This function is called to set the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    obj.DriverData.numPostTriggerSamples = propertyValue;</SetMCode>
               </Code>
               <PermissibleType>
                  <Type>Double</Type>
                  <Constraint>none</Constraint>
               </PermissibleType>
               <DefaultValue>0</DefaultValue>
               <ReadOnly>never</ReadOnly>
               <Description>The number of samples to be taken after a trigger event.

If no trigger event has been set then this specifies the maximum number of samples to be taken. If a trigger
condition has been set, this specifies the number of samples to be taken after a trigger has fired, and the number of samples to be
collected is then: -

noOfPreTriggerSamples + noOfPostTriggerSamples

When used in Streaming mode, this is the maximum number of raw samples after a trigger event for each enabled channel.</Description>
            </Property>
            <Property>
               <Name>numPreTriggerSamples</Name>
               <Location>parent</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <GetMCode>function propertyValue = getProperty(obj, propertyName)
% Return a property value.
%   This function is called to return the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    % If numPreTriggerSamples doesn't exist, create it.
    if ( ~isfield(obj.DriverData, 'numPreTriggerSamples') )
        obj.DriverData.numPreTriggerSamples = [ ];
    end
    
    propertyValue = obj.DriverData.numPreTriggerSamples;</GetMCode>
                  <SetMCode>function set(obj, propertyName, propertyValue)
% Set a property value.
%   This function is called to set the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    obj.DriverData.numPreTriggerSamples = propertyValue;</SetMCode>
               </Code>
               <PermissibleType>
                  <Type>Double</Type>
                  <Constraint>none</Constraint>
               </PermissibleType>
               <DefaultValue>0</DefaultValue>
               <ReadOnly>never</ReadOnly>
               <Description>The number of samples to return before the trigger event.

If no trigger has been set then this argument is ignored and noOfPostTriggerSamples specifies the maximum number of samples to collect.

When used in Streaming mode, this is the maximum number of raw samples before the trigger event for each enabled channel.
</Description>
            </Property>
            <Property>
               <Name>timebase</Name>
               <Location>parent</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <GetMCode>function propertyValue = getProperty(obj, propertyName)
% Return a property value.
%   This function is called to return the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    % If timebase doesn't exist, create it.
    if ( ~isfield(obj.DriverData, 'timebase') )
        obj.DriverData.timebase = 1;
    else
        propertyValue = obj.DriverData.timebase;
    end</GetMCode>
                  <SetMCode>function set(obj, propertyName, propertyValue)
% Set a property value.
%   This function is called to set the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    obj.DriverData.timebase = propertyValue;</SetMCode>
               </Code>
               <PermissibleType>
                  <Type>Double</Type>
                  <Constraint>none</Constraint>
               </PermissibleType>
               <DefaultValue>79</DefaultValue>
               <ReadOnly>never</ReadOnly>
               <Description>The timebase used for the scope when capturing data in Block and Rapid Block mode - please refer to the Programmer's Guide for the formulae to calculate the timebase index based on the interval.</Description>
            </Property>
            <Property>
               <Name>unitHandle</Name>
               <Location>parent</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <GetMCode>function propertyValue = getProperty(obj, propertyName)
% Return a property value.
%   This function is called to return the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    % If DriverData.unitHandle doesn't exist, create it.
    if ( ~isfield(obj.DriverData, 'unitHandle') )
        obj.DriverData.unitHandle = 0;
    else
        propertyValue = obj.DriverData.unitHandle;
    end</GetMCode>
                  <SetMCode>function set(obj, propertyName, propertyValue)
% Set a property value.
%   This function is called to set the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.</SetMCode>
               </Code>
               <PermissibleType>
                  <Type>Double</Type>
                  <Constraint>none</Constraint>
               </PermissibleType>
               <DefaultValue>0</DefaultValue>
               <ReadOnly>always</ReadOnly>
               <Description>The handle assigned by the underlying driver for the device.</Description>
            </Property>
            <Property>
               <Name>unitSerial</Name>
               <Location>parent</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <GetMCode>function propertyValue = getProperty(obj, propertyName)
% Return a property value.
%   This function is called to return the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    % If DriverData.unitSerial doesn't exist, create it.
    if ( ~isfield(obj.DriverData, 'unitSerial') )
        obj.DriverData.unitSerial = [ ];
    else
        propertyValue = obj.DriverData.unitSerial;
    end</GetMCode>
                  <SetMCode>function set(obj, propertyName, propertyValue)
% Set a property value.
%   This function is called to set the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.</SetMCode>
               </Code>
               <PermissibleType>
                  <Type>String</Type>
                  <Constraint>none</Constraint>
               </PermissibleType>
               <DefaultValue/>
               <ReadOnly>always</ReadOnly>
               <Description>The device batch/serial number.</Description>
            </Property>
         </PropertyInfo>
         <MethodInfo>
            <Method>
               <Name>getUnitInfo</Name>
               <Location>parent</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function [status, unitInfoValues] = getUnitInfo(obj)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    unitHandle = obj.DriverData.unitHandle;
    
    unitInfoDesc = {'Driver version: '; 'USB version: '; 'Hardware version: '; 'Variant: '; ...
        'Batch &amp; Serial: '; 'Cal. Date: '; 'Kernel version: '; };

    infoLine = blanks(20);

    unitInfoValues = cell(7,1);

    reqSize = 15;

    status = zeros(11,1,'uint32');

    % Loop through and put together information
    for n = 1:7

        [status(n,1), infoLine1, reqSize]  = calllib('ps4000', ...
            'ps4000GetUnitInfo', unitHandle, infoLine, ... 
            length(infoLine), reqSize,(n-1));
        
        if(status(n,1) ~= PicoStatus.PICO_OK)
           
            % TBD - Error handling 
        
        end

        unitInfoLine = strcat(unitInfoDesc(n), infoLine1);
        unitInfoValues(n) = cellstr(unitInfoLine);
        
    end</MCode>
               </Code>
               <Description>GetUnitInfo(obj) retrieves information about the specified oscilloscope for the following types of information:

1.   Driver version
2.   USB version
3.   Hardware version
4.   Variant number
5.   Batch &amp; Serial number
6.   Calibration date
7.   Kernel Version

Input parameters:

obj - the object representing the device.

Output parameters:

status - an array containing the status codes returned by the driver on each call to the underlying ps4000GetUnitInfo function.
unitInfoValues - a set of text providing information on the device connected to.

For further information on the underlying ps4000GetUnitInfo function please refer to the PicoScope 4000 Series PC Oscilloscopes Programmer's Guide.</Description>
            </Method>
            <Method>
               <Name>ps4000FlashLed</Name>
               <Location>parent</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function status = ps4000FlashLed(obj, start)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    status = calllib('ps4000', 'ps4000FlashLed', ...
        obj.DriverData.unitHandle, start);
            
	if(status ~= PicoStatus.PICO_OK)
           
        error('ps4000FlashLed: Error code %d\n', status);
        
    end</MCode>
               </Code>
               <Description>ps4000FlashLed(obj, start) flashes the LED on the front of the scope without blocking the calling thread.

This function may be used with the Test and Measurement Tool.

Input parameters:

obj - the object representing the device.
start - the action required:

	&lt; 0 : flash the LED indefinitely.
	0 : stop the LED flashing.
	&gt; 0 : flash the LED start times.

Output parameters:

status - status code returned by the device.

For further information on the ps4000FlashLed function please refer to the PicoScope 4000 Series PC Oscilloscopes Programmer's Guide.</Description>
            </Method>
            <Method>
               <Name>ps4000GetMaxDownSampleRatio</Name>
               <Location>parent</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function [status, maxDownSampleRatio] = ps4000GetMaxDownSampleRatio(obj, numUnaggregatedSamples, downSampleRatioMode, segmentIndex)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    % Value to which the max downsample ration is assigned
    maxDownSampleRatio = 0;        

    [status, maxDownSampleRatio] = calllib('ps4000', ...
        'ps4000GetMaxDownSampleRatio', get(obj, 'unitHandle'), numUnaggregatedSamples, ...
            maxDownSampleRatio, downSampleRatioMode, segmentIndex);
        
    if(status ~= PicoStatus.PICO_OK)
           
       error('ps4000GetMaxDownSampleRatio: error code %d\n', status);
        
    end   </MCode>
               </Code>
               <Description>ps4000GetMaxDownSampleRatio(obj, numUnaggregatedSamples, downSampleRatioMode, segmentIndex) returns the maximum downsampling ratio that can be used for a given number of samples in a given downsampling mode.

This function may be used with the Test and Measurement Tool.

Input parameters:

obj - the object representing the device.
numUnaggregatedSamples - the number of unprocessed samples to be downsampled.
downSampleRatioMode - the downsampling mode.
segmentIndex - the memory segment where the data is stored.

Output parameters:

status - status code returned by the driver.
maxDownSampleRatio - the maximum possible downsampling ratio.

For further information on the ps4000GetMaxDownSampleRatio function please refer to the PicoScope 4000 Series PC Oscilloscopes Programmer's Guide.</Description>
            </Method>
            <Method>
               <Name>ps4000GetTimebase2</Name>
               <Location>parent</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function [status, timeIntervalNanoseconds, maxSamples] = ps4000GetTimebase2(obj, timebase, segmentIndex)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    timeIntervalNanoseconds = 0;
    
    numSamples = obj.DriverData.numPreTriggerSamples + ...
        obj.DriverData.numPostTriggerSamples;
    
    maxSamples = 0; % Pass data to return the max samples from the driver
    
    [status, timeIntervalNanoseconds, maxSamples] = calllib('ps4000', ...
        'ps4000GetTimebase2', obj.DriverData.unitHandle, timebase, numSamples, ...
        timeIntervalNanoseconds,0, maxSamples, segmentIndex);
    
    if (status ~= PicoStatus.PICO_OK)
        
        % Inform the User that an invalid timebase index has been selected
        if (status == PicoStatus.PICO_INVALID_TIMEBASE)
           
            warning('PS4000InstrumentDriver:InvalidTimebase', ['Invalid timebase ', ...
                'index used in call to ps4000GetTimebase2().']);
            
        else
            
            error('PS4000InstrumentDriver:GetTimebase2', ['ps4000GetTimebase2:- Status code: ', ...
                '%d. Please refer to the PicoStatus.m file.'], status);
        
        end
        
    end
    
    clear numSamples;</MCode>
               </Code>
               <Description>ps4000GetTimebase2(obj, timebase, segmentIndex) discovers which timebases are available on the oscilloscope, returning the time interval as floating point values.

The channels should be setup using the ps4000SetChannel function first.

This function may be used with the Test and Measurement Tool.

Input parameters:

obj - the object representing the device.
timebase: a timebase index.
segmentIndex: the index of the memory segment to use.

Output parameters:

status - status code returned by the driver.
timeIntervalNanoseconds: the time interval between readings at the selected timebase.
maxSamples: the maximum number of samples available. 

For further information on the ps4000GetTimebase2 function please refer to the PicoScope 4000 Series PC Oscilloscopes Programmer's Guide.</Description>
            </Method>
            <Method>
               <Name>ps4000MemorySegments</Name>
               <Location>parent</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function [status, nMaxSamples] = ps4000MemorySegments(obj, nSegments)
% If this is a group function, OBJ is the group object. If
% it a base device function, OBJ is the device object.

    nMaxSamples = 0; % Initialise value for pointer

    [status, nMaxSamples] = calllib('ps4000', 'ps4000MemorySegments', ...
        obj.DriverData.unitHandle, nSegments, nMaxSamples);
    
    if(status ~= PicoStatus.PICO_OK)
           
        error('ps4000MemorySegments: error code %d\n', status);  
        
    end</MCode>
               </Code>
               <Description>ps4000MemorySegments(obj, nSegments) sets the number of memory segments that the scope will use.

This function may be used with the Test and Measurement Tool.

Input parameters:

obj - the object representing the device.
nSegments - the number of segments required from 1 to 8192

Output parameters:

status - status code returned by the driver.
nMaxSamples - the number of samples available in each segment.

For further information on the ps4000MemorySegments function please refer to the PicoScope 4000 Series PC Oscilloscopes Programmer's Guide.</Description>
            </Method>
            <Method>
               <Name>ps4000SetBwFilter</Name>
               <Location>parent</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function status = ps4000SetBwFilter(obj, channel, enabled)
% If this is a group function, OBJ is the group object. If
% it a base device function, OBJ is the device object.
 
    if (obj.InstrumentModel == '4262')
        
        status = calllib('ps4000', 'ps4000SetBwFilter', ...
        obj.DriverData.unitHandle, channel, enabled);
    
        if(status ~= PicoStatus.PICO_OK)
            
            error('ps4000SetBwFilter: error code %d\n', status);
            
        end    
        
    else
        
        error('this function is not support on this device');
        
    end</MCode>
               </Code>
               <Description>function status = ps4000SetBwFilter(obj, channel, enabled) specifies whether an input channel has the bandwidth filter enabled (can only be used with 4262)

This function may be used with the Test and Measurement Tool.

Input parameters:

obj - the object representing the device.
channel - the channel to be configured (an enumeration from the PS4000A_CHANNEL range - PS4000_CHANNEL_A to 	PS4000_CHANNEL_B).
enabled - set to TRUE (1) to enable the channel filter, FALSE (0) otherwise.

Output parameters:

status - status code returned by the driver.

For further information on the ps4000SetBwFilter function please refer to the PicoScope 4000 Series PC Oscilloscopes Programmer's Guide.</Description>
            </Method>
            <Method>
               <Name>ps4000SetChannel</Name>
               <Location>parent</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function status = ps4000SetChannel(obj, channel, enabled, type, range)
% If this is a group function, OBJ is the group object. If
% it a base device function, OBJ is the device object.
 
    status = calllib('ps4000', 'ps4000SetChannel', ...
        obj.DriverData.unitHandle, channel, enabled, type, ...
        range);
    
    % Obtain channel settings information 
    chSettings = obj.DriverData.channelSettings;

	if(status == PicoStatus.PICO_OK)
        
        switch(channel)
            
            case evalin('base', 'ps4000Enuminfo.enPS4000Channel.PS4000_CHANNEL_A')
                
                chSettings(1,1) = enabled;
                chSettings(1,2) = type;
                chSettings(1,3) = range;
                
            case evalin('base', 'ps4000Enuminfo.enPS4000Channel.PS4000_CHANNEL_B')
                
                chSettings(2,1) = enabled;
                chSettings(2,2) = type;
                chSettings(2,3) = range;

            case evalin('base', 'ps4000Enuminfo.enPS4000Channel.PS4000_CHANNEL_C')
                
                chSettings(3,1) = enabled;
                chSettings(3,2) = type;
                chSettings(3,3) = range;
                
            case evalin('base', 'ps4000Enuminfo.enPS4000Channel.PS4000_CHANNEL_D')
                
                chSettings(4,1) = enabled;
                chSettings(4,2) = type;
                chSettings(4,3) = range;
                
               
            otherwise
                
                % Do nothing
                    
        end
        
        %obj.UserData.channelSettings
        obj.DriverData.channelSettings = chSettings;
        
        % Information to be passed to the wrapper dll
        enabledChannels = zeros(obj.DriverData.channelCount, 1, 'int16');
        
        %disp('Setting channels')
        
        switch(obj.DriverData.channelCount)
            
            case PicoConstants.DUAL_SCOPE
           
                % Only channels A and B
                enabledChannels = [chSettings(1,1); ...
                    chSettings(2,1); 0; 0; 0; 0; 0; 0];
            
            case PicoConstants.QUAD_SCOPE
                
                enabledChannels = [chSettings(1,1); ...
                    chSettings(2,1); ...
                    chSettings(3,1); ...
                    chSettings(4,1); ...
                    0; 0; 0; 0];           

            
            otherwise
        
                % Do nothing
            
        end
        
        setEnabledChannelsStatus = calllib('ps4000Wrap', ...
                    'setEnabledChannels', obj.DriverData.unitHandle, ...
                    enabledChannels);
        
    else
        
        if(status == PicoStatus.PICO_INVALID_CHANNEL)
           
            error('ps4000SetChannel: Invalid channel selected.');
            
        else
            
            error('ps4000SetChannel: error code %d\n', status);
            
        end
        
    end</MCode>
               </Code>
               <Description>function status = ps4000SetChannel(obj, channel, enabled, type, range, analogueOffset, bandwidth) specifies whether an input channel is to be enabled, its input coupling type, voltage range, analog offset and bandwidth limit.

This function may be used with the Test and Measurement Tool.

Input parameters:

obj - the object representing the device.
channel - the channel to be configured (an enumeration from the PS4000A_CHANNEL range - PS4000_CHANNEL_A to 	PS4000_CHANNEL_D).
enabled - set to TRUE (1) to enable the channel, FALSE (0) otherwise.
type - the impedance and coupling type (0 = DC, 1 = AC).
range - the input voltage range (an enumeration from the PS4000_RANGE range).


Output parameters:

status - status code returned by the driver.

For further information on the ps4000SetChannel function please refer to the PicoScope 4000 Series PC Oscilloscopes Programmer's Guide.</Description>
            </Method>
            <Method>
               <Name>ps4000SetDataBuffersWithMode</Name>
               <Location>parent</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function status = ps4000SetDataBuffersWithMode(obj, channel, pBufferMax, pBufferMin, bufferLth, ratioMode)
% If this is a group function, OBJ is the group object. If
% it a base device function, OBJ is the device object.

    status = calllib('ps4000', 'ps4000SetDataBuffersWithMode', ...
        obj.DriverData.unitHandle, channel, pBufferMax, pBufferMin, ...
        bufferLth, ratioMode);
    
    if(status ~= PicoStatus.PICO_OK)
           
        error('ps4000SetDataBuffers: error code %d', status); 
        
    end</MCode>
               </Code>
               <Description>ps4000SetDataBuffersWithMode(obj, channel, pBufferMax, pBufferMin, bufferLth, ratioMode) tells the driver the location of one or two buffers for receiving data.

If aggregate mode is not being used, then ps4000SetDataBufferWithMode can optionally be used instead.

Input parameters:

obj - the object representing the device.
channel -  the channel for which to set the buffers (an enumeration from the P64000_CHANNEL range).
pBufferMax - a libpointer to a 1-D array to receive the maximum data values in aggregation mode, or the non-aggregated values otherwise.
pBufferMin -  a libpointer to a 1-D array to receive the minimum aggregated data values. Not used in other downsampling modes.
bufferLth - the size of the arrays to which pBufferMax and pBufferMin are pointers.
mode - the downsampling mode to use (an enumeration from the PS4000_RATIO_MODE range).

Output parameters:

status - status code returned by the device.

If capturing data in streaming mode with aggregation, pBufferMax and pBufferMin must also be passed as the driverMaxBuffer and driverMinBuffer arguments respectively for the setMaxMinAppAndDriverBuffers function call.

For further information on the ps4000SetDataBuffers function please refer to the PicoScope 4000 Series PC Oscilloscopes Programmer's Guide.</Description>
            </Method>
            <Method>
               <Name>ps4000SetDataBufferWithMode</Name>
               <Location>parent</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function status = ps4000SetDataBufferWithMode(obj, channel, pBuffer, bufferLth, mode)
% If this is a group function, OBJ is the group object. If
% it a base device function, OBJ is the device object.

    status = calllib('ps4000', 'ps4000SetDataBufferWithMode', ...
        obj.DriverData.unitHandle, channel, pBuffer, bufferLth, mode);
            
    if(status ~= PicoStatus.PICO_OK)
           
        error('ps4000SetDataBuffer: error code %d', status);
        
    end</MCode>
               </Code>
               <Description>ps4000SetDataBufferWithMode(obj, channel, buffer, bufferLth, mode) tells the driver where to store the data, either unprocessed or downsampled, that will be returned after the next call to one of the GetValues functions.

Input parameters:

obj - the object representing the device.
channel - the channel to which the buffer corresponds (an enumeration from the PS4000_CHANNEL range).
pBuffer - a libpointer to a 1-D array to receive the data values for the channel.
bufferLth - the length of the buffer array.
mode - the downsampling mode (an enumeration from the PS4000_RATIO_MODE range).

Output parameters:

status - status code returned by the device.

If capturing data in streaming mode without aggregation, buffer must also be passed as the driverBuffer argument for the setAppAndDriverBuffers function call.

For further information on the ps4000SetDataBuffer function please refer to the PicoScope 4000 Series  PC Oscilloscopes Programmer's Guide.

</Description>
            </Method>
            <Method>
               <Name>ps4000SetExtTriggerRange</Name>
               <Location>parent</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function status = ps4000SetExtTriggerRange(obj, extRange)
% If this is a group function, OBJ is the group object. If
% it a base device function, OBJ is the device object.
 
    if (obj.InstrumentModel == '4262')
        
        if (extRange ~= obj.DriverData.enums.enPS4000Range.PS4000_500MV || ...
                extRange ~= obj.DriverData.enums.enPS4000Range.PS4000_5V)

            warning('PS4000InstrumentDriver:InvalidExtTriggerRange', ...
                'Invalid external trigger range, setting to ±5 V');

            extRange = obj.DriverData.enums.enPS4000Range.PS4000_5V;

        end

        status = calllib('ps4000', 'ps4000SetExtTriggerRange', ...
                    obj.DriverData.unitHandle, extRange);

        % Update device object's extTriggerRange property
        if (status == PicoStatus.PICO_OK)

            obj.DriverData.extTriggerRange = extRange;

        else

            error('ps4000SetExtTriggerRange:- status code: %d. Please refer to the PicoStatus.m file.', status);

        end 
        
    end</MCode>
               </Code>
               <Description>ps4000SetExtTriggerRange(obj, extRange) sets the range of the external trigger for the PicoScope 4262.

This function may be used with the Test and Measurement Tool.

Input parameters:

obj - the object representing the Signalgenerator group.
extRange - set to either the ±500 mV (enPS4000Range.PS4000_500MV) or ±5 V (enPS4000Range.PS4000_5V) range.

Output parameters:

status - status code returned by the driver.</Description>
            </Method>
            <Method>
               <Name>ps4000Stop</Name>
               <Location>parent</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function status = ps4000Stop(obj)
% If this is a group function, OBJ is the group object. If
% it a base device function, OBJ is the device object.

    status = calllib('ps4000', 'ps4000Stop', obj.DriverData.unitHandle);
    
    if(status ~= PicoStatus.PICO_OK)
           
        error('ps4000Stop: error code %d\n', status)
        
    end</MCode>
               </Code>
               <Description>ps4000Stop(obj) stops the scope device from sampling data.

This function may be used with the Test and Measurement Tool.

Input parameters:

obj - the object representing the device.

Output parameters:

status - status code returned by the driver.

For further information on the ps4000Stop function please refer to the PicoScope 4000 Series PC Oscilloscopes Programmer's Guide.</Description>
            </Method>
            <Method>
               <Name>resetDevice</Name>
               <Location>parent</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function resetDevice(obj)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    fprintf('Setting Device Parameters...\n\n');
    
    obj.DriverData.bufferMemory = PicoConstants.BUFFER_MEMORY_32MS;
    obj.DriverData.firstRange = evalin('base', 'ps4000Enuminfo.enPS4000Range.PS4000_10MV');
    obj.DriverData.lastRange = evalin('base', 'ps4000Enuminfo.enPS4000Range.PS4000_100V');
    obj.DriverData.hasHardwareEts = PicoConstants.TRUE;
    obj.DriverData.maxPktoPk = PS4000Constants.PS4000_SIGGEN_MAXPKTOPK;
    obj.DriverData.dwellTime = PS4000Constants.MIN_DWELL_COUNT;
    timebase = 21;
    
    
    % Set the max. ADC value

    obj.DriverData.maxADCValue = PS4000Constants.PS4000_MAX_VALUE;    

    % Set the min. ADC value 

    obj.DriverData.minADCValue  = PS4000Constants.PS4000_MIN_VALUE;
           
    awgMaxBufferSize = 0;

     [status, ~, ~, ~, awgMaxBufferSize] = calllib('ps4000','ps4000SigGenArbitraryMinMaxValues', obj.DriverData.unitHandle, ...
     0, 0, 0, awgMaxBufferSize);
 
     if(status == PicoStatus.PICO_OK)       
         
         obj.DriverData.sigGenType = PicoConstants.SIG_GEN_AWG;
                
     else
       
         obj.DriverData.sigGenType = PicoConstants.SIG_GEN_NONE;
         obj.DriverData.dacFrequency = PicoConstants.AWG_DAC_FREQUENCY_ZERO
         
     end
     
     obj.DriverData.awgBufferSize = awgMaxBufferSize;

     if (obj.InstrumentModel(2)== '2')
         obj.DriverData.channelCount = PicoConstants.DUAL_SCOPE;
     else
         obj.DriverData.channelCount = PicoConstants.QUAD_SCOPE;
     end
         
     switch(obj.InstrumentModel(4))  
    
         case'2';
            
            obj.DriverData.bufferMemory = PicoConstants.BUFFER_MEMORY_16MS;
            obj.DriverData.bandwidth = PicoConstants.BANDWIDTH_5MHZ;
            obj.DriverData.maxSamplingRate = PicoConstants.MAX_SAMPLING_RATE_10MSPS;
            obj.DriverData.hasHardwareEts = PicoConstants.FALSE;
            obj.DriverData.maxADCValue = PS4000Constants.PS4262_MAX_VALUE;
            obj.DriverData.minADCValue  = PS4000Constants.PS4262_MIN_VALUE;
            obj.DriverData.maxPktoPk = PS4000Constants.PS4262_SIGGEN_MAXPKTOPK;
            obj.DriverData.dwellTime = PS4000Constants.MIN_DWELL_COUNT_4262;
            timebase = 11;
        
         case '6'
        
            obj.DriverData.bandwidth = PicoConstants.BANDWIDTH_50MHZ; 
            obj.DriverData.maxSamplingRate = PicoConstants.MAX_SAMPLING_RATE_125MSPS;
         
         case '7'
        
            obj.DriverData.bandwidth = PicoConstants.BANDWIDTH_100MHZ;
            obj.DriverData.maxSamplingRate = PicoConstants.MAX_SAMPLING_RATE_250MSPS;
        
         otherwise
        
            obj.DriverData.bandwidth = PicoConstants.BANDWIDTH_20MHZ;
            obj.DriverData.maxSamplingRate = PicoConstants.MAX_SAMPLING_RATE_80MSPS;
            timebase = 34;
            
     end

    %Inform the wrapper dll of the number of channels on the device
    status = calllib('ps4000Wrap', 'setChannelCount', obj.DriverData.unitHandle, ...
       obj.DriverData.channelCount);
    

    % Reset Channels
    [ch] = invoke(obj, 'setChannelDefaults');

    % Turn off ETS
    
    %disp('Turning off Equivalent Time Sampling...');
    
    %[ets_status, st_ps] = invoke(obj, 'ps4000SetEts', evalin('base', ...
     %                       'ps4000Enuminfo.enPS4000EtsMode.PS4000_ETS_OFF'), 0, 0);

    % Turn off trigger

    fprintf('Turning off trigger...\n\n');
    
    obj.DriverData.autoTriggerMs = 0;
    obj.DriverData.delay = 0;
    
    % Only applies to the PicoScope 4226/7 &amp; 4262
    obj.DriverData.extRange = evalin('base', 'ps4000Enuminfo.enPS4000Range.PS4000_5V') 
    
    % Obtain Trigger group object
    
    triggerGroupObj = get(obj, 'Trigger');
    triggerGroupObj = triggerGroupObj(1);
    triggerStatus = invoke(triggerGroupObj, 'setTriggerOff');

    fprintf('Default Block mode parameters:-\n\n');
    
    % Set the default number of pre-trigger and post-trigger samples
    obj.DriverData.numPreTriggerSamples = 0;
    
    obj.DriverData.numPostTriggerSamples = 1000000;
    
    totalSamples = obj.DriverData.numPreTriggerSamples + obj.DriverData.numPostTriggerSamples;
    
    % Set the timebase - 1us sampling interval (1MS/s) 
    obj.DriverData.timebase = timebase;
    
    timeIntervalNs = 0;
    segmentIndex = 0;
    
    % Call get timebase to return interval in ns 
    
    [timebaseStatus, timeIntervalNs, maxBlockSamples] = ...
        invoke(obj, 'ps4000GetTimebase2', obj.DriverData.timebase, segmentIndex);

    fprintf('               Timebase index : %d\n', obj.DriverData.timebase);
    fprintf('                 Time Interval: %.1f ns\n', timeIntervalNs);
    fprintf(' Number of pre-trigger samples: %d\n', obj.DriverData.numPreTriggerSamples);
    fprintf('Number of post-trigger samples: %d\n', obj.DriverData.numPostTriggerSamples);
    fprintf('       Total number of samples: %d\n', totalSamples);
    
    fprintf('\n');
    
    fprintf('Default Streaming mode parameters:-\n\n');
   
    obj.DriverData.streamingInterval = 1e-6; % 1us -&gt; 1MS/s
    obj.DriverData.autoStop = PicoConstants.TRUE;
    
    fprintf(' Streaming interval: %1.2d s\n', obj.DriverData.streamingInterval);
    fprintf('Streaming auto stop: %d\n', obj.DriverData.autoStop);
    
    fprintf('\n');
    
    if(obj.DriverData.sigGenType == PicoConstants.SIG_GEN_FUNCT_GEN || ...
            obj.DriverData.sigGenType == PicoConstants.SIG_GEN_AWG)
       
        fprintf('Default Signal generator parameters:-\n\n');
        
        obj.DriverData.startFrequency = 1000;
        
        obj.DriverData.stopFrequency = 1000;
        
        obj.DriverData.offsetVoltage = 0;
        obj.DriverData.peakToPeakVoltage = 2000;
        
        fprintf('      Start frequency: %d Hz\n', obj.DriverData.startFrequency);
        fprintf('       Stop frequency: %d Hz\n', obj.DriverData.stopFrequency);
        fprintf('       Offset voltage: %d mV\n', obj.DriverData.offsetVoltage);
        fprintf(' Peak to Peak voltage: %d mV\n', obj.DriverData.peakToPeakVoltage);
        
    end
    
    fprintf('\n');
    disp('Initialisation complete.');</MCode>
               </Code>
               <Description>resetDevice(obj) sets the default parameters for the device.

This includes the folliowing:

1. Device specific properties.
2. Enabling all available channels to 5V range, DC coupled, full bandwidth with 0 analogue offset.
3. Turning off the trigger.
4. Block mode parameters:

	Timebase index - device dependent, corresponding to a sampling interval of 1us.
	numPreTriggerSamples - 0
 	numPostTriggerSamples - 1000000

5. Streaming mode parameters:

	streamingInterval - 1e-6 (seconds)
	autoStop - 1
    
6. Signal Generator parameters:
        
	offsetVoltage - 0mV
	peakToPeakVoltage - 2000mV
	startFrequency - 1000 (Hz)
	stopFrequency - 1000 (Hz)


</Description>
            </Method>
            <Method>
               <Name>setChannelDefaults</Name>
               <Location>parent</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function [setCh] = setChannelDefaults(obj)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    fprintf('Default Channel Setup:-\n');
    fprintf('-----------------------\n\n');
    
   
    noChannel = obj.DriverData.channelCount;
    
    % Create a num channels x fields array
    chSettings = zeros(noChannel, 3);
    ch = zeros(noChannel, 1);
    setCh = zeros(noChannel,1);
    
    % Matrix of values to represent channels (rows) x properties (cols)
    obj.DriverData.channelSettings = zeros(noChannel, 5);
    
    ch(1) = evalin('base', 'ps4000Enuminfo.enPS4000Channel.PS4000_CHANNEL_A');
    ch(2) = evalin('base', 'ps4000Enuminfo.enPS4000Channel.PS4000_CHANNEL_B');
    
    if(noChannel == 4)
        
        ch(3) = evalin('base', 'ps4000Enuminfo.enPS4000Channel.PS4000_CHANNEL_C');
        ch(4) = evalin('base', 'ps4000Enuminfo.enPS4000Channel.PS4000_CHANNEL_D');
    
    end
      
    % Assign values used repeatedly to local variable

    true = PicoConstants.TRUE;   

    type = 1; % DC
    range = evalin('base', 'ps4000Enuminfo.enPS4000Range.PS4000_5V');        
   
    
    % Set Channels A through D, updating internal settings
    % Parameters are channel index, enabled, dc coupling, range index and 
    % analogue offset
        for i = 1:noChannel
        
        channelSettings(i).enabled = true;
        channelSettings(i).dc = type;
        channelSettings(i).range = range;
        
        chSettings(i, :) = cell2mat(struct2cell(channelSettings(i)))'; 
        
        setCh(i) = invoke(obj, 'ps4000SetChannel', ch(i), true, type, range);
        fprintf(strcat('Channel',char('A'+ i - 1),':-\n\tEnabled: True\n\tCoupling: DC\n\tRange: 5V\n\n'));

    end
        
    obj.DriverData.channelSettings = chSettings;    
        
    % Clear local variables
    
    clear i;
    clear ch;     
    clear channelSettings;
    clear chSettings;
    clear type;
    clear true;
    clear range5V;
        </MCode>
               </Code>
               <Description>setChannelDefaults(obj) sets the following default values for any Analogue channels found on the device:

Analogue Channel:

Enabled               : True
Coupling              :  0 (DC)
Voltage Range    : 5V 
</Description>
            </Method>
         </MethodInfo>
      </Group>
      <Group>
         <Name>block</Name>
         <Description>The Block group contains a set of properties and functions related to the block data collection functionality of the device.</Description>
         <Command/>
         <Size>1</Size>
         <Mappings>
            <ChannelMap Command="block" Index="1"/>
         </Mappings>
         <PropertyInfo/>
         <MethodInfo>
            <Method>
               <Name>getBlockData</Name>
               <Location>block</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function [numSamples, overflow, channelA, channelB, channelC, channelD] = getBlockData(obj, startIndex, segmentIndex, ratio, ratioMode)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    % Check ratio mode is not aggregated
    if (ratioMode ~= evalin('base', 'ps4000Enuminfo.enRatioMode.RATIO_MODE_AGGREGATE'))
        
        deviceObj = get(obj, 'Parent');
        unitHandle = deviceObj.DriverData.unitHandle;
        
        channelCount = deviceObj.DriverData.channelCount;
        
        % Retrieve channel settings - channel x data field matrix
        channelSettings = deviceObj.DriverData.channelSettings; 
        
        % Create empty arrays for channel data.
        channelA = [];
        channelB = [];
        channelC = [];
        channelD = [];

        % Overflow indicator
        overflow = 0;

        % Initialise variable for array of libpointers
        pBuffer = libpointer;
        
        % Initialise status
        setBufferStatus = 0;

        % total number of samples to set for data buffers
        totalSamples = deviceObj.DriverData.numPreTriggerSamples + deviceObj.DriverData.numPostTriggerSamples;
        
        if (deviceObj.DriverData.displayOutput == PicoConstants.TRUE)
            
            fprintf('getBlockData: Setting up data buffers...\n');
            
        end
        
        for ch = 1:channelCount

            % Set Data Buffer if channel is enabled - index 1 indicates if
            % channel is enabled
            if (channelSettings(ch,1) == PicoConstants.TRUE)
                
                % Store array of libpointers
                pBuffer(ch) = libpointer('int16Ptr', zeros(totalSamples, 1, 'int16'));

                setBufferStatus = calllib('ps4000', 'ps4000SetDataBufferWithMode', ...
                    unitHandle, (ch - 1), pBuffer(ch), totalSamples, ratioMode);
                
                if (setBufferStatus ~= PicoStatus.PICO_OK)
                    
                    error('getBlockData: Set Data Buffer for Channel %d error code %d', ...
                        (ch - 1), setBufferStatus);
                    
                end

            end

        end

        if (deviceObj.DriverData.displayOutput == PicoConstants.TRUE)
            
            fprintf('getBlockData: Retrieving data...\n');
            
        end
        
        % Call ps4000GetValues
        [getValuesStatus, numSamples, overflow] = ...
            calllib('ps4000', 'ps4000GetValues', unitHandle, startIndex, ...
                totalSamples, ratio, ratioMode, segmentIndex, overflow);
        
        if(getValuesStatus == PicoStatus.PICO_OK)
            
            if (deviceObj.DriverData.displayOutput == PicoConstants.TRUE)
                
                fprintf('getBlockData: Assigning data to array and converting to millivolts.\n');
                
            end
            
            % Obtain max ADC count value
            maxADCValue = double(deviceObj.DriverData.maxADCValue);
            
            % Retrieve data values for enabled channels
            for ch = 1:channelCount

                if(channelSettings(ch,1) == PicoConstants.TRUE)
                    
                    % Obtain the index for the
                    % PicoConstants.SCOPE_INPUT_RANGES array corresponding
                    % to the voltage range selected for the channel.
                    scopeInputIndex = channelSettings(ch,3) + 1;
                    
                    % Obtain the voltage range for the channel.
                    voltageRange = PicoConstants.SCOPE_INPUT_RANGES(scopeInputIndex);
                    
                    bufferValues = adc2mv(pBuffer(ch).Value, voltageRange, ...
                        maxADCValue);

                    switch(ch - 1)

                        case evalin('base', 'ps4000Enuminfo.enPS4000Channel.PS4000_CHANNEL_A')

                            channelA = bufferValues;

                        case evalin('base', 'ps4000Enuminfo.enPS4000Channel.PS4000_CHANNEL_B')

                            channelB = bufferValues;

                        case evalin('base', 'ps4000Enuminfo.enPS4000Channel.PS4000_CHANNEL_C')

                            channelC = bufferValues;

                        case evalin('base', 'ps4000Enuminfo.enPS4000Channel.PS4000_CHANNEL_D')

                            channelD = bufferValues;                      

                        otherwise

                            % Do nothing

                    end
                    
                end
                
            end
            
            if (deviceObj.DriverData.displayOutput == PicoConstants.TRUE)
                
                fprintf('getBlockData: Data succesfully retrieved.\n');
                
            end
            
        else
            
            error('getBlockData: Error retrieving data values - code: %d', getValuesStatus);
            
        end
        
        
    else
        
        error('getBlockData: Aggregate Mode data collection not supported by this function.');
        
    end
</MCode>
               </Code>
               <Description>getBlockData(obj, startIndex, segmentIndex, ratio, ratioMode) returns block mode data with or without downsampling starting at the specified sample number.

Memory for the data arrays is allocated and the driver is informed where to store the data prior to retrieval. Data collection in Aggregation mode or with more than one downsampling mode is NOT supported by this function.

This function can be used with the Test and Measurement Tool.

Input parameters:

obj - the object representing the Block group.
startIndex - a zero-based index that indicates the start point for data collection. Use zero to start at the first sample.
segmentIndex - the number of the memory segment to be used/where the data is stored. Use 0 if the memory has not been segmented.
ratio - the downsampling factor that will be applied to the raw data.
ratioMode - which downsampling mode to use (specified by an enumeration from the PS4000_RATIO_MODE range of enumerations excluding PS4000_RATIO_MODE_AGGREGATE).


Output parameters:

status - status code returned by the driver.
numSamples - the number of samples retrieved from the driver.
overflow - a set of flags that indicate whether an overvoltage has occurred on any of the channels.
channelA - an array containing data values (in milliVolts) for channel A.
channelB - an array containing data values (in milliVolts) for channel B.
channelC - an array containing data values (in milliVolts) for channel C.
channelD - an array containing data values (in milliVolts) for channel D.

Channels not enabled or not supported by this device will be returned as an empty array.

Please also refer to the ps4000SetDataBuffer and ps4000GetValues functions in the PicoScope 4000 Series PC Oscilloscopes Programmer's Guide.</Description>
            </Method>
            <Method>
               <Name>ps4000GetTriggerTimeOffset</Name>
               <Location>block</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function [status, timeUpper, timeLower, timeUnits] = ps4000GetTriggerTimeOffset(obj, segmentIndex)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    
    timeUpper = 0;
    timeLower = 0;
    timeUnits = 0;
    
    [status, timeUpper, timeLower, timeUnits] = calllib('ps4000', ...
        'ps4000GetTriggerTimeOffset', deviceObj.DriverData.unitHandle, ...
        timeUpper, timeLower, timeUnits, segmentIndex);
    
    if(status ~= PicoStatus.PICO_OK)
           
        error('ps4000GetTriggerTimeOffset: Status code: %d. Please refer to the PicoStatus.m file.', status); 
        
    end
</MCode>
               </Code>
               <Description>ps4000GetTriggerTimeOffset(obj, segmentIndex) gets the time, as two 4-byte values, at which the trigger occurred.

This function may be used with the Test and Measurement Tool.

Input parameters:

obj - the object representing the Block group.
segmentIndex - the number of the memory segment for which the information is required.

Output parameters:

status - status code returned by the driver.
timeUpper - the upper 32 bits of the time at which the trigger point occurred.
timeLower - the lower 32 bits of the time at which the trigger point occurred.
timeUnits - the time units in which timeUpper and timeLower are measured (represented by a PS4000_TIME_UNITS enumeration).

For further information on the ps4000GetTriggerTimeOffset function please refer to the PicoScope 4000 Series PC Oscilloscopes Programmer's Guide.</Description>
            </Method>
            <Method>
               <Name>ps4000GetTriggerTimeOffset64</Name>
               <Location>block</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function [status, time, timeUnits] = ps4000GetTriggerTimeOffset64(obj, segmentIndex)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    
    time = 0;
    timeUnits = 0;

    [status, timeUnits] = calllib('ps4000', ...
        'ps4000GetTriggerTimeOffset64', deviceObj.DriverData.unithandle, ...
        time, timeUnits, segmentIndex);
    
    if(status ~= PicoStatus.PICO_OK)
           
        error('ps4000GetTriggerTimeOffset64: Status code: %d. Please refer to the PicoStatus.m file.', status);  
        
    end</MCode>
               </Code>
               <Description>ps4000GetTriggerTimeOffset64(obj, segmentIndex)  gets the time, as a single 64-bit value, at which the trigger occurred.

This function may be used with the Test and Measurement Tool.

Input parameters:

obj - the object representing the Block group.
segmentIndex -  the number of the memory segment for which the information is required.

Output parameters:

status - status code returned by the driver.
time - the time at which the trigger point occurred.
timeUnits - the time units in which time is measured (as an enumeration).

For further information on the ps4000GetTriggerTimeOffset64 function please refer to the PicoScope 4000 Series PC Oscilloscopes Programmer's Guide.</Description>
            </Method>
            <Method>
               <Name>ps4000GetValues</Name>
               <Location>block</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function [status, numSamples, overflow] = ps4000GetValues(obj, startIndex, noOfSamples, downSampleRatio, downSampleRatioMode, segmentIndex)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    
    pNumSamples = libpointer('uint32Ptr', noOfSamples);
    pOverflow = libpointer('int16Ptr', 0);
    
    [status] = calllib('ps4000', 'ps4000GetValues', ...
        deviceObj.DriverData.unitHandle, startIndex, pNumSamples, downSampleRatio, ....
        downSampleRatioMode, segmentIndex, pOverflow);
    
    if(status ~= PicoStatus.PICO_OK)
           
        error('ps4000GetValues: Status code: %d. Please refer to the PicoStatus.m file.', status);   
    
    else
        
        overflow = pOverflow.Value;
        numSamples = pNumSamples.Value;
        
    end</MCode>
               </Code>
               <Description>ps4000GetValues(obj, startIndex, noOfSamples, downSampleRatio, downSampleRatioMode, segmentIndex) returns block-mode data, with or without downsampling, starting at the specified sample number.

Input parameters:

obj - the object representing the Block group.
startIndex - a zero-based index that indicates the start point for data collection.
noOfSamples - the number of samples required.
downSampleRatio - the downsampling factor that will be applied to the raw data.
downSampleRatioMode - which downsampling mode to use (specified by enumeration).
segmentIndex - the zero-based number of the memory segment where the data is stored.

Output parameters:

status - status code returned by the driver.
numSamples - the actual number retrieved from the driver.
overflow - a set of flags that indicate whether an overvoltage has occurred on any of the channels.

For further information on the ps4000GetValues function please refer to the PicoScope 4000 Series PC Oscilloscopes Programmer's Guide.</Description>
            </Method>
            <Method>
               <Name>runBlock</Name>
               <Location>block</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function [status, timeIndisposedMs] = runBlock(obj, segmentIndex)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    deviceObj = get(obj, 'Parent');

    timeIndisposedMs = 0;   % Initialise to pass as pointer.
    overSample = 0;         % OverSampling not needed, please use downsampling
    lpReady = [];           % Set to NULL - Callback function not used.
    pParameter = [];        % Set to NULL - Callback function not used.
    
    unitHandle = deviceObj.DriverData.unitHandle;
    timebaseIndex = deviceObj.DriverData.timebase;
    preTriggerSamples = deviceObj.DriverData.numPreTriggerSamples;
    postTriggerSamples = deviceObj.DriverData.numPostTriggerSamples;

    if (deviceObj.DriverData.displayOutput == PicoConstants.TRUE)
        
        fprintf('runBlock:- Collecting block of data:\n\tTimebase: %u\n\tPre-trigger samples: %u\n\tPost-trigger samples: %u\n', ...
            timebaseIndex, preTriggerSamples, postTriggerSamples);
        
    end

   [runBlockStatus, timeIndisposedMs] = calllib('ps4000', 'ps4000RunBlock', ...
        unitHandle, preTriggerSamples, postTriggerSamples, ...
        timebaseIndex,overSample, timeIndisposedMs,segmentIndex, lpReady, pParameter);

    if(runBlockStatus ~= PicoStatus.PICO_OK)
           
        error('runBlock: Error in ps4000RunBlock call - code %d', runBlockStatus); 
        
    end
 
    if (deviceObj.DriverData.displayOutput == PicoConstants.TRUE)
        
        fprintf('runBlock: Waiting for device to become ready...\n');
        
    end
  
    ready = 0; % Initialise value for pointer

    while(ready == 0)
        
        [readyStatus, ready] = calllib('ps4000', 'ps4000IsReady', ...
                                unitHandle, ready);
                        
        if(readyStatus == PicoStatus.PICO_OK || readyStatus == PicoStatus.PICO_BUSY)
           
            % Do nothing
            
        else
            
            error('runBlock: Error in ps4000IsReady call - code %d', readyStatus); 
        
        end
                        
    end
    
    if (deviceObj.DriverData.displayOutput == PicoConstants.TRUE)
        
        fprintf('runBlock: Device ready.\n\n');
        
    end
    
    % Other conditions would have been captured.
    if(runBlockStatus == PicoStatus.PICO_OK &amp;&amp; readyStatus == PicoStatus.PICO_OK)
        
        status = PicoStatus.PICO_OK;
        
    else
        
        if(runBlockStatus ~= PicoStatus.PICO_OK)
            
            error('runBlock:- ps4000RunBlock error code: %d\n', runBlockStatus);
            
        else
            
            error('runBlock:- ps4000IsReady error code: %d\n', readyStatus);
                
        end
            
        
    end;
    
    
    
</MCode>
               </Code>
               <Description>runBlock(obj, segmentIndex) starts collecting data in block mode and returns when the device is ready for data to be collected.

Input parameters:

obj - the object representing the Block group.
segmentIndex - zero-based index, specifying which memory segment to use. Set this parameter to 0, if memory has not been segmented.

Output parameters:

status - 0 if the ps4000RunBlock and ps4000IsReady functions have been executed correctly. 

For further information on the  ps4000RunBlock and ps4000IsReady functions please refer to the PicoScope 4000 Series PC Oscilloscopes Programmer's Guide.
</Description>
            </Method>
         </MethodInfo>
      </Group>
      <Group>
         <Name>rapidblock</Name>
         <Description>The Rapidblock group contains a set of properties and functions related to the rapid block data collection functionality of the device.</Description>
         <Command/>
         <Size>1</Size>
         <Mappings>
            <ChannelMap Command="rapidblock" Index="1"/>
         </Mappings>
         <PropertyInfo/>
         <MethodInfo>
            <Method>
               <Name>getRapidBlockData</Name>
               <Location>rapidblock</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function [numSamples, overflow, channelA, channelB, channelC, channelD] = getRapidBlockData(obj, numCaptures)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    unitHandle = deviceObj.DriverData.unitHandle;

    channelCount = deviceObj.DriverData.channelCount;

    % Retrieve channel settings - channel x data field matrix
    channelSettings = deviceObj.DriverData.channelSettings; 

    % Create empty arrays for channel data.
    channelA = [];
    channelB = [];
    channelC = [];
    channelD = [];

    % Initialise variable for array of libpointers
    pBuffer(channelCount, numCaptures) = libpointer;

    % Initialise array for status values
    setBufferStatus = zeros(channelCount, numCaptures, 'uint32');

    % total number of samples to set for data buffers
    totalSamples = deviceObj.DriverData.numPreTriggerSamples + deviceObj.DriverData.numPostTriggerSamples;

    % Create a 2D matrix of libpointers to allocate memory space for
    % each channel and segment combination
    for segment = 1:numCaptures

        for ch = 1:channelCount

            % Set Data Buffer if channel is enabled
            if (channelSettings(ch, 1) == PicoConstants.TRUE)

                % Store array of libpointers
                pBuffer(ch, segment) = libpointer('int16Ptr', zeros(totalSamples, 1, 'int16'));

                setBufferStatus(ch, segment) = calllib('ps4000', 'ps4000SetDataBufferBulk', ...
                    unitHandle, (ch - 1), pBuffer(ch, segment), totalSamples, ...
                    (segment - 1));

                if (setBufferStatus(ch, segment) ~= PicoStatus.PICO_OK)

                    error('getRapidBlockData: Set Data Buffer for Channel %d Segment % error code %d', ...
                        (ch - 1), (segment - 1), setBufferStatus);

                end

            end

        end

    end

    if (deviceObj.DriverData.displayOutput == PicoConstants.TRUE)
        
        fprintf('getRapidBlockData: Retrieving data...\n');
        
    end

    fromSegmentIndex = 0;
    toSegmentIndex = numCaptures - 1;

    overflowSize = (toSegmentIndex - fromSegmentIndex) + 1;
    overflowPtr = libpointer('int16Ptr', zeros(overflowSize, 1, 'int16'));
    overflow = 0;

    % Call ps4000GetValuesBulk
    [getValuesBulkStatus, numSamples] = calllib('ps4000', ...
        'ps4000GetValuesBulk', unitHandle, totalSamples, fromSegmentIndex, ...
        toSegmentIndex, overflowPtr);

    overflow = overflowPtr.Value;

    if (getValuesBulkStatus == PicoStatus.PICO_OK)

        if (deviceObj.DriverData.displayOutput == PicoConstants.TRUE)
            
            fprintf('getRapidBlockData: Converting to millivolts and assigning to channel array.\n');
            
        end

        % Obtain max ADC count value
        maxADCValue = double(deviceObj.DriverData.maxADCValue);

        % Retrieve data values for enabled channels
        for ch = 1:channelCount

            if (channelSettings(ch,1) == PicoConstants.TRUE)

                scopeInputIndex = channelSettings(ch, 3) + 1;
                voltageRange = PicoConstants.SCOPE_INPUT_RANGES(scopeInputIndex);

                % Obtain a cell array representing the waveforms for 
                % the channel

                bufferCell = get(pBuffer(ch, :), 'Value');

                % Combine the cell contents into a total_samples x
                % numCaptures array

                bufferMatrix = [];

                if (numCaptures &gt; 1)

                    bufferMatrix = horzcat(bufferCell{1:end});

                else

                    bufferMatrix = bufferCell;

                end

                bufferValues = adc2mv(bufferMatrix, voltageRange, ...
                    maxADCValue);

                switch(ch - 1)

                    case evalin('base', 'ps4000Enuminfo.enPS4000Channel.PS4000_CHANNEL_A')

                        channelA = bufferValues;

                    case evalin('base', 'ps4000Enuminfo.enPS4000Channel.PS4000_CHANNEL_B')

                        channelB = bufferValues;

                    case evalin('base', 'ps4000Enuminfo.enPS4000Channel.PS4000_CHANNEL_C')

                        channelC = bufferValues;

                    case evalin('base', 'ps4000Enuminfo.enPS4000Channel.PS4000_CHANNEL_D')

                        channelD = bufferValues;

                    otherwise

                        % Do nothing

                end

                clear bufferCell;
                clear bufferMatrix;
                clear bufferValues;

            end

        end

        if (deviceObj.DriverData.displayOutput == PicoConstants.TRUE)
            
            fprintf('getRapidBlockData: Data succesfully retrieved.\n\n');
            
        end

        clear pBuffer;

    else

        error('getRapidBlockData: Error retrieving data values - code: %d', getValuesBulkStatus);

    end      
</MCode>
               </Code>
               <Description>getRapidBlockData(obj, numCaptures) retrieves waveforms captured using rapid block mode. The waveforms must have been collected sequentially and in the same run.

Memory for the data arrays from segment index 0 to numCaptures - 1 is allocated and the driver is informed where to store the data prior to retrieval. Data collection using a downsampling mode  is NOT supported by this function.

This function can be used with the Test and Measurement Tool.

Input parameters:

obj - the object representing the Rapidblock group.
numCaptures - the number of waveform captures to retrieve.

Output parameters:

status - status code returned by the driver.
numSamples - the number of samples retrieved from the driver.
overflow - a set of flags that indicate whether an overvoltage has occurred on any of the channels.
channelA - an array containing data values (in milliVolts) for channel A.
channelB - an array containing data values (in milliVolts) for channel B.
channelC - an array containing data values (in milliVolts) for channel C.
channelD - an array containing data values (in milliVolts) for channel D.

Channel data will be returned as an array in the form numSamples x numCaptures. Channels not enabled or not supported by this device will be returned as an empty array.

Please also refer to the  ps4000SetDataBuffer and ps4000GetValues functions as well as the PicoScope 4000 Series PC Oscilloscopes Programmer's Guide.</Description>
            </Method>
            <Method>
               <Name>ps4000GetValuesBulk</Name>
               <Location>rapidblock</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function [status, numSamples, overflow] = ps4000GetValuesBulk(obj, noOfSamples, fromSegmentIndex, toSegmentIndex)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    unitHandle = deviceObj.DriverData.unitHandle;

    % overflow must be an array
    overflowSize = (toSegmentIndex - fromSegmentIndex) + 1;
    overflowPtr = libpointer('int16Ptr', zeros(overflowSize, 1));
    overflow = 0;

    [status, numSamples] = calllib('ps4000', 'ps4000GetValuesBulk', ...
        unitHandle, noOfSamples, fromSegmentIndex, toSegmentIndex, overflowPtr);
    
    if(status == PicoStatus.PICO_OK)
        
        overflow = get(overflowPtr, 'Value');
        
    else
           
        error('ps4000GetValuesBulk: Status code: %d. Please refer to the PicoStatus.m file.', status); 
        
    end</MCode>
               </Code>
               <Description>ps4000GetValuesBulk(obj, noOfSamples, fromSegmentIndex, toSegmentIndex) retrieves waveforms captured using rapid block mode.

Input parameters:

obj - the object representing the Rapidblock group.
noOfSamples - the number of samples required.
fromSegmentIndex - the first segment from which the waveform should be retrieved.
toSegmentIndex - the last segment from which the waveform should be retrieved.

Output parameters:

status - status code returned by the driver.
numSamples - the actual number retrieved from the driver.
overflow - an array of integers equal to or larger than the number of waveforms to be retrieved with each element corresponding to an overlow value as described in the ps4000GetValues function.

For further information on the ps4000GetValuesBulk function please refer to the PicoScope 4000 Series PC Oscilloscopes Programmer's Guide.</Description>
            </Method>
            <Method>
               <Name>ps4000SetDataBufferBulk</Name>
               <Location>rapidblock</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function status =  ps4000SetDataBufferBulk(obj, channel, pBuffer,bufferLth, segmentIndex, ratioMode)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    status = calllib('ps4000', 'ps4000SetDataBufferBulk', ...
        obj.DriverData.unitHandle, channel, pBuffer, bufferLth, segmentIndex);
            
    if(status ~= PicoStatus.PICO_OK)
           
        error('ps4000SetDataBufferBulk: error code %d', status);
        
    end   
</MCode>
               </Code>
               <Description>ps4000SetDataBufferBulk(obj, channel, pBuffer,bufferLth, segmentIndex) tells the driver where to store the data, either unprocessed or downsampled, that will be returned after the next call to one of the GetValues functions.

Input parameters:

obj - the object representing the device.
channel - the channel to which the buffer corresponds (an enumeration from the PS4000_CHANNEL range).
pBuffer - a libpointer to a 1-D array to receive the data values for the channel.
bufferLth - the length of the buffer array.
segmentIndex - the number of the memory segment to be used.

Output parameters:

status - status code returned by the device.

If want to return all buffer simultaneously please call ps4000GetValuesBulk.

For further information on the ps4000SetDataBuffer function please refer to the PicoScope 4000 Series PC Oscilloscopes Programmer's Guide.
</Description>
            </Method>
            <Method>
               <Name>ps4000SetNoOfCaptures</Name>
               <Location>rapidblock</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function status = ps4000SetNoOfCaptures(obj, nCaptures)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    unitHandle = deviceObj.DriverData.unitHandle;

    status = calllib('ps4000', 'ps4000SetNoOfCaptures', ...
        unitHandle', nCaptures);
    
    if(status ~= PicoStatus.PICO_OK)
           
        error('ps4000SetNoOfCaptures: Status code: %d. Please refer to the PicoStatus.m file.', status);  
        
    end</MCode>
               </Code>
               <Description>ps4000SetNoOfCaptures(obj, nCaptures) sets the number of captures to be collected in one run of rapid block mode.

If this function is not called prior to a run, only a single waveform will be captured.

This function may be used with the Test and Measurement Tool.

Input parameters:

obj - the object representing the Rapidblock group.
nCaptures - the number of waveforms to capture in one run.

Output parameters:

status - status code returned by the device.

For further information on the ps4000SetNoOfCaptures function please refer to the PicoScope 4000 Series PC Oscilloscopes Programmer's Guide.</Description>
            </Method>
         </MethodInfo>
      </Group>
      <Group>
         <Name>signalgenerator</Name>
         <Description>The Signalgenerator group contains a set of properties and functions related to the signal generator functionality of the device.</Description>
         <Command/>
         <Size>1</Size>
         <Mappings>
            <ChannelMap Command="signalgenerator" Index="1"/>
         </Mappings>
         <PropertyInfo>
            <Property>
               <Name>awgBufferSize</Name>
               <Location>signalgenerator</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <GetMCode>function propertyValue = getProperty(obj, propertyName)
% Return a property value.
%   This function is called to return the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    
     % If awgBufferSize doesn't exist, create it.
    if ( ~isfield(deviceObj.DriverData, 'awgBufferSize') )
        deviceObj.DriverData.awgBufferSize = 0;
    end
    
    propertyValue = deviceObj.DriverData.awgBufferSize;</GetMCode>
                  <SetMCode>function set(obj, propertyName, propertyValue)
% Set a property value.
%   This function is called to set the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.
</SetMCode>
               </Code>
               <PermissibleType>
                  <Type>Double</Type>
                  <Constraint>bounded</Constraint>
                  <ConstraintValue>
                     <Range Max="16384.0" Min="0.0"/>
                  </ConstraintValue>
               </PermissibleType>
               <DefaultValue>16384</DefaultValue>
               <ReadOnly>always</ReadOnly>
               <Description>The size of the arbitrary waveform buffer on the device, in samples.</Description>
            </Property>
            <Property>
               <Name>dacFrequency</Name>
               <Location>signalgenerator</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <GetMCode>function propertyValue = getProperty(obj, propertyName)
% Return a property value.
%   This function is called to return the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    
     % If dacFrequency doesn't exist, create it.
    if ( ~isfield(deviceObj.DriverData, 'dacFrequency') )
        deviceObj.DriverData.dacFrequency = 200e6;
    end
    
    propertyValue = deviceObj.DriverData.dacFrequency;</GetMCode>
                  <SetMCode>function set(obj, propertyName, propertyValue)
% Set a property value.
%   This function is called to set the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.
</SetMCode>
               </Code>
               <PermissibleType>
                  <Type>Double</Type>
                  <Constraint>bounded</Constraint>
                  <ConstraintValue>
                     <Range Max="8.0E7" Min="0.0"/>
                  </ConstraintValue>
               </PermissibleType>
               <DefaultValue>80E6</DefaultValue>
               <ReadOnly>always</ReadOnly>
               <Description>The update frequency of the Arbitrary Waveform Generator (MS/s or MHz).</Description>
            </Property>
            <Property>
               <Name>dwellTime</Name>
               <Location>signalgenerator</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <GetMCode>function propertyValue = getProperty(obj, propertyName)
% Return a property value.
%   This function is called to return the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    
     % If awgBufferSize doesn't exist, create it.
    if ( ~isfield(deviceObj.DriverData, 'dwellTime') )
        deviceObj.DriverData.dwellTime = 0;
    end
    
    propertyValue = deviceObj.DriverData.dwellTime;</GetMCode>
                  <SetMCode>function set(obj, propertyName, propertyValue)
% Set a property value.
%   This function is called to set the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.
</SetMCode>
               </Code>
               <PermissibleType>
                  <Type>Double</Type>
                  <Constraint>none</Constraint>
               </PermissibleType>
               <DefaultValue>0</DefaultValue>
               <ReadOnly>never</ReadOnly>
               <Description/>
            </Property>
            <Property>
               <Name>maxPktoPk</Name>
               <Location>signalgenerator</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <GetMCode>function propertyValue = getProperty(obj, propertyName)
% Return a property value.
%   This function is called to return the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    deviceObj = get(obj, 'Parent');    
    
    propertyValue = deviceObj.DriverData.maxPktoPk;</GetMCode>
                  <SetMCode>function set(obj, propertyName, propertyValue)
% Set a property value.
%   This function is called to set the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.
</SetMCode>
               </Code>
               <PermissibleType>
                  <Type>Double</Type>
                  <Constraint>none</Constraint>
               </PermissibleType>
               <DefaultValue>0</DefaultValue>
               <ReadOnly>never</ReadOnly>
               <Description/>
            </Property>
            <Property>
               <Name>offsetVoltage</Name>
               <Location>signalgenerator</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <GetMCode>function propertyValue = getProperty(obj, propertyName)
% Return a property value.
%   This function is called to return the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    
     % If offsetVoltage doesn't exist, create it.
    if ( ~isfield(deviceObj.DriverData, 'offsetVoltage') )
        deviceObj.DriverData.offsetVoltage = 0;
    end
    
    propertyValue = deviceObj.DriverData.offsetVoltage;</GetMCode>
                  <SetMCode>function set(obj, propertyName, propertyValue)
% Set a property value.
%   This function is called to set the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    deviceObj.DriverData.offsetVoltage = propertyValue;</SetMCode>
               </Code>
               <PermissibleType>
                  <Type>Double</Type>
                  <Constraint>bounded</Constraint>
                  <ConstraintValue>
                     <Range Max="2000.0" Min="-2000.0"/>
                  </ConstraintValue>
               </PermissibleType>
               <DefaultValue>0</DefaultValue>
               <ReadOnly>never</ReadOnly>
               <Description>The voltage offset, in milliVolts, to be applied to the waveform.

The sum of the offset voltage and peak to peak voltage should not exceed +/- 4000mV.</Description>
            </Property>
            <Property>
               <Name>peakToPeakVoltage</Name>
               <Location>signalgenerator</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <GetMCode>function propertyValue = getProperty(obj, propertyName)
% Return a property value.
%   This function is called to return the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    
     % If peakToPeakVoltage doesn't exist, create it.
    if ( ~isfield(deviceObj.DriverData, 'peakToPeakVoltage') )
        deviceObj.DriverData.peakToPeakVoltage = 0;
    end
    
    propertyValue = deviceObj.DriverData.peakToPeakVoltage;</GetMCode>
                  <SetMCode>function set(obj, propertyName, propertyValue)
% Set a property value.
%   This function is called to set the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    deviceObj.DriverData.peakToPeakVoltage = propertyValue;</SetMCode>
               </Code>
               <PermissibleType>
                  <Type>Double</Type>
                  <Constraint>bounded</Constraint>
                  <ConstraintValue>
                     <Range Max="4000.0" Min="0.0"/>
                  </ConstraintValue>
               </PermissibleType>
               <DefaultValue>2000</DefaultValue>
               <ReadOnly>never</ReadOnly>
               <Description>The peak-to-peak voltage, in millivolts, of the waveform signal.

The sum of the peak to peak voltage and offset voltage should not exceed +/- 4000mV.</Description>
            </Property>
            <Property>
               <Name>sigGenType</Name>
               <Location>signalgenerator</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <GetMCode>function propertyValue = getProperty(obj, propertyName)
% Return a property value.
%   This function is called to return the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    
     % If sigGenType doesn't exist, create it.
    if ( ~isfield(deviceObj.DriverData, 'sigGenType') )
        deviceObj.DriverData.sigGenType = [ ];
    end
    
    propertyValue = deviceObj.DriverData.sigGenType;</GetMCode>
                  <SetMCode>function set(obj, propertyName, propertyValue)
% Set a property value.
%   This function is called to set the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.
</SetMCode>
               </Code>
               <PermissibleType>
                  <Type>Double</Type>
                  <Constraint>enum</Constraint>
                  <ConstraintValue>
                     <Value>0.0</Value>
                     <Value>1.0</Value>
                     <Value>2.0</Value>
                  </ConstraintValue>
               </PermissibleType>
               <DefaultValue>0.0</DefaultValue>
               <ReadOnly>always</ReadOnly>
               <Description>The type of Signal Generator on the device:

0 - None
1 - Function Generator
2 - Arbitrary Waveform Generator</Description>
            </Property>
            <Property>
               <Name>startFrequency</Name>
               <Location>signalgenerator</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <GetMCode>function propertyValue = getProperty(obj, propertyName)
% Return a property value.
%   This function is called to return the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    
     % If startFrequency doesn't exist, create it.
    if ( ~isfield(deviceObj.DriverData, 'startFrequency') )
        deviceObj.DriverData.startFrequency = [ ];
    end
    
    propertyValue = deviceObj.DriverData.startFrequency;</GetMCode>
                  <SetMCode>function set(obj, propertyName, propertyValue)
% Set a property value.
%   This function is called to set the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    deviceObj.DriverData.startFrequency = propertyValue;</SetMCode>
               </Code>
               <PermissibleType>
                  <Type>Double</Type>
                  <Constraint>bounded</Constraint>
                  <ConstraintValue>
                     <Range Max="1000000.0" Min="0.0"/>
                  </ConstraintValue>
               </PermissibleType>
               <DefaultValue>1000</DefaultValue>
               <ReadOnly>never</ReadOnly>
               <Description>The frequency that the signal generator will initially produce (Hertz).</Description>
            </Property>
            <Property>
               <Name>stopFrequency</Name>
               <Location>signalgenerator</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <GetMCode>function propertyValue = getProperty(obj, propertyName)
% Return a property value.
%   This function is called to return the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    
     % If stopFrequency doesn't exist, create it.
    if ( ~isfield(deviceObj.DriverData, 'stopFrequency') )
        deviceObj.DriverData.stopFrequency = [ ];
    end
    
    propertyValue = deviceObj.DriverData.stopFrequency;</GetMCode>
                  <SetMCode>function set(obj, propertyName, propertyValue)
% Set a property value.
%   This function is called to set the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    deviceObj.DriverData.stopFrequency = propertyValue;</SetMCode>
               </Code>
               <PermissibleType>
                  <Type>Double</Type>
                  <Constraint>bounded</Constraint>
                  <ConstraintValue>
                     <Range Max="1000000.0" Min="0.0"/>
                  </ConstraintValue>
               </PermissibleType>
               <DefaultValue>1000</DefaultValue>
               <ReadOnly>never</ReadOnly>
               <Description>The frequency at which the sweep reverses direction or returns to the initial frequency (Hertz).

To output a signal with constant frequency, ensure that stopFrequency is equal to startFrequency.</Description>
            </Property>
         </PropertyInfo>
         <MethodInfo>
            <Method>
               <Name>ps4000SigGenSoftwareControl</Name>
               <Location>signalgenerator</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function status = ps4000SigGenSoftwareControl(obj, state)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    
    status = calllib('ps4000', 'ps4000SigGenSoftwareControl', ...
                deviceObj.DriverData.unitHandle, state);
            
	if(status ~= PicoStatus.PICO_OK)
           
        error('ps4000SigGenSoftwareControl: Status code: %d. Please refer to the PicoStatus.m file.', status);
        
    end </MCode>
               </Code>
               <Description>ps4000SigGenSoftwareControl(obj, state) causes a trigger event, or starts and stops gating.

This function may be used with the Test and Measurement Tool.

Input parameters:

obj - the object representing the Signalgenerator group.
state - sets the trigger gate high or low when the trigger type is set to either SIGGEN_GATE_HIGH or SIGGEN_GATE_LOW.

Output parameters:

status - status code returned by the driver.

For further information on the ps4000SigGenSoftwareControl function please refer to the PicoScope 4000 Series PC Oscilloscopes Programmer's Guide.</Description>
            </Method>
            <Method>
               <Name>setSigGenArbitrary</Name>
               <Location>signalgenerator</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function [status, dwellTime] = setSigGenArbitrary(obj, increment, dwellTime, arbitraryWaveform, sweepType, operation, indexMode, shots, sweeps, triggerType, triggerSource, extInThresholdMV)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    deviceObj = get(obj, 'Parent');

    % Only call function if device has an Arbitrary Waveform Generator
    if (get(obj, 'sigGenType') == PicoConstants.SIG_GEN_AWG)

        offsetVoltageUV = deviceObj.DriverData.offsetVoltage * 1e3;
        peakToPeakVoltageUV = deviceObj.DriverData.peakToPeakVoltage * 1e3;
        
        if (abs(offsetVoltageUV + peakToPeakVoltageUV) &gt; deviceObj.DriverData.maxPktoPk)
            
            error('setSigGenBuiltInSimple: The sum of offsetVoltage and peakToPeakVoltage cannot exceed +/-4000mV. (or +/- 2000mV for the 4262)');
            
        end
        
        dacFrequency = get(obj, 'dacFrequency');
        
        % Convert the waveform to the range for the driver
        if (deviceObj.InstrumentModel == '4262')
            
            arbitraryWave = int16(arbitraryWaveform * double(intmax('int16')));
            
        else
            
            arbitraryWave = int16(((arbitraryWaveform + 1)/2)*4095);
            
        end
        
        startFrequency = get(obj, 'startFrequency');

        [status, startDeltaPhase] = calllib('ps4000', 'ps4000SigGenFrequencyToPhase', ...
                                  deviceObj.DriverData.unitHandle, ...
                                  startFrequency, indexMode, ...
                                  length(arbitraryWave), 0);                                

        % No need to calculate stop delta phase if start and stop frequencies
        % are the same.
        
        stopFrequency = get(obj, 'stopFrequency');
        
        if (stopFrequency == startFrequency)

            stopDeltaPhase = startDeltaPhase;

        else
            
            [status, stopDeltaPhase] = calllib('ps4000', 'ps4000SigGenFrequencyToPhase', ...
                          deviceObj.DriverData.unitHandle, ...
                          stopFrequency, indexMode, ...
                          length(arbitraryWave), 0); 
        end
        
        [status, deltaPhaseIncrement] = calllib('ps4000', 'ps4000SigGenFrequencyToPhase', ...
              deviceObj.DriverData.unitHandle, ...
              increment, indexMode, ...
              length(arbitraryWave), 0);       

        dwellCount = round(dwellTime * dacFrequency); % Round to the nearest integer
        
        if (dwellCount &lt; obj.dwellTime)

            dwellCount = obj.dwellTime;

        end
        
        % Return dwell time information to the user if it has been
        % modified.
        dwellTime = dwellCount / dacFrequency;
        
        % Calculate external threshold value in counts
        maxADCValue = deviceObj.DriverData.constants.PS4000_MAX_VALUE;
        
        if (deviceObj.InstrumentModel == '4262')
        
            maxADCValue = deviceObj.DriverData.constants.PS4262_MAX_VALUE;
            
        end
        
        extInThreshold = mv2adc(extInThresholdMV, ...
            PicoConstants.SCOPE_INPUT_RANGES(deviceObj.DriverData.extTriggerRange + 1), ...
            maxADCValue);

        status = calllib('ps4000', 'ps4000SetSigGenArbitrary', ...
                    deviceObj.DriverData.unitHandle, ...
                    offsetVoltageUV, peakToPeakVoltageUV, startDeltaPhase, ...
                    stopDeltaPhase, deltaPhaseIncrement, dwellCount, arbitraryWave, ...
                    length(arbitraryWave), sweepType, operation, indexMode, shots, ...
                    sweeps, triggerType, triggerSource, extInThreshold);
         
        % Output error message to user if status is not PICO_OK        
        if (status ~= PicoStatus.PICO_OK)
                    
            switch (status)

                case PicoStatus.PICO_SIG_GEN_PARAM
                    
                    error('setSigGenArbitrary: Incorrect parameter passed to the signal generator.');
                    
                case PicoStatus.PICO_SHOTS_SWEEPS_WARNING
                    
                    error('setSigGenArbitrary: Incorrect parameter passed to the signal generator.');
                    
                case PicoStatus.PICO_SIGGEN_OUTPUT_OVER_VOLTAGE
                    
                    error('setSigGenArbitrary: The combined peak to peak voltage and the analog offset voltage must be in the range 0 -&gt; +/- 2V');
                   
                case PicoStatus.PICO_WARNING_EXT_THRESHOLD_CONFLICT
                    
                    error('setSigGenArbitrary: Attempt to set different EXT input thresholds set for signal generator and oscilloscope trigger.');
                    
                case PicoStatus.PICO_SIGGEN_OFFSET_VOLTAGE
                    
                    error('setSigGenArbitrary: The analog offset voltage is out of range.');

                case PicoStatus.PICO_SIGGEN_PK_TO_PK
                    
                    error('setSigGenArbitrary: The analog peak to peak voltage must be in the range 0 -&gt; +/- 2V.');
                    
                case PicoStatus.PICO_SIGGEN_WAVEFORM_SETUP_FAILED
                    
                    error('setSigGenArbitrary: Unable to setup signal generator waveform.');
                    
                otherwise     
                    
                    error('setSigGenArbitrary: Status code: %d. Please refer to the PicoStatus.m file.', status);
            end
            
        end
        
        clear offsetVoltageUV
        clear peakToPeakVoltageUV
        clear maxBufferSize
        clear dacFrequency
        clear arbitraryWave
        clear startDeltaPhase
        clear stopDeltaPhase
        clear dwellCount
        clear deltaPhaseIncrement
        clear startFrequency;
        clear stopFrequency;
                
    else
       
        error('AWG functionality not supported by this device.');
        
    end</MCode>
               </Code>
               <Description>setSigGenArbitrary(obj, increment, dwellTime, arbitraryWaveform, sweepType, operation, indexMode, shots, sweeps, triggerType, triggerSource, extInThreshold) programs the signal generator to produce an arbitrary waveform.

The startFrequency, stopFrequency, offsetVoltage and peakToPeakVoltage properties must be set prior to calling this function, otherwise the default values will be used.

This function may be used with the Test and Measurement Tool.

Input parameters:

obj - the object representing the Signalgenerator group.
increment - the increase or decrease in frequency when operating in sweep mode.
dwellTime - the time for which the sweep stays at each frequency, in seconds.
arbitraryWaveform -  a buffer that holds the waveform pattern as a set of samples in the range -1 to +1. These values correspond to the 	                                   maximum and minimum amplitude values of the waveform.
sweepType -  determines whether the startFrequency is swept up to the stopFrequency, or down to it, or repeatedly up and down.
operation - configures the white noise/PRBS (pseudo-random binary sequence) generator.
indexMode - specifies how the signal will be formed from the arbitrary waveform data.
shots - the number of cycles of the waveform to be produced after a trigger event. If this is set to a non-zero value 
	then sweeps must be set to zero.
sweeps - the number of times to sweep the frequency after a trigger event, according to sweepType. If this is set to a non-zero value 
		then shots must be set to zero.
triggerType - the type of trigger that will be applied to the signal generator.
triggerSource - the source that will trigger the signal generator.
extInThresholdMV - not used by the PicoScope 4000 Series
Output parameters:

status - status code returned by the driver.
dwellTime -  the dwell time will be modified if the user specifies a dwell time (125e-9) corresponding to less than the minimum dwell count for the device (10).

For further information on the ps4000SetSigGenArbitrary function please refer to the PicoScope 4000 Series PC Oscilloscopes.




 </Description>
            </Method>
            <Method>
               <Name>setSigGenArbitrarySimple</Name>
               <Location>signalgenerator</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function status = setSigGenArbitrarySimple(obj, arbitraryWaveform)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    startDeltaPhase =0;
    single =  evalin('base', 'ps4000Enuminfo.enIndexMode.SINGLE');
    
    % Only call function if device has an Arbitrary Waveform Generator
    if(get(obj, 'sigGenType') == PicoConstants.SIG_GEN_AWG)

        % Convert voltages to microvolts
        offsetVoltageUV = deviceObj.DriverData.offsetVoltage * 1e3;
        peakToPeakVoltageUV = deviceObj.DriverData.peakToPeakVoltage * 1e3;
        
        if(abs(offsetVoltageUV + peakToPeakVoltageUV) &gt; deviceObj.DriverData.maxPktoPk)
            
            error('setSigGenBuiltInSimple: The sum of offsetVoltage and peakToPeakVoltage cannot exceed +/-2000mV.');
            
        end     
                       
        % Convert the waveform to the range for the driver
        if(deviceObj.InstrumentModel == '4262')
            
            arbitraryWave = int16(arbitraryWaveform * double(intmax('int16')));
            
        else
            
            arbitraryWave = int16(((arbitraryWaveform + 1)/2)*4095);
            
        end

        [status, startDeltaPhase] = calllib('ps4000', 'ps4000SigGenFrequencyToPhase', ...
                                  deviceObj.DriverData.unitHandle, ...
                                  obj.startFrequency, single, ...
                                  length(arbitraryWave),startDeltaPhase);                                


        % Constant frequency
        stopDeltaPhase = startDeltaPhase;
    
        status = calllib('ps4000', 'ps4000SetSigGenArbitrary', ...
                    deviceObj.DriverData.unitHandle, offsetVoltageUV, ...
                    peakToPeakVoltageUV, startDeltaPhase, ...
                    stopDeltaPhase, 0, 0, arbitraryWave, ...
                    length(arbitraryWave), 0, 0, 0, 0, 0, 0, 0, 0);
         
        % Output error message to user if status is not PICO_OK        
        if(status ~= PicoStatus.PICO_OK)
                    
            switch(status)

                case PicoStatus.PICO_SIG_GEN_PARAM
                    
                    error('setSigGenArbitrary: Incorrect parameter passed to the signal generator.');
                    
                case PicoStatus.PICO_SHOTS_SWEEPS_WARNING
                    
                    error('setSigGenArbitrary: Incorrect parameter passed to the signal generator.');
                    
                case PicoStatus.PICO_SIGGEN_OUTPUT_OVER_VOLTAGE
                    
                    error('setSigGenArbitrary: The combined peak to peak voltage and the analog offset voltage must be in the range 0 -&gt; +/- 2V');
                   
                case PicoStatus.PICO_WARNING_EXT_THRESHOLD_CONFLICT
                    
                    error('setSigGenArbitrary: Attempt to set different EXT input thresholds set for signal generator and oscilloscope trigger.');
                    
                case PicoStatus.PICO_SIGGEN_OFFSET_VOLTAGE
                    
                    error('setSigGenArbitrary: The analog offset voltage is out of range.');

                case PicoStatus.PICO_SIGGEN_PK_TO_PK
                    
                    error('setSigGenArbitrary: The analog peak to peak voltage must be in the range 0 -&gt; +/- 2V.');
                    
                case PicoStatus.PICO_SIGGEN_WAVEFORM_SETUP_FAILED
                    
                    error('setSigGenArbitrary: Unable to setup signal generator waveform.');
                    
                otherwise     
                    
                    error('setSigGenArbitrarySimple: Status code: %d. Please refer to the PicoStatus.m file.', status);
            end
            
        end
                
    else
       
        error('AWG functionality not supported by this device.');
        
    end


</MCode>
               </Code>
               <Description>setSigGenArbitrary(obj, arbitraryWaveform) programs the signal generator to produce an arbitrary waveform at a constant frequency.

The startFrequency, stopFrequency, offsetVoltage and peakToPeakVoltage properties must be set prior to calling this function, otherwise the default values will be used.

This function may be used with the Test and Measurement Tool.

Input parameters:

obj - the object representing the Signalgenerator group.
arbitraryWaveform -  a buffer that holds the waveform pattern as a set of samples in the range -1 to +1. These values correspond to the 	maximum and minimum amplitude values of the waveform.

Output parameters:

status - status code returned by the driver.

For further information on the ps4000SetSigGenArbitrary function please refer to the PicoScope 4000 Series PC Oscilloscopes Programmer's Guide.</Description>
            </Method>
            <Method>
               <Name>setSigGenBuiltIn</Name>
               <Location>signalgenerator</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function status = setSigGenBuiltIn(obj, waveType, increment, dwellTime, sweepType, operation, shots, sweeps, triggerType, triggerSource, extInThresholdMV)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.
    
    deviceObj = get(obj, 'Parent');
    sigGenType = deviceObj.DriverData.sigGenType;
    
    % Error checking
    if (sigGenType == PicoConstants.SIG_GEN_AWG || ...
            sigGenType == PicoConstants.SIG_GEN_FUNCT_GEN)
        
        % Convert millivolt values to microvolts  
        offsetVoltageUV = deviceObj.DriverData.offsetVoltage * 1e3;
        peakToPeakVoltageUV = deviceObj.DriverData.peakToPeakVoltage * 1e3;
        
        if (abs(offsetVoltageUV + peakToPeakVoltageUV) &gt; deviceObj.DriverData.maxPktoPk)
            
            error('setSigGenBuiltInSimple: The sum of offsetVoltage and peakToPeakVoltage cannot exceed +/-4000mV.');
            
        end
        
        % Calculate external threshold value in counts
        maxADCValue = deviceObj.DriverData.constants.PS4000_MAX_VALUE;

        if (deviceObj.InstrumentModel == '4262')
        
            maxADCValue = deviceObj.DriverData.constants.PS4262_MAX_VALUE;
            
        end
        
        extInThreshold = mv2adc(extInThresholdMV, ...
            PicoConstants.SCOPE_INPUT_RANGES(deviceObj.DriverData.extTriggerRange + 1), ...
            maxADCValue);
        
        status = calllib('ps4000', 'ps4000SetSigGenBuiltIn', deviceObj.DriverData.unitHandle, ...
                    offsetVoltageUV, peakToPeakVoltageUV, waveType, ...
                    deviceObj.DriverData.startFrequency, deviceObj.DriverData.stopFrequency, ...
                    increment, dwellTime, sweepType, operation, shots, sweeps, ...
                    triggerType, triggerSource, extInThreshold);

        % Output error message to user if status is not PICO_OK        
        if (status ~= PicoStatus.PICO_OK)

            switch(status)

                case PicoStatus.PICO_SIG_GEN_PARAM

                    error('setSigGenBuiltIn: One or more signal generator parameters are out of range.');

                case PicoStatus.PICO_SHOTS_SWEEPS_WARNING

                    error('setSigGenBuiltIn: Shots/sweeps warning.');

                case PicoStatus.PICO_SIGGEN_OUTPUT_OVER_VOLTAGE

                    error('setSigGenBuiltIn: The combined peak to peak voltage and the analog offset voltage must be in the range 0 -&gt; +/- 2V');

                case PicoStatus.PICO_SIGGEN_OFFSET_VOLTAGE

                    error('setSigGenBuiltIn: The analog offset voltage is out of range.');

                case PicoStatus.PICO_SIGGEN_PK_TO_PK

                    error('setSigGenBuiltIn: The analog peak to peak voltage must be in the range 0 -&gt; +/- 2V.');

                case PicoStatus.PICO_SIGGEN_WAVEFORM_SETUP_FAILED

                    error('setSigGenBuiltIn: Unable to setup signal generator waveform.');

                otherwise     

                    error('setSigGenBuiltIn: Status code: %d. Please refer to the PicoStatus.m file.', status);
            end

        end
        
        clear offsetVoltage;
        clear peakToPeakVoltage;
        clear sigGenType;
            
    else
        
        error('setSigGenBuiltIn: Signal Generator functionality not supported by this device.');
        
    end</MCode>
               </Code>
               <Description>setSigGenBuiltIn(obj, waveType, increment, dwellTime, sweepType, operation, shots, sweeps, triggerType, triggerSource, extInThresholdMV) sets up the signal generator to produce a signal from a list of built-in waveforms.

The startFrequency, stopFrequency, offsetVoltage and peakToPeakVoltage properties must be set prior to calling this function otherwise the default values will be used.

This function may be used with the Test and Measurement Tool.

Input parameters:

obj - the object representing the Signalgenerator group.
wavetype - the type of waveform to be generated by the oscilloscope. Use the following waveType enumerations:

		0 - SINE
		1 - SQUARE
		2 - TRIANGLE
		3 - RAMP UP
		4 - RAMP DOWN
		5 - SINC
		6 - GAUSSIAN
		7 - HALF SINE
		8 - DC VOLTAGE
		9 - WHITE NOISE

increment - the amount in hertz by which the frequency rises or falls every dwellTime seconds in sweep mode.
dwellTime - the time in seconds between frequency changes in sweep mode.
sweepType - determines whether the startFrequency is swept up to the stopFrequency, or down to it, or repeatedly up and down.
operation - configures the white noise/PRBS (pseudo-random binary sequence) generator.
shots - the number of cycles of the waveform to be produced after a trigger event. If this is set to a non-zero value 
		then sweeps must be set to zero.
sweeps - the number of times to sweep the frequency after a trigger event, according to sweepType. If this is set to a non-zero 	value then shots must be set to zero.
triggerType - the type of trigger that will be applied to the signal generator.
triggerSource - the source that will trigger the signal generator.
extInThresholdMV - not used by the PicoScope 4824

Output parameters:

status - status code returned by the driver.

For further information on the ps4000SetSigGenBuiltIn function please refer to the PicoScope 4000 Series (A API) PC Oscilloscopes Programmer's Guide.

</Description>
            </Method>
            <Method>
               <Name>setSigGenBuiltInSimple</Name>
               <Location>signalgenerator</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function status = setSigGenBuiltInSimple(obj, waveType)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.
 
    deviceObj = get(obj, 'Parent');
    sigGenType = get(obj, 'sigGenType');
    
    % Error checking
    if(sigGenType == PicoConstants.SIG_GEN_AWG || ...
            sigGenType == PicoConstants.SIG_GEN_FUNCT_GEN)
        
        % Convert millivolt values to microvolts  
        offsetVoltageUV = deviceObj.DriverData.offsetVoltage * 1e3;
        peakToPeakVoltageUV = deviceObj.DriverData.peakToPeakVoltage * 1e3;
        
        if(abs(offsetVoltageUV + peakToPeakVoltageUV) &gt; deviceObj.DriverData.maxPktoPk)
            
            error('setSigGenBuiltInSimple: The sum of offsetVoltage and peakToPeakVoltage cannot exceed +/-4000mV.');
            
        end
        
        status = calllib('ps4000', 'ps4000SetSigGenBuiltIn', deviceObj.DriverData.unitHandle, ...
                    offsetVoltageUV, peakToPeakVoltageUV, waveType, ...
                    deviceObj.DriverData.startFrequency, deviceObj.DriverData.startFrequency, ...
                        0, 0, 0, 0, 0, 0, 0, 0, 0);
                    
        % Output error message to user if status is not PICO_OK        
        if(status ~= PicoStatus.PICO_OK)

            switch(status)

                case PicoStatus.PICO_SIG_GEN_PARAM

                    error('setSigGenBuiltInSimple: One or more signal generator parameters are out of range.');

                case PicoStatus.PICO_SHOTS_SWEEPS_WARNING

                    error('setSigGenBuiltInSimple: Shots/sweeps warning.');

                case PicoStatus.PICO_SIGGEN_OUTPUT_OVER_VOLTAGE

                    error('setSigGenBuiltInSimple: The combined peak to peak voltage and the analog offset voltage must be in the range 0 -&gt; +/- 2V');

                case PicoStatus.PICO_WARNING_EXT_THRESHOLD_CONFLICT

                    error('setSigGenBuiltInSimple: External threshold conflict.');

                case PicoStatus.PICO_SIGGEN_OFFSET_VOLTAGE

                    error('setSigGenBuiltInSimple: The analog offset voltage is out of range.');

                case PicoStatus.PICO_SIGGEN_PK_TO_PK

                    error('setSigGenBuiltInSimple: The analog peak to peak voltage must be in the range 0 -&gt; +/- 2V.');

                case PicoStatus.PICO_SIGGEN_WAVEFORM_SETUP_FAILED

                    error('setSigGenBuiltInSimple: Unable to setup signal generator waveform.');

                otherwise     

                    error('setSigGenBuiltInSimple: Status code: %d. Please refer to the PicoStatus.m file.', status);
            end

        end  
        
        clear offsetVoltageUV;
        clear peakToPeakVoltageUV;
        clear sigGenType;
    
    else
        
        error('setSigGenBuiltInSimple: Signal Generator functionality not supported by this device.');
        
    end
</MCode>
               </Code>
               <Description>setSigGenBuiltInSimple(obj,  waveType) sets up the signal generator to produce a signal of constant frequency from a list of built-in waveforms.

The startFrequency, offsetVoltage and peakToPeakVoltage properties must be set prior to using this function, or the default values will be used.

The offset voltage offsetVoltage and peakToPeakVoltage properties are defined in millivolts and converted to microvolts for the underlying driver. The sum of offsetVoltageMV and pkToPkMV cannot exceed 4000 millivolts.

This function may be used with the Test and Measurement Tool.

Input parameters:

obj - the object representing the Signalgenerator group.
wavetype - the type of waveform to be generated by the oscilloscope. Use the following waveType enumerations:

		0 - SINE
		1 - SQUARE
		2 - TRIANGLE
		3 - RAMP UP
		4 - RAMP DOWN
		5 - SINC
		6 - GAUSSIAN
		7 - HALF SINE
		8 - DC VOLTAGE
		9 - WHITE NOISE

Output parameters:

status - status code returned by the driver.

For further information, please view the Help text for the ps4000SetSigGenBuiltIn function.
</Description>
            </Method>
            <Method>
               <Name>setSigGenOff</Name>
               <Location>signalgenerator</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function status = setSigGenOff(obj)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    
    offsetVoltage = 0;
    pkToPk = 0;
    waveTypeDC = 8;
    
    status = calllib('ps4000', 'ps4000SetSigGenBuiltIn', ...
                deviceObj.DriverData.unitHandle, ...
                offsetVoltage, pkToPk, waveTypeDC, 0, 0, ...
                0, 0, 0, 0, 0, 0, 0, 0, 0);
                    
    if(status ~= PicoStatus.PICO_OK)
       
        error('setSigGenOff: Status code: %d. Please refer to the PicoStatus.m file.', status);
        
    end
            
	clear offsetVoltage;
    clear pkToPk;
    clear waveTypeDC;</MCode>
               </Code>
               <Description>setSigGenOff(obj) effectively turns off the signal generator by setting the output to a zero DC voltage.

This function may be used with the Test and Measurement Tool.

Input parameters:

obj - the object representing the Signalgenerator group.

Output parameters:

status - status code returned by the driver.</Description>
            </Method>
         </MethodInfo>
      </Group>
      <Group>
         <Name>streaming</Name>
         <Description>The Streaming group contains a set of properties and functions related to the streaming data collection functionality of the device.</Description>
         <Command/>
         <Size>1</Size>
         <Mappings>
            <ChannelMap Command="streaming" Index="1"/>
         </Mappings>
         <PropertyInfo>
            <Property>
               <Name>autoStop</Name>
               <Location>streaming</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <GetMCode>function propertyValue = getProperty(obj, propertyName)
% Return a property value.
%   This function is called to return the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    
    % If autoStop doesn't exist, create it.
    if ( ~isfield(deviceObj.DriverData, 'autoStop') )
        deviceObj.DriverData.autoStop = 0;
    else
        propertyValue = deviceObj.DriverData.autoStop;
    end</GetMCode>
                  <SetMCode>function set(obj, propertyName, propertyValue)
% Set a property value.
%   This function is called to set the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    deviceObj.DriverData.autoStop = propertyValue;</SetMCode>
               </Code>
               <PermissibleType>
                  <Type>Double</Type>
                  <Constraint>enum</Constraint>
                  <ConstraintValue>
                     <Value>0.0</Value>
                     <Value>1.0</Value>
                  </ConstraintValue>
               </PermissibleType>
               <DefaultValue>1</DefaultValue>
               <ReadOnly>never</ReadOnly>
               <Description>A flag to specify if streaming data collection should stop when all of maxSamples have been taken.

This flag should be set to 0 or 1.</Description>
            </Property>
            <Property>
               <Name>streamingInterval</Name>
               <Location>streaming</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <GetMCode>function propertyValue = getProperty(obj, propertyName)
% Return a property value.
%   This function is called to return the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    
    % If streamingInterval doesn't exist, create it.
    if ( ~isfield(deviceObj.DriverData, 'streamingInterval') )
        deviceObj.DriverData.streamingInterval = 0;
    end
    
    propertyValue = deviceObj.DriverData.streamingInterval;</GetMCode>
                  <SetMCode>function set(obj, propertyName, propertyValue)
% Set a property value.
%   This function is called to set the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    deviceObj.DriverData.streamingInterval = propertyValue;</SetMCode>
               </Code>
               <PermissibleType>
                  <Type>Double</Type>
                  <Constraint>none</Constraint>
               </PermissibleType>
               <DefaultValue>0</DefaultValue>
               <ReadOnly>never</ReadOnly>
               <Description/>
            </Property>
         </PropertyInfo>
         <MethodInfo>
            <Method>
               <Name>autoStopped</Name>
               <Location>streaming</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function autoStop = autoStopped(obj)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    unitHandle = deviceObj.DriverData.unitHandle;
    
    autoStop = calllib('ps4000Wrap', 'AutoStopped', unitHandle);</MCode>
               </Code>
               <Description>AutoStopped(obj) indicates if the device has stopped on collection of the number of samples specified in the call to the ps4000RunStreaming function.

The autoStop property must have been set to 1.

Input parameters:

obj - the object representing the Streaming group.

Output parameters:

autoStop - 0 if the device has not stopped, non-zero if streaming has auto-stopped.</Description>
            </Method>
            <Method>
               <Name>availableData</Name>
               <Location>streaming</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function [numSamples, startIndex] = availableData(obj)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    unitHandle = deviceObj.DriverData.unitHandle;
    
    startIndex = 0; % Initialise variable to be used as a pointer

    [numSamples, startIndex] = calllib('ps4000Wrap', 'AvailableData', ...
                                unitHandle, startIndex);</MCode>
               </Code>
               <Description>AvailableData(obj) indicates the number of samples returned from the driver and shows the start index of the data in the buffer when collecting data in streaming mode.

Input parameters:

obj - the object representing the Streaming group.

Output parameters:

numSamples - 0, data is not yet available; Non-zero, the number of samples returned from the driver.
startIndex - an index to the first valid sample in the buffer (when data is available).

Note: the startIndex value is zero-based so should be incremented by 1 when used to retrieve data from the buffer.</Description>
            </Method>
            <Method>
               <Name>clearTriggerReady</Name>
               <Location>streaming</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function triggerCleared = clearTriggerReady(obj)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    unitHandle = deviceObj.DriverData.unitHandle;
    
    triggerCleared = calllib('ps4000Wrap', 'ClearTriggerReady', unitHandle);</MCode>
               </Code>
               <Description>ClearTriggerReady(obj) clears the triggered and triggeredAt flags in relation to streaming mode capture.

Input parameters:

obj - the object representing the Streaming group.

Output parameters:

1 - Call successfully completed.</Description>
            </Method>
            <Method>
               <Name>getStreamingLatestValues</Name>
               <Location>streaming</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function status = getStreamingLatestValues(obj)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    unitHandle = deviceObj.DriverData.unitHandle;
    
    status = calllib('ps4000Wrap', 'GetStreamingLatestValues', ...
                unitHandle);
            
    if(status ~= PicoStatus.PICO_OK &amp;&amp; status ~= PicoStatus.PICO_BUSY)
           
        error('ps4000GetStreamingLatestValues: Status code: %d. Please refer to the PicoStatus.m file.', status); 
        
    end</MCode>
               </Code>
               <Description>getStreamingLatestValues(obj) facilitates communication with the underlying driver to return the next block of values to your application when capturing data in streaming mode.

Input parameters:

obj - the object representing the Streaming group.

Output parameters:

status - status code returned by the driver.

For further information on the underlying ps4000GetStreamingLatestValues function please refer to the PicoScope 4000 Series PC Oscilloscopes Programmer's Guide.</Description>
            </Method>
            <Method>
               <Name>isReady</Name>
               <Location>streaming</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function ready = isReady(obj)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    unitHandle = deviceObj.DriverData.unitHandle;
    
    ready = calllib('ps4000Wrap', 'IsReady', unitHandle);
</MCode>
               </Code>
               <Description>IsReady(obj) is used to poll the driver to verify that data is ready to be received. The ps4000RunStreaming function must have been called prior to calling this function.

Input parameters:

obj - the object representing the Streaming group.

Output parameters:

ready - 0, if data is not yet available; non-zero if data is ready to be collected.</Description>
            </Method>
            <Method>
               <Name>isTriggerReady</Name>
               <Location>streaming</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function [triggered, triggeredAt] = isTriggerReady(obj)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    unitHandle = deviceObj.DriverData.unitHandle;
    
    triggeredAt = 0; % Initialise value to zero for pointer.

    [triggered, triggeredAt] = calllib('ps4000Wrap', 'IsTriggerReady', ...
        unitHandle, triggeredAt);
</MCode>
               </Code>
               <Description>isTriggerReady(obj) indicates whether a trigger has occurred when collecting data in streaming mode, and the location of the trigger point.

Input parameters:

obj - the object representing the Streaming group.

Output parameters:

triggered - 0, if the device has not triggered; Non-zero, if the device has been triggered.
triggeredAt - the zero-based index of the sample in the buffer where the trigger occurred.</Description>
            </Method>
            <Method>
               <Name>ps4000NoOfStreamingValues</Name>
               <Location>streaming</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function [status, noOfValues] = ps4000NoOfStreamingValues(obj)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    unitHandle = deviceObj.DriverData.unitHandle;
    
    noOfValues = 0; % Initialise value for use as pointer.

    [status, noOfValues] = calllib('ps4000', 'ps4000NoOfStreamingValues', ...
        unitHandle, noOfValues);
    
    if(status ~= PicoStatus.PICO_OK)
           
        error('ps4000NoOfStreamingValues: Status code: %d. Please refer to the PicoStatus.m file.', status); 
        
    end
</MCode>
               </Code>
               <Description>ps4000NoOfStreamingValues(obj) returns the number of samples available after data collection in streaming mode. Call this function after calling ps4000Stop.

Input parameters:

obj - the object representing the device.

Output parameters:

status - status code returned by the driver.
noOfValues - the number of samples.

For further information on the ps4000NoOfStreamingValues function please refer to the PicoScope 4000 Series PC Oscilloscopes Programmer's Guide.</Description>
            </Method>
            <Method>
               <Name>ps4000RunStreaming</Name>
               <Location>streaming</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function [status, sampleInterval, sampleIntervalTimeUnitsStr] = ps4000RunStreaming(obj, downSampleRatio, overviewBufferSize)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    unitHandle = deviceObj.DriverData.unitHandle;
    
    % Calculate sampleInterval and sampleIntervalTimeUnits according to
    % streamingInterval property set. Property is defined in seconds.

    streamingInterval = deviceObj.DriverData.streamingInterval;
    
    femtosecondsEnum = evalin('base', 'ps4000Enuminfo.enPS4000TimeUnits.PS4000_FS');
    picosecondsEnum = evalin('base', 'ps4000Enuminfo.enPS4000TimeUnits.PS4000_PS');
    nanosecondsEnum = evalin('base', 'ps4000Enuminfo.enPS4000TimeUnits.PS4000_NS');
    microsecondsEnum = evalin('base', 'ps4000Enuminfo.enPS4000TimeUnits.PS4000_US');
    millisecondsEnum = evalin('base', 'ps4000Enuminfo.enPS4000TimeUnits.PS4000_MS');
    secondsEnum = evalin('base', 'ps4000Enuminfo.enPS4000TimeUnits.PS4000_S');
    
    sampleIntervalTimeUnits = secondsEnum;
    
    % Match the specified interval to the correct time units
    % If an interval with component less than the minimum value for the time unit 
    % is specified e.g 1.3e-3, that will be converted to 1300 microseconds.
    
    if (streamingInterval &lt; 1e-12) % Femtoseconds (unlikely with USB 2.0/USB 3.0)
        
        sampleInterval = streamingInterval * 1e15;
        sampleIntervalTimeUnits = femtosecondsEnum;
        
    elseif (streamingInterval &gt;= 1e-12 &amp;&amp; streamingInterval &lt; 1e-9) % Picoseconds
        
        if (mod(streamingInterval, 1e-12) &gt; 0)
        
            sampleInterval = streamingInterval * 1e15;
            sampleIntervalTimeUnits = femtosecondsEnum;
            
        else
           
            sampleInterval = streamingInterval * 1e12;
            sampleIntervalTimeUnits = picosecondsEnum;
            
        end
        
    elseif (streamingInterval &gt;= 1e-9 &amp;&amp; streamingInterval &lt; 1e-6) % Nanoseconds

        if (mod(streamingInterval, 1e-9) &gt; 0)
            
            sampleInterval = streamingInterval * 1e12;
            sampleIntervalTimeUnits = picosecondsEnum;
            
        else
           
            sampleInterval = streamingInterval * 1e9;
            sampleIntervalTimeUnits = nanosecondsEnum;
            
        end
        
    elseif (streamingInterval &gt;= 1e-6 &amp;&amp; streamingInterval &lt; 1e-3) % Microseconds
        
        if (mod(streamingInterval, 1e-6) &gt; 0)
        
            sampleInterval = streamingInterval * 1e9;
            sampleIntervalTimeUnits = nanosecondsEnum;
            
        else
           
            sampleInterval = streamingInterval * 1e6;
            sampleIntervalTimeUnits = microsecondsEnum;
            
        end
        
    elseif (streamingInterval &gt;= 1e-3 &amp;&amp; streamingInterval &lt; 1) % Milliseconds
        
        if (mod(streamingInterval, 1e-3) &gt; 0)
           
            sampleInterval = streamingInterval * 1e6;
            sampleIntervalTimeUnits = microsecondsEnum;
            
        else
            
            sampleInterval = streamingInterval * 1e3;
            sampleIntervalTimeUnits = millisecondsEnum;
            
        end
            
    else 
        
        % Already defined seconds 
        
        % 
        if (mod(sampleInterval, 1) &gt; 0)
           
           sampleInterval = streamingInterval * 1e3;
           sampleIntervalTimeUnits = millisecondsEnum;
           
       end
        
    end
        
    autoStop = get(obj, 'autoStop');
    
    [status, sampleInterval] = calllib('ps4000', 'ps4000RunStreaming', ...
        unitHandle, sampleInterval, sampleIntervalTimeUnits, ...
        deviceObj.DriverData.numPreTriggerSamples, ...
        deviceObj.DriverData.numPostTriggerSamples, ...
        autoStop, downSampleRatio, overviewBufferSize);
    
    if (status == PicoStatus.PICO_OK)
           
        if (deviceObj.DriverData.displayOutput == PicoConstants.TRUE)
            
            fprintf('ps4000RunStreaming:- Sample interval %d ', sampleInterval);
            
        end
        
        switch(sampleIntervalTimeUnits)
       
            case femtosecondsEnum

                sampleIntervalTimeUnitsStr = 'fs';
                
            case picosecondsEnum

                sampleIntervalTimeUnitsStr = 'ps';

            case nanosecondsEnum

                sampleIntervalTimeUnitsStr = 'ns';

            case microsecondsEnum

                sampleIntervalTimeUnitsStr = 'us';

            case millisecondsEnum

                sampleIntervalTimeUnitsStr = 'ms';

            case secondsEnum

                sampleIntervalTimeUnitsStr = 's';
            
            otherwise
                
                % Do nothing
        
        end
        
        if (deviceObj.DriverData.displayOutput == PicoConstants.TRUE)
            
            fprintf('%s\n', sampleIntervalTimeUnitsStr);
            
        end
        
        clear streamingInterval;
        clear femtosecondsEnum;
        clear picosecondsEnum;
        clear nanosecondsEnum;
        clear microsecondsEnum;
        clear millisecondsEnum;
        clear secondsEnum;     

        
    else
        
        error('ps4000RunStreaming: Error code %d\n', status);
        
    end
</MCode>
               </Code>
               <Description>ps4000RunStreaming(obj, downSampleRatio, downSampleRatioMode, overviewBufferSize) function tells the oscilloscope to start collecting data in streaming mode. Use the function getStreamingLatestValues to ensure values are copied into the application buffers. 

Input parameters:

obj - the object representing the Streaming group.
downSampleRatio - the downsampling factor that will be applied to the raw data.
downSampleRatioMode -  which downsampling mode to use (an enumeration from the PS4000_RATIO_MODE range).
overviewBufferSize - the size of the overview buffers (temporary buffers used for storing the data before returning it to the application).

Output parameters:

status - status code returned by the driver.
sampleInterval - the actual time interval used.
sampleIntervalTimeUnitsStr - a string representing the time unit for the sampling interval.

For further information on the ps4000RunStreaming function please refer to the PicoScope 4000 Series PC Oscilloscopes Programmer's Guide.</Description>
            </Method>
            <Method>
               <Name>setAppAndDriverBuffers</Name>
               <Location>streaming</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function status = setAppAndDriverBuffers(obj, channel, appBuffer, driverBuffer, bufferLength)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    unitHandle = deviceObj.DriverData.unitHandle;
    
    status = calllib('ps4000Wrap', 'setAppAndDriverBuffers', ...
        unitHandle, channel, appBuffer, driverBuffer, bufferLength);
    
    if(status ~= PicoStatus.PICO_OK)
       
        if(status == PicoStatus.PICO_INVALID_CHANNEL)
            
            error('setAppAndDriverBuffers: Invalid channel specified.');
                    
        elseif(status == PICO_INVALID_HANDLE)
            
            error('setAppAndDriverBuffers: Invalid handle specified.');
            
        else
            
            error('setAppAndDriverBuffers: status code %d.\n', status);
        
        end
        
    end</MCode>
               </Code>
               <Description>setAppAndDriverBuffers(obj, channel, appBuffer, driverBuffer, bufferLength) set the application and corresponding driver buffer in the wrapper dll.

This function is required to allow the driver to copy the data into the application buffer being used in MATLAB when acquiring data from the PicoScope in streaming mode without aggregation.

Input parameters:

obj - the object representing the Streaming group.
channel - the channel to which the buffer corresponds (an enumeration from the PS4000_CHANNEL range).
appBuffer - a libpointer to a 1-D array of 16-bit integer values representing the application buffer.
driverBuffer - the libpointer passed to the driver in the ps4000SetDataBuffer function call.
bufferLength - the length of the arrays (must be equal)

Output parameters:

status - status code returned by the wrapper driver.</Description>
            </Method>
            <Method>
               <Name>setMaxMinAppAndDriverBuffers</Name>
               <Location>streaming</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function status = setMaxMinAppAndDriverBuffers(obj, channel, appMaxBuffer, appMinBuffer, driverMaxBuffer, driverMinBuffer, bufferLength)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.
    
    deviceObj = get(obj, 'Parent');
    unitHandle = deviceObj.DriverData.unitHandle;
    
    status = calllib('ps4000Wrap', 'setMaxMinAppAndDriverBuffers', ...
        unitHandle, channel, appMaxBuffer, appMinBuffer, ...
        driverMaxBuffer, driverMinBuffer, bufferLength);
    
    if(status ~= PicoStatus.PICO_OK)
       
        if(status == PicoStatus.PICO_INVALID_CHANNEL)
            
            error('setAppAndDriverBuffers: Invalid channel specified.');
                    
        elseif(status == PICO_INVALID_HANDLE)
            
            error('setMaxMinAppAndDriverBuffers: Invalid handle specified.');
            
        else
            
            error('setMaxMinAppAndDriverBuffers: status code %d.\n', status);
        
        end
        
    end</MCode>
               </Code>
               <Description>setAppAndDriverBuffers(obj, channel, appMaxBuffer, appMinBuffer, driverMaxBuffer, driverMinBuffer, bufferLength) set the maximum and minimum application and corresponding driver buffers in the wrapper dll.

This function is required to allow the driver to copy the data into the maximum and minimum application buffers being used in MATLAB when acquiring data from the PicoScope in 
streaming mode with aggregation.

Input parameters:

obj - the object representing the Streaming group.
channel - the channel to which the buffer corresponds (an enumeration from the PS4000_CHANNEL range).
appMaxBuffer - a libpointer to a 1-D array of 16-bit integer values representing the application buffer.
appMinBuffer - a libpointer to a 1-D array of 16-bit integer values representing the application buffer.
driverMaxBuffer - the libpointer passed to the driver for the maximum aggregated data values  in the ps4000SetDataBuffers function call.
driverMinBuffer - the libpointer passed to the driver for the minimum aggregated data values in the ps4000SetDataBuffers function call.
bufferLength - the length of the arrays (must be equal)

Output parameters:

status - status code returned by the wrapper driver.</Description>
            </Method>
         </MethodInfo>
      </Group>
      <Group>
         <Name>trigger</Name>
         <Description>The Trigger group contains a set of properties and functions related to the trigger functionality of the device.</Description>
         <Command/>
         <Size>1</Size>
         <Mappings>
            <ChannelMap Command="trigger" Index="1"/>
         </Mappings>
         <PropertyInfo>
            <Property>
               <Name>autoTriggerMs</Name>
               <Location>trigger</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <GetMCode>function propertyValue = getProperty(obj, propertyName)
% Return a property value.
%   This function is called to return the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    
     % If autoTriggerMs doesn't exist, create it.
    if ( ~isfield(deviceObj.DriverData, 'autoTriggerMs') )
        deviceObj.DriverData.autoTriggerMs = 0;
    end
    
    propertyValue = deviceObj.DriverData.autoTriggerMs;</GetMCode>
                  <SetMCode>function set(obj, propertyName, propertyValue)
% Set a property value.
%   This function is called to set the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    deviceObj.DriverData.autoTriggerMs = propertyValue;</SetMCode>
               </Code>
               <PermissibleType>
                  <Type>Double</Type>
                  <Constraint>none</Constraint>
               </PermissibleType>
               <DefaultValue>0</DefaultValue>
               <ReadOnly>never</ReadOnly>
               <Description>The number of milliseconds the device will wait if no trigger occurs.
</Description>
            </Property>
            <Property>
               <Name>delay</Name>
               <Location>trigger</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <GetMCode>function propertyValue = getProperty(obj, propertyName)
% Return a property value.
%   This function is called to return the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    
     % If delay doesn't exist, create it.
    if ( ~isfield(deviceObj.DriverData, 'delay') )
        deviceObj.DriverData.delay = 0;
    end
    
    propertyValue = deviceObj.DriverData.delay;</GetMCode>
                  <SetMCode>function set(obj, propertyName, propertyValue)
% Set a property value.
%   This function is called to set the device or group object property
%   value. If the property is a group property, OBJ is the group object. If
%   the property is a base device property, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    deviceObj.DriverData.delay = propertyValue;</SetMCode>
               </Code>
               <PermissibleType>
                  <Type>Double</Type>
                  <Constraint>none</Constraint>
               </PermissibleType>
               <DefaultValue>0</DefaultValue>
               <ReadOnly>never</ReadOnly>
               <Description>The time, in sample periods, between the trigger occurring and the first sample being taken.</Description>
            </Property>
         </PropertyInfo>
         <MethodInfo>
            <Method>
               <Name>ps4000HoldOff</Name>
               <Location>trigger</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function status = ps4000HoldOff(obj, samples)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    
    % Set trigger to false for channel A
    
    source = 0; % Channel A
    thresholdADC = 0;
    direction = 0;
    
    status = calllib('ps4000', 'ps4000HoldOff', ...
            deviceObj.DriverData.unitHandle, samples,  ...
            ps4000Enuminfo.enPs4000HoldOffType.PS4000_TIME);    
   
    if(status ~= PicoStatus.PICO_OK)
           
        error('ps4000HoldOff: Error code %d\n', status);
        
    end</MCode>
               </Code>
               <Description>ps4000HoldOff(obj,samples) sets the time the scopes waits after each trigger event before allowing the next trigger event.

This function may be with the Test and Measurement Tool.

Input parameters:

obj - the object representing the Trigger group.

samples - the number of samples it will wait. To get time multiply samples by the sample interval.

Output parameters:

status - status code returned by the device.

For further information on the underlying ps4000HoldOff function please refer to the PicoScope 4000 Series  PC Oscilloscopes Programmer's Guide.</Description>
            </Method>
            <Method>
               <Name>ps4000IsTriggerOrPulseWidthQualifierEnabled</Name>
               <Location>trigger</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function [status, triggerEnabled, pwqEnabled] = ps4000IsTriggerOrPulseWidthQualifierEnabled(obj)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    deviceObj = get(obj, 'Parent');

    % Allocate values for variables
    triggerEnabled = 0;
    pwqEnabled = 0;

    [status, triggerEnabled, pwqEnabled] = calllib('ps4000', ...
        'ps4000IsTriggerOrPulseWidthQualifierEnabled', ...
        deviceObj.DriverData.unitHandle, triggerEnabled, pwqEnabled);

    if(status ~= PicoStatus.PICO_OK)

        error('ps4000IsTriggerOrPulseWidthQualifierEnabled: Status code: %d. Please refer to the PicoStatus.m file.', status); 

    end</MCode>
               </Code>
               <Description>ps4000IsTriggerOrPulseWidthQualifierEnabled(obj) discovers whether a trigger, or pulse width triggering, is enabled.

This function may be used with the Test and Measurement Tool.

Input parameters:

obj - the object representing the Trigger group.

Output parameters:

status - status code returned by the device.
triggerEnabled - indicates if trigger is set.
pwqEnabled - indicates if pulse widtrh qualifier is set.

For further information on the ps4000IsTriggerOrPulseWidthQualifierEnabled function please refer to the PicoScope 4000 Series PC Oscilloscopes Programmer's Guide.</Description>
            </Method>
            <Method>
               <Name>setSimpleTrigger</Name>
               <Location>trigger</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function status = setSimpleTrigger(obj, source, thresholdMV, direction)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    
    % Find the voltage range index
    % Set default as 5V (External trigger will use this range).
    channelRange = evalin('base', 'ps4000Enuminfo.enPS4000Range.PS4000_5V');

    % Obtain information for device 
    channelSettings = deviceObj.DriverData.channelSettings;
    
    % Range is item 3 in the row for each channel

    switch(source)

        % Channel A
        case evalin('base', 'ps4000Enuminfo.enPS4000Channel.PS4000_CHANNEL_A')

            channelRange = channelSettings(1,3);

        % Channel B
        case evalin('base', 'ps4000Enuminfo.enPS4000Channel.PS4000_CHANNEL_B')

            channelRange = channelSettings(2,3);

        % Channel C
        case evalin('base', 'ps4000Enuminfo.enPS4000Channel.PS4000_CHANNEL_C')

            channelRange = channelSettings(3,3);

        % Channel D
        case evalin('base', 'ps4000Enuminfo.enPS4000Channel.PS4000_CHANNEL_D')

            channelRange = channelSettings(4,3);
        
             
        % External trigger
        case evalin('base', 'ps4000Enuminfo.enPS4000Channel.PS4000_EXTERNAL')
            
            channelRange = deviceObj.DriverData.extRange;

        otherwise

            error('setSimpleTrigger: Invalid channel specified');

    end
    
    % Obtain the range being used in milliVolts
    channelRangeMV = PicoConstants.SCOPE_INPUT_RANGES(channelRange + 1);

    % Calculate the threshold in ADC counts
    thresholdADC = mv2adc(thresholdMV, channelRangeMV, deviceObj.DriverData.maxADCValue);

    status = calllib('ps4000', 'ps4000SetSimpleTrigger', ...
            deviceObj.DriverData.unitHandle, PicoConstants.TRUE, source, ...
            thresholdADC, direction, deviceObj.DriverData.delay, ...
            deviceObj.DriverData.autoTriggerMs);
        
    if(status ~= PicoStatus.PICO_OK)
       
        error('setSimpleTrigger: Status code: %d. Please refer to the PicoStatus.m file.', status);
        
    end
</MCode>
               </Code>
               <Description>setSimpleTrigger(obj, source, thresholdMV, direction) simplifies arming the trigger. 

It supports only the LEVEL trigger types and does not allow more than one channel to have a trigger applied to it.

This function may be used with the Test and Measurement Tool.

Input parameters:

obj - the object representing the Trigger group.
source - the channel on which to trigger.
thresholdMV - the level at which the trigger will fire (in millivolts).
direction - the direction in which the signal must move to cause a trigger.

Output parameters:

status - status code returned by the driver.

For further information on the ps4000SetSimpleTrigger function please refer to the PicoScope 4000 Series PC Oscilloscopes Programmer's Guide.</Description>
            </Method>
            <Method>
               <Name>setTriggerOff</Name>
               <Location>trigger</Location>
               <CapabilityGroup>Base</CapabilityGroup>
               <Type>MCode</Type>
               <Code>
                  <MCode>function status = setTriggerOff(obj)
% For group functions, OBJ is the group object. For
% base device functions, OBJ is the device object.

    deviceObj = get(obj, 'Parent');
    
    % Set trigger to false for channel A
    
    source = 0; % Channel A
    thresholdADC = 0;
    direction = 0;
    
    status = calllib('ps4000', 'ps4000SetSimpleTrigger', ...
            deviceObj.DriverData.unitHandle, PicoConstants.FALSE, source, ...
            thresholdADC, direction, deviceObj.DriverData.delay, ...
            deviceObj.DriverData.autoTriggerMs);
    
    %status = calllib('ps4000', 'ps4000SetTriggerChannelConditions', ...
    %    get(obj, 'unitHandle'), [], 0);
    
    if(status ~= PicoStatus.PICO_OK)
           
        error('setTriggerOff: Error code %d\n', status);
        
    end</MCode>
               </Code>
               <Description>setTriggerOff(obj) switches off triggering on the oscilloscope.

This function may be with the Test and Measurement Tool.

Input parameters:

obj - the object representing the Trigger group.

Output parameters:

status - status code returned by the device.

For further information on the underlying ps4000SetSimpleTrigger function please refer to the PicoScope 4000 Series  PC Oscilloscopes Programmer's Guide.</Description>
            </Method>
         </MethodInfo>
      </Group>
   </GroupInfo>
</MATLABInstrumentDriver>