libtiepie.h

Go to the documentation of this file.

#ifndef _LIBTIEPIE_H_
#define _LIBTIEPIE_H_

// This section tries to define the C99 stdint types by detecting the used compiler/C version:
#if ( defined( __STDC_VERSION__ ) && __STDC_VERSION__ >= 199901L ) || ( defined( __GNUC__ ) && defined( __cplusplus ) )
  #include <stdint.h>
#elif defined( INCLUDED_BY_MATLAB ) // MathWorks Matlab, see libtiepiematlab.h
  #include <tmwtypes.h>

  // Define types:
  typedef INT8_T  int8_t;
  typedef INT16_T int16_t;
  typedef INT32_T int32_t;
  typedef INT64_T int64_t;

  typedef UINT8_T  uint8_t;
  typedef UINT16_T uint16_t;
  typedef UINT32_T uint32_t;
  typedef UINT64_T uint64_t;
#elif defined( _CVI_ ) // National Instruments LabWindows/CVI
  #ifdef _CVI_C99_EXTENSIONS_
    #include <stdint.h>
  #else
    // Define types:
    typedef char    int8_t;
    typedef short   int16_t;
    typedef int     int32_t;
    typedef __int64 int64_t;

    typedef unsigned char    uint8_t;
    typedef unsigned short   uint16_t;
    typedef unsigned int     uint32_t;
    typedef unsigned __int64 uint64_t;
  #endif

  #ifdef _NI_linux_
    #define __linux__
  #endif
#elif defined( _MSC_VER )
  #include "stdint.h" // Note: You can find a stdint.h for microsoft compilers at http://msinttypes.googlecode.com/svn/trunk/stdint.h .
#else
  #error "C99 stdint types not defined!"
#endif

// Check whether we are on a Windows NT based operating system:
#if defined( _WIN32 ) || defined( _WIN64 ) || defined( __WIN32__ ) || defined( __TOS_WIN__ ) || defined( __WINDOWS__ )
  #ifndef HAVE_WINDOWS_H
    #define HAVE_WINDOWS_H
  #endif
  #include <windows.h>
#endif

#ifdef __cplusplus
extern "C"
{
#endif

#define LIBTIEPIE_VERSION_MAJOR    0
#define LIBTIEPIE_VERSION_MINOR    4
#define LIBTIEPIE_VERSION_RELEASE  3

#define ARN_COUNT  3 


#define ARB_DISABLED    0
#define ARB_NATIVEONLY  1
#define ARB_ALL         2

#define ARM_NONE  0
#define ARM_ALL   ( ( 1 << ARN_COUNT ) - 1 )

#define AR_UNKNOWN     0 

#define AR_DISABLED    ( 1 << ARB_DISABLED )   
#define AR_NATIVEONLY  ( 1 << ARB_NATIVEONLY ) 
#define AR_ALL         ( 1 << ARB_ALL )        


#define BMN_COUNT  3 


#define BMB_DISABLED       0
#define BMB_COUNT          1
#define BMB_GATED_PERIODS  2

#define BM_UNKNOWN  0

#define BM_DISABLED       ( 1 << BMB_DISABLED )
#define BM_COUNT          ( 1 << BMB_COUNT  )
#define BM_GATED_PERIODS  ( 1 << BMB_GATED_PERIODS    )

#define BMM_NONE  0x0000000000000000ULL
#define BMM_ALL   ( ( 1ULL << BMN_COUNT ) - 1 )

#define CKN_COUNT  5 


#define CKB_DCV    0  
#define CKB_ACV    1  
#define CKB_DCA    2  
#define CKB_ACA    3  
#define CKB_OHM    4  


#define CK_UNKNOWN 0                  

#define CK_DCV     ( 1 << CKB_DCV )   
#define CK_ACV     ( 1 << CKB_ACV )   
#define CK_DCA     ( 1 << CKB_DCA )   
#define CK_ACA     ( 1 << CKB_ACA )   
#define CK_OHM     ( 1 << CKB_OHM )   


#define CKM_V     ( CK_DCV | CK_ACV ) 
#define CKM_A     ( CK_DCA | CK_ACA ) 
#define CKM_OHM   ( CK_OHM )          

#define CKM_ASYMMETRICRANGE ( CKM_OHM )       
#define CKM_SYMMETRICRANGE  ( CKM_V | CKM_A ) 


#define CON_COUNT  2 


#define COB_SAMPLE  0 
#define COB_10MHZ   1 


#define CO_NONE      0                   
#define CO_SAMPLE    ( 1 << COB_SAMPLE ) 
#define CO_10MHZ     ( 1 << COB_10MHZ )  


#define CSN_COUNT  2 


#define CSB_EXTERNAL  0 
#define CSB_INTERNAL  1 


#define CS_EXTERNAL  ( 1 << CSB_EXTERNAL )  
#define CS_INTERNAL  ( 1 << CSB_INTERNAL )  


#define FMN_COUNT  2 


#define FMB_SIGNALFREQUENCY  0
#define FMB_SAMPLEFREQUENCY  1

#define FM_UNKNOWN 0x00000000

#define FM_SIGNALFREQUENCY  ( 1 << FMB_SIGNALFREQUENCY )
#define FM_SAMPLEFREQUENCY  ( 1 << FMB_SAMPLEFREQUENCY )

#define FMM_NONE  0x00000000
#define FMM_ALL   ( ( 1 << FMN_COUNT ) - 1 )

#define MMN_COUNT  2 


#define MMB_STREAM 0 
#define MMB_BLOCK  1 


#define MM_UNKNOWN 0                   

#define MM_STREAM  ( 1 << MMB_STREAM ) 
#define MM_BLOCK   ( 1 << MMB_BLOCK  ) 


#define STN_COUNT  6 


#define STB_SINE       0
#define STB_TRIANGLE   1
#define STB_SQUARE     2
#define STB_DC         3
#define STB_NOISE      4
#define STB_ARBITRARY  5

#define ST_UNKNOWN     0

#define ST_SINE        ( 1 << STB_SINE )
#define ST_TRIANGLE    ( 1 << STB_TRIANGLE )
#define ST_SQUARE      ( 1 << STB_SQUARE )
#define ST_DC          ( 1 << STB_DC )
#define ST_NOISE       ( 1 << STB_NOISE )
#define ST_ARBITRARY   ( 1 << STB_ARBITRARY )

#define STM_AMPLITUDE  ( ST_SINE | ST_TRIANGLE | ST_SQUARE         | ST_NOISE | ST_ARBITRARY )
#define STM_OFFSET     ( ST_SINE | ST_TRIANGLE | ST_SQUARE | ST_DC | ST_NOISE | ST_ARBITRARY )
#define STM_FREQUENCY  ( ST_SINE | ST_TRIANGLE | ST_SQUARE         | ST_NOISE | ST_ARBITRARY )
#define STM_PHASE      ( ST_SINE | ST_TRIANGLE | ST_SQUARE                    | ST_ARBITRARY )
#define STM_SYMMETRY   ( ST_SINE | ST_TRIANGLE | ST_SQUARE                                   )
#define STM_DATALENGTH (                                                        ST_ARBITRARY )
#define STM_DATA       (                                                        ST_ARBITRARY )

#define TCN_COUNT  2 


#define TCB_GREATER  0
#define TCB_LESS     1

#define TC_UNKNOWN   0

#define TC_GREATER   ( 1 << TCB_GREATER )
#define TC_LESS      ( 1 << TCB_LESS )

#define TCM_NONE  0 
#define TCM_ALL   ( ( 1 << TCN_COUNT ) - 1 ) 


#define TH_ALLPRESAMPLES 0xffffffffffffffffULL 


#define TKN_COUNT  9 


#define TKB_RISINGEDGE          0
#define TKB_FALLINGEDGE         1
#define TKB_INWINDOW            2
#define TKB_OUTWINDOW           3
#define TKB_ANYEDGE             4
#define TKB_ENTERWINDOW         5
#define TKB_EXITWINDOW          6
#define TKB_PULSEWIDTHPOSITIVE  7
#define TKB_PULSEWIDTHNEGATIVE  8

#define TKB_RISING         TKB_RISINGEDGE
#define TKB_FALLING        TKB_FALLINGEDGE
#define TKB_EDGE           TKB_ANYEDGE
#define TKB_DROPINWINDOW   TKB_ENTERWINDOW
#define TKB_DROPOUTWINDOW  TKB_EXITWINDOW


#define TK_UNKNOWN            0                                   
#define TK_RISINGEDGE         ( 1ULL << TKB_RISINGEDGE )          
#define TK_FALLINGEDGE        ( 1ULL << TKB_FALLINGEDGE )         
#define TK_INWINDOW           ( 1ULL << TKB_INWINDOW )            
#define TK_OUTWINDOW          ( 1ULL << TKB_OUTWINDOW )           
#define TK_ANYEDGE            ( 1ULL << TKB_ANYEDGE )             
#define TK_ENTERWINDOW        ( 1ULL << TKB_ENTERWINDOW )         
#define TK_EXITWINDOW         ( 1ULL << TKB_EXITWINDOW )          
#define TK_PULSEWIDTHPOSITIVE ( 1ULL << TKB_PULSEWIDTHPOSITIVE )  
#define TK_PULSEWIDTHNEGATIVE ( 1ULL << TKB_PULSEWIDTHNEGATIVE )  


#define TK_RISING         TK_RISINGEDGE
#define TK_FALLING        TK_FALLINGEDGE
#define TK_EDGE           TK_ANYEDGE
#define TK_DROPINWINDOW   TK_ENTERWINDOW
#define TK_DROPOUTWINDOW  TK_EXITWINDOW


#define TKM_NONE             0 
#define TKM_EDGE             ( TK_RISINGEDGE | TK_FALLINGEDGE | TK_ANYEDGE ) 
#define TKM_WINDOW           ( TK_INWINDOW | TK_OUTWINDOW | TK_ENTERWINDOW | TK_EXITWINDOW ) 
#define TKM_PULSEWIDTH       ( TK_PULSEWIDTHPOSITIVE | TK_PULSEWIDTHNEGATIVE ) 
#define TKM_ALL              ( ( 1ULL << TKN_COUNT ) - 1 ) 


#define TO_INFINITY -1 


#define TOEN_COUNT  3 


#define TOEB_GENERATOR_START      0
#define TOEB_GENERATOR_STOP       1
#define TOEB_GENERATOR_NEWPERIOD  2

#define TOE_UNKNOWN              0
#define TOE_GENERATOR_START      ( 1 << TOEB_GENERATOR_START )
#define TOE_GENERATOR_STOP       ( 1 << TOEB_GENERATOR_STOP )
#define TOE_GENERATOR_NEWPERIOD  ( 1 << TOEB_GENERATOR_NEWPERIOD )

#define TOEM_NONE             0 
#define TOEM_GENERATOR        ( TOE_GENERATOR_START | TOE_GENERATOR_STOP | TOE_GENERATOR_NEWPERIOD ) 
#define TOEM_ALL              ( ( 1ULL << TOEN_COUNT ) - 1 ) 


#define TSN_CHANNEL_COUNT    32                    

#define TS_NONE              0x0000000000000000ULL 

#define TS_CH1               0x0000000000000001ULL 
#define TS_CH2               0x0000000000000002ULL 
#define TS_CH3               0x0000000000000004ULL 
#define TS_CH4               0x0000000000000008ULL 
#define TS_CH5               0x0000000000000010ULL 
#define TS_CH6               0x0000000000000020ULL 
#define TS_CH7               0x0000000000000040ULL 
#define TS_CH8               0x0000000000000080ULL 
#define TS_CH9               0x0000000000000100ULL 
#define TS_CH10              0x0000000000000200ULL 
#define TS_CH11              0x0000000000000400ULL 
#define TS_CH12              0x0000000000000800ULL 
#define TS_CH13              0x0000000000001000ULL 
#define TS_CH14              0x0000000000002000ULL 
#define TS_CH15              0x0000000000004000ULL 
#define TS_CH16              0x0000000000008000ULL 
#define TS_CH17              0x0000000000010000ULL 
#define TS_CH18              0x0000000000020000ULL 
#define TS_CH19              0x0000000000040000ULL 
#define TS_CH20              0x0000000000080000ULL 
#define TS_CH21              0x0000000000100000ULL 
#define TS_CH22              0x0000000000200000ULL 
#define TS_CH23              0x0000000000400000ULL 
#define TS_CH24              0x0000000000800000ULL 
#define TS_CH25              0x0000000001000000ULL 
#define TS_CH26              0x0000000002000000ULL 
#define TS_CH27              0x0000000004000000ULL 
#define TS_CH28              0x0000000008000000ULL 
#define TS_CH29              0x0000000010000000ULL 
#define TS_CH30              0x0000000020000000ULL 
#define TS_CH31              0x0000000040000000ULL 
#define TS_CH32              0x0000000080000000ULL 

#define TS_GENSTOP           0x0400000000000000ULL 
#define TS_GENNEW            0x0800000000000000ULL 
#define TS_GENSTART          0x1000000000000000ULL 
#define TS_EXT2              0x2000000000000000ULL 
#define TS_EXTANALOG         0x4000000000000000ULL 
#define TS_EXT               0x8000000000000000ULL 


#define TSM_NONE             0x0000000000000000ULL 
#define TSM_ALL              0xFFFFFFFFFFFFFFFFULL 
#define TSM_CHANNELS         ( ( 1ULL << TSN_CHANNEL_COUNT ) - 1 ) 
#define TSM_NONCHANNELS      ( TSM_ALL - TSM_CHANNELS ) 
#define TSM_GENALL           ( TS_GENSTART | TS_GENNEW | TS_GENSTOP ) 


#define PID_NONE    0 
#define PID_COMBI   2 

#define PID_HS5    22 


#ifdef INCLUDED_BY_MATLAB
typedef void* TpCallback_t;
#else
typedef void(*TpCallback_t)( void* pData );
#endif

#define TPDEVICEHANDLE_INVALID 0 


#define DEVICETYPE_OSCILLOSCOPE  0x00000001 
#define DEVICETYPE_GENERATOR     0x00000002 
#define DEVICETYPE_I2CHOST       0x00000004 


#define IDKIND_DEVICEID     0x00000001 
#define IDKIND_INDEX        0x00000002 
#define IDKIND_SERIALNUMBER 0x00000004 


#define LIBTIEPIESTATUS_SUCCESS                                  0 
#define LIBTIEPIESTATUS_VALUE_CLIPPED                            1 
#define LIBTIEPIESTATUS_VALUE_MODIFIED                           2 
#define LIBTIEPIESTATUS_UNSUCCESSFUL                            -1 
#define LIBTIEPIESTATUS_NOT_SUPPORTED                           -2 
#define LIBTIEPIESTATUS_INVALID_HANDLE                          -3 
#define LIBTIEPIESTATUS_INVALID_VALUE                           -4 
#define LIBTIEPIESTATUS_INVALID_CHANNEL                         -5 
#define LIBTIEPIESTATUS_INVALID_TRIGGER_SOURCE                  -6 
#define LIBTIEPIESTATUS_INVALID_DEVICE_TYPE                     -7 
#define LIBTIEPIESTATUS_INVALID_DEVICE_INDEX                    -8 
#define LIBTIEPIESTATUS_INVALID_DEVICE_ID                       -9 
#define LIBTIEPIESTATUS_INVALID_DEVICE_SERIALNUMBER            -10 
#define LIBTIEPIESTATUS_DEVICE_GONE                            -11 
#define LIBTIEPIESTATUS_INTERNAL_ADDRESS                       -12 
#define LIBTIEPIESTATUS_NOT_CONTROLLABLE                       -13 
#define LIBTIEPIESTATUS_BIT_ERROR                              -14 
#define LIBTIEPIESTATUS_NO_ACKNOWLEDGE                         -15 
#define LIBTIEPIESTATUS_INVALID_CONTAINED_DEVICE_SERIALNUMBER  -16 
#define LIBTIEPIESTATUS_INVALID_INPUT                          -17 
#define LIBTIEPIESTATUS_INVALID_OUTPUT                         -18 
#define LIBTIEPIESTATUS_INVALID_DRIVER                         -19 


#define CONNECTORTYPE_UNKNOWN  0x00000000

#define CONNECTORTYPE_BNC        0x00000001
#define CONNECTORTYPE_BANANA     0x00000002
#define CONNECTORTYPE_POWERPLUG  0x00000004

#define CONNECTORTYPE_MASK  ( CONNECTORTYPE_BNC | CONNECTORTYPE_BANANA | CONNECTORTYPE_POWERPLUG )

#define DATARAWTYPE_UNKNOWN  0x00000000

#define DATARAWTYPE_INT8     0x00000001 
#define DATARAWTYPE_INT16    0x00000002 
#define DATARAWTYPE_INT32    0x00000004 
#define DATARAWTYPE_INT64    0x00000008 

#define DATARAWTYPE_UINT8    0x00000010 
#define DATARAWTYPE_UINT16   0x00000020 
#define DATARAWTYPE_UINT32   0x00000040 
#define DATARAWTYPE_UINT64   0x00000080 

#define DATARAWTYPE_FLOAT32  0x00000100 
#define DATARAWTYPE_FLOAT64  0x00000200 


#define DATARAWTYPE_MASK_INT   ( DATARAWTYPE_INT8     | DATARAWTYPE_INT16     | DATARAWTYPE_INT32  | DATARAWTYPE_INT64  )
#define DATARAWTYPE_MASK_UINT  ( DATARAWTYPE_UINT8    | DATARAWTYPE_UINT16    | DATARAWTYPE_UINT32 | DATARAWTYPE_UINT64 )
#define DATARAWTYPE_MASK_FLOAT ( DATARAWTYPE_FLOAT32  | DATARAWTYPE_FLOAT64   )
#define DATARAWTYPE_MASK_FIXED ( DATARAWTYPE_MASK_INT | DATARAWTYPE_MASK_UINT )

#define IDM_DEVICEID 0x80000000
#define IDM_ALL      0xffffffff

#define IDB_HS3    0
#define IDB_HS4    1
#define IDB_HS4D   2
#define IDB_HS805  3
#define IDB_HP3    4
#define IDB_HS5    5
#define IDB_HL0516 6
#define IDB_PA1    7
#define IDB_COMBI  8

#define ID_HS3    ( IDM_DEVICEID | ( 1 << IDB_HS3 ) )    
#define ID_HS4    ( IDM_DEVICEID | ( 1 << IDB_HS4 ) )    
#define ID_HS4D   ( IDM_DEVICEID | ( 1 << IDB_HS4D ) )   
#define ID_HS805  ( IDM_DEVICEID | ( 1 << IDB_HS805 ) )  
#define ID_HP3    ( IDM_DEVICEID | ( 1 << IDB_HP3 ) )    
#define ID_HS5    ( IDM_DEVICEID | ( 1 << IDB_HS5 ) )    
#define ID_HL0516 ( IDM_DEVICEID | ( 1 << IDB_HL0516 ) ) 
#define ID_PA1    ( IDM_DEVICEID | ( 1 << IDB_PA1 ) )    
#define ID_COMBI  ( IDM_DEVICEID | ( 1 << IDB_COMBI ) )  


#define BOOL8_FALSE 0
#define BOOL8_TRUE  1

#define LIBTIEPIE_TRISTATE_UNDEFINED 0 
#define LIBTIEPIE_TRISTATE_FALSE     1 
#define LIBTIEPIE_TRISTATE_TRUE      2 




#define LIBTIEPIE_RANGEINDEX_AUTO  0xffffffff 




typedef int32_t  LibTiePieStatus_t;       
typedef uint32_t TpDeviceHandle_t;        
typedef uint64_t TpVersion_t;             
typedef uint32_t TpDate_t;                
typedef uint8_t  bool8_t;                 
typedef uint8_t  LibTiePieTriState_t;     
typedef void**   LibTiePiePointerArray_t; 

#define TPVERSION_MAJOR( x )    ( x >> 48 )               
#define TPVERSION_MINOR( x )    ( ( x >> 32 ) & 0xffff )  
#define TPVERSION_RELEASE( x )  ( ( x >> 16 ) & 0xffff )  
#define TPVERSION_BUILD( x )    ( x & 0xffff )            

#define TPDATE_YEAR( x )  ( x >> 16 )            
#define TPDATE_MONTH( x ) ( ( x >> 8 ) & 0xff )  
#define TPDATE_DAY( x )   ( x & 0xff )           


#ifdef HAVE_WINDOWS_H

#define WM_LIBTIEPIE                              ( WM_USER + 1337 ) 

#define WM_LIBTIEPIE_LST_DEVICEADDED              ( WM_LIBTIEPIE + 2 ) 
#define WM_LIBTIEPIE_LST_DEVICEREMOVED            ( WM_LIBTIEPIE + 3 ) 

#define WM_LIBTIEPIE_DEV_REMOVED                  ( WM_LIBTIEPIE + 4 ) 

#define WM_LIBTIEPIE_SCP_DATAREADY                ( WM_LIBTIEPIE + 0 ) 
#define WM_LIBTIEPIE_SCP_DATAOVERFLOW             ( WM_LIBTIEPIE + 1 ) 
#define WM_LIBTIEPIE_SCP_CONNECTIONTESTCOMPLETED  ( WM_LIBTIEPIE + 7 ) 

#define WM_LIBTIEPIE_GEN_BURSTCOMPLETED           ( WM_LIBTIEPIE + 5 ) 
#define WM_LIBTIEPIE_GEN_CONTROLLABLECHANGED      ( WM_LIBTIEPIE + 6 ) 


#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef TpVersion_t(*LibTiePieLibGetVersion_t)( void );
#else
TpVersion_t LibGetVersion( void );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieLibGetConfig_t)( uint8_t* pBuffer , uint32_t dwBufferLength );
#else
uint32_t LibGetConfig( uint8_t* pBuffer , uint32_t dwBufferLength );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef LibTiePieStatus_t(*LibTiePieLibGetLastStatus_t)( void );
#else
LibTiePieStatus_t LibGetLastStatus( void );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef const char*(*LibTiePieLibGetLastStatusStr_t)( void );
#else
const char* LibGetLastStatusStr( void );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieLstGetCount_t)( void );
#else
uint32_t LstGetCount( void );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieLstGetDeviceCanOpen_t)( uint32_t dwIdKind , uint32_t dwId , uint32_t dwDeviceType );
#else
bool8_t LstGetDeviceCanOpen( uint32_t dwIdKind , uint32_t dwId , uint32_t dwDeviceType );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieLstGetDeviceProductId_t)( uint32_t dwIdKind , uint32_t dwId );
#else
uint32_t LstGetDeviceProductId( uint32_t dwIdKind , uint32_t dwId );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieLstGetDeviceVendorId_t)( uint32_t dwIdKind , uint32_t dwId );
#else
uint32_t LstGetDeviceVendorId( uint32_t dwIdKind , uint32_t dwId );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieLstGetDeviceName_t)( uint32_t dwIdKind , uint32_t dwId , char* pBuffer , uint32_t dwBufferLength );
#else
uint32_t LstGetDeviceName( uint32_t dwIdKind , uint32_t dwId , char* pBuffer , uint32_t dwBufferLength );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieLstGetDeviceNameShort_t)( uint32_t dwIdKind , uint32_t dwId , char* pBuffer , uint32_t dwBufferLength );
#else
uint32_t LstGetDeviceNameShort( uint32_t dwIdKind , uint32_t dwId , char* pBuffer , uint32_t dwBufferLength );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef TpVersion_t(*LibTiePieLstDevGetDriverVersion_t)( uint32_t dwIdKind , uint32_t dwId );
#else
TpVersion_t LstDevGetDriverVersion( uint32_t dwIdKind , uint32_t dwId );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef TpVersion_t(*LibTiePieLstDevGetRecommendedDriverVersion_t)( uint32_t dwIdKind , uint32_t dwId );
#else
TpVersion_t LstDevGetRecommendedDriverVersion( uint32_t dwIdKind , uint32_t dwId );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef TpVersion_t(*LibTiePieLstDevGetFirmwareVersion_t)( uint32_t dwIdKind , uint32_t dwId );
#else
TpVersion_t LstDevGetFirmwareVersion( uint32_t dwIdKind , uint32_t dwId );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef TpDate_t(*LibTiePieLstDevGetCalibrationDate_t)( uint32_t dwIdKind , uint32_t dwId );
#else
TpDate_t LstDevGetCalibrationDate( uint32_t dwIdKind , uint32_t dwId );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieLstGetDeviceSerialNumber_t)( uint32_t dwIdKind , uint32_t dwId );
#else
uint32_t LstGetDeviceSerialNumber( uint32_t dwIdKind , uint32_t dwId );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieLstGetDeviceTypes_t)( uint32_t dwIdKind , uint32_t dwId );
#else
uint32_t LstGetDeviceTypes( uint32_t dwIdKind , uint32_t dwId );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef TpDeviceHandle_t(*LibTiePieLstOpenDevice_t)( uint32_t dwIdKind , uint32_t dwId , uint32_t dwDeviceType );
#else
TpDeviceHandle_t LstOpenDevice( uint32_t dwIdKind , uint32_t dwId , uint32_t dwDeviceType );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef TpDeviceHandle_t(*LibTiePieLstOpenOscilloscope_t)( uint32_t dwIdKind , uint32_t dwId );
#else
TpDeviceHandle_t LstOpenOscilloscope( uint32_t dwIdKind , uint32_t dwId );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef TpDeviceHandle_t(*LibTiePieLstOpenGenerator_t)( uint32_t dwIdKind , uint32_t dwId );
#else
TpDeviceHandle_t LstOpenGenerator( uint32_t dwIdKind , uint32_t dwId );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef TpDeviceHandle_t(*LibTiePieLstOpenI2CHost_t)( uint32_t dwIdKind , uint32_t dwId );
#else
TpDeviceHandle_t LstOpenI2CHost( uint32_t dwIdKind , uint32_t dwId );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieLstRemoveDevice_t)( uint32_t dwSerialNumber );
#else
void LstRemoveDevice( uint32_t dwSerialNumber );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieLstUpdate_t)( uint32_t dwDeviceIdMask );
#else
void LstUpdate( uint32_t dwDeviceIdMask );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieLstDevGetContainedSerialNumbers_t)( uint32_t dwIdKind , uint32_t dwId , uint32_t* pBuffer , uint32_t dwBufferLength );
#else
uint32_t LstDevGetContainedSerialNumbers( uint32_t dwIdKind , uint32_t dwId , uint32_t* pBuffer , uint32_t dwBufferLength );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieLstCbDevGetProductId_t)( uint32_t dwIdKind , uint32_t dwId , uint32_t dwContainedDeviceSerialNumber );
#else
uint32_t LstCbDevGetProductId( uint32_t dwIdKind , uint32_t dwId , uint32_t dwContainedDeviceSerialNumber );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieLstCbDevGetVendorId_t)( uint32_t dwIdKind , uint32_t dwId , uint32_t dwContainedDeviceSerialNumber );
#else
uint32_t LstCbDevGetVendorId( uint32_t dwIdKind , uint32_t dwId , uint32_t dwContainedDeviceSerialNumber );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieLstCbDevGetName_t)( uint32_t dwIdKind , uint32_t dwId , uint32_t dwContainedDeviceSerialNumber , char* pBuffer , uint32_t dwBufferLength );
#else
uint32_t LstCbDevGetName( uint32_t dwIdKind , uint32_t dwId , uint32_t dwContainedDeviceSerialNumber , char* pBuffer , uint32_t dwBufferLength );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieLstCbDevGetNameShort_t)( uint32_t dwIdKind , uint32_t dwId , uint32_t dwContainedDeviceSerialNumber , char* pBuffer , uint32_t dwBufferLength );
#else
uint32_t LstCbDevGetNameShort( uint32_t dwIdKind , uint32_t dwId , uint32_t dwContainedDeviceSerialNumber , char* pBuffer , uint32_t dwBufferLength );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef TpVersion_t(*LibTiePieLstCbDevGetDriverVersion_t)( uint32_t dwIdKind , uint32_t dwId , uint32_t dwContainedDeviceSerialNumber );
#else
TpVersion_t LstCbDevGetDriverVersion( uint32_t dwIdKind , uint32_t dwId , uint32_t dwContainedDeviceSerialNumber );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef TpVersion_t(*LibTiePieLstCbDevGetFirmwareVersion_t)( uint32_t dwIdKind , uint32_t dwId , uint32_t dwContainedDeviceSerialNumber );
#else
TpVersion_t LstCbDevGetFirmwareVersion( uint32_t dwIdKind , uint32_t dwId , uint32_t dwContainedDeviceSerialNumber );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef TpDate_t(*LibTiePieLstCbDevGetCalibrationDate_t)( uint32_t dwIdKind , uint32_t dwId , uint32_t dwContainedDeviceSerialNumber );
#else
TpDate_t LstCbDevGetCalibrationDate( uint32_t dwIdKind , uint32_t dwId , uint32_t dwContainedDeviceSerialNumber );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint16_t(*LibTiePieLstCbScpGetChannelCount_t)( uint32_t dwIdKind , uint32_t dwId , uint32_t dwContainedDeviceSerialNumber );
#else
uint16_t LstCbScpGetChannelCount( uint32_t dwIdKind , uint32_t dwId , uint32_t dwContainedDeviceSerialNumber );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieLstSetCallbackDeviceAdded_t)( TpCallback_t pCallback , void* pData );
#else
void LstSetCallbackDeviceAdded( TpCallback_t pCallback , void* pData );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieLstSetCallbackDeviceRemoved_t)( TpCallback_t pCallback , void* pData );
#else
void LstSetCallbackDeviceRemoved( TpCallback_t pCallback , void* pData );
#endif

#ifdef __linux__

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieLstSetEventDeviceAdded_t)( int fdEvent );
#else
void LstSetEventDeviceAdded( int fdEvent );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieLstSetEventDeviceRemoved_t)( int fdEvent );
#else
void LstSetEventDeviceRemoved( int fdEvent );
#endif

#endif

#ifdef HAVE_WINDOWS_H

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieLstSetEventDeviceAdded_t)( HANDLE hEvent );
#else
void LstSetEventDeviceAdded( HANDLE hEvent );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieLstSetEventDeviceRemoved_t)( HANDLE hEvent );
#else
void LstSetEventDeviceRemoved( HANDLE hEvent );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieLstSetMessageDeviceAdded_t)( HWND hWnd );
#else
void LstSetMessageDeviceAdded( HWND hWnd );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieLstSetMessageDeviceRemoved_t)( HWND hWnd );
#else
void LstSetMessageDeviceRemoved( HWND hWnd );
#endif

#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieDevClose_t)( TpDeviceHandle_t hDevice );
#else
void DevClose( TpDeviceHandle_t hDevice );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieDevIsRemoved_t)( TpDeviceHandle_t hDevice );
#else
bool8_t DevIsRemoved( TpDeviceHandle_t hDevice );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef TpVersion_t(*LibTiePieDevGetDriverVersion_t)( TpDeviceHandle_t hDevice );
#else
TpVersion_t DevGetDriverVersion( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef TpVersion_t(*LibTiePieDevGetFirmwareVersion_t)( TpDeviceHandle_t hDevice );
#else
TpVersion_t DevGetFirmwareVersion( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef TpDate_t(*LibTiePieDevGetCalibrationDate_t)( TpDeviceHandle_t hDevice );
#else
TpDate_t DevGetCalibrationDate( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieDevGetSerialNumber_t)( TpDeviceHandle_t hDevice );
#else
uint32_t DevGetSerialNumber( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieDevGetProductId_t)( TpDeviceHandle_t hDevice );
#else
uint32_t DevGetProductId( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieDevGetVendorId_t)( TpDeviceHandle_t hDevice );
#else
uint32_t DevGetVendorId( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieDevGetType_t)( TpDeviceHandle_t hDevice );
#else
uint32_t DevGetType( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieDevGetName_t)( TpDeviceHandle_t hDevice , char* pBuffer , uint32_t dwBufferLength );
#else
uint32_t DevGetName( TpDeviceHandle_t hDevice , char* pBuffer , uint32_t dwBufferLength );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieDevGetNameShort_t)( TpDeviceHandle_t hDevice , char* pBuffer , uint32_t dwBufferLength );
#else
uint32_t DevGetNameShort( TpDeviceHandle_t hDevice , char* pBuffer , uint32_t dwBufferLength );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieDevSetCallbackRemoved_t)( TpDeviceHandle_t hDevice , TpCallback_t pCallback , void* pData );
#else
void DevSetCallbackRemoved( TpDeviceHandle_t hDevice , TpCallback_t pCallback , void* pData );
#endif

#ifdef __linux__

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieDevSetEventRemoved_t)( TpDeviceHandle_t hDevice , int fdEvent );
#else
void DevSetEventRemoved( TpDeviceHandle_t hDevice , int fdEvent );
#endif

#endif

#ifdef HAVE_WINDOWS_H

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieDevSetEventRemoved_t)( TpDeviceHandle_t hDevice , HANDLE hEvent );
#else
void DevSetEventRemoved( TpDeviceHandle_t hDevice , HANDLE hEvent );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieDevSetMessageRemoved_t)( TpDeviceHandle_t hDevice , HWND hWnd , WPARAM wParam , LPARAM lParam );
#else
void DevSetMessageRemoved( TpDeviceHandle_t hDevice , HWND hWnd , WPARAM wParam , LPARAM lParam );
#endif

#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef uint16_t(*LibTiePieDevTrGetInputCount_t)( TpDeviceHandle_t hDevice );
#else
uint16_t DevTrGetInputCount( TpDeviceHandle_t hDevice );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieDevTrInGetEnabled_t)( TpDeviceHandle_t hDevice , uint16_t wInput );
#else
bool8_t DevTrInGetEnabled( TpDeviceHandle_t hDevice , uint16_t wInput );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieDevTrInSetEnabled_t)( TpDeviceHandle_t hDevice , uint16_t wInput , bool8_t bEnable );
#else
bool8_t DevTrInSetEnabled( TpDeviceHandle_t hDevice , uint16_t wInput , bool8_t bEnable );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieDevTrInGetKinds_t)( TpDeviceHandle_t hDevice , uint16_t wInput );
#else
uint64_t DevTrInGetKinds( TpDeviceHandle_t hDevice , uint16_t wInput );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieDevTrInGetKind_t)( TpDeviceHandle_t hDevice , uint16_t wInput );
#else
uint64_t DevTrInGetKind( TpDeviceHandle_t hDevice , uint16_t wInput );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieDevTrInSetKind_t)( TpDeviceHandle_t hDevice , uint16_t wInput , uint64_t qwKind );
#else
uint64_t DevTrInSetKind( TpDeviceHandle_t hDevice , uint16_t wInput , uint64_t qwKind );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieDevTrInGetName_t)( TpDeviceHandle_t hDevice , uint16_t wInput , char* pBuffer , uint32_t dwBufferLength );
#else
uint32_t DevTrInGetName( TpDeviceHandle_t hDevice , uint16_t wInput , char* pBuffer , uint32_t dwBufferLength );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef uint16_t(*LibTiePieDevTrGetOutputCount_t)( TpDeviceHandle_t hDevice );
#else
uint16_t DevTrGetOutputCount( TpDeviceHandle_t hDevice );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieDevTrOutGetEnabled_t)( TpDeviceHandle_t hDevice , uint16_t wOutput );
#else
bool8_t DevTrOutGetEnabled( TpDeviceHandle_t hDevice , uint16_t wOutput );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieDevTrOutSetEnabled_t)( TpDeviceHandle_t hDevice , uint16_t wOutput , bool8_t bEnable );
#else
bool8_t DevTrOutSetEnabled( TpDeviceHandle_t hDevice , uint16_t wOutput , bool8_t bEnable );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieDevTrOutGetEvents_t)( TpDeviceHandle_t hDevice , uint16_t wOutput );
#else
uint64_t DevTrOutGetEvents( TpDeviceHandle_t hDevice , uint16_t wOutput );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieDevTrOutGetEvent_t)( TpDeviceHandle_t hDevice , uint16_t wOutput );
#else
uint64_t DevTrOutGetEvent( TpDeviceHandle_t hDevice , uint16_t wOutput );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieDevTrOutSetEvent_t)( TpDeviceHandle_t hDevice , uint16_t wOutput , uint64_t qwEvent );
#else
uint64_t DevTrOutSetEvent( TpDeviceHandle_t hDevice , uint16_t wOutput , uint64_t qwEvent );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieDevTrOutGetName_t)( TpDeviceHandle_t hDevice , uint16_t wOutput , char* pBuffer , uint32_t dwBufferLength );
#else
uint32_t DevTrOutGetName( TpDeviceHandle_t hDevice , uint16_t wOutput , char* pBuffer , uint32_t dwBufferLength );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef uint16_t(*LibTiePieScpGetChannelCount_t)( TpDeviceHandle_t hDevice );
#else
uint16_t ScpGetChannelCount( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieScpGetSharedChannelGroupCount_t)( TpDeviceHandle_t hDevice );
#else
uint32_t ScpGetSharedChannelGroupCount( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieScpGetSharedChannelGroup_t)( TpDeviceHandle_t hDevice , uint32_t dwGroupIndex , uint16_t* pChannelNumbers , uint32_t dwLength );
#else
uint32_t ScpGetSharedChannelGroup( TpDeviceHandle_t hDevice , uint32_t dwGroupIndex , uint16_t* pChannelNumbers , uint32_t dwLength );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieScpChGetConnectorType_t)( TpDeviceHandle_t hDevice , uint16_t wCh );
#else
uint32_t ScpChGetConnectorType( TpDeviceHandle_t hDevice , uint16_t wCh );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieScpChIsDifferential_t)( TpDeviceHandle_t hDevice , uint16_t wCh );
#else
bool8_t ScpChIsDifferential( TpDeviceHandle_t hDevice , uint16_t wCh );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpChGetCouplings_t)( TpDeviceHandle_t hDevice , uint16_t wCh );
#else
uint64_t ScpChGetCouplings( TpDeviceHandle_t hDevice , uint16_t wCh );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpChGetCoupling_t)( TpDeviceHandle_t hDevice , uint16_t wCh );
#else
uint64_t ScpChGetCoupling( TpDeviceHandle_t hDevice , uint16_t wCh );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpChSetCoupling_t)( TpDeviceHandle_t hDevice , uint16_t wCh , uint64_t qwCoupling );
#else
uint64_t ScpChSetCoupling( TpDeviceHandle_t hDevice , uint16_t wCh , uint64_t qwCoupling );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieScpChGetEnabled_t)( TpDeviceHandle_t hDevice , uint16_t wCh );
#else
bool8_t ScpChGetEnabled( TpDeviceHandle_t hDevice , uint16_t wCh );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieScpChSetEnabled_t)( TpDeviceHandle_t hDevice , uint16_t wCh , bool8_t bEnable );
#else
bool8_t ScpChSetEnabled( TpDeviceHandle_t hDevice , uint16_t wCh , bool8_t bEnable );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpChGetProbeGain_t)( TpDeviceHandle_t hDevice , uint16_t wCh );
#else
double ScpChGetProbeGain( TpDeviceHandle_t hDevice , uint16_t wCh );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpChSetProbeGain_t)( TpDeviceHandle_t hDevice , uint16_t wCh , double dProbeGain );
#else
double ScpChSetProbeGain( TpDeviceHandle_t hDevice , uint16_t wCh , double dProbeGain );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieScpChGetAutoRanging_t)( TpDeviceHandle_t hDevice , uint16_t wCh );
#else
bool8_t ScpChGetAutoRanging( TpDeviceHandle_t hDevice , uint16_t wCh );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieScpChSetAutoRanging_t)( TpDeviceHandle_t hDevice , uint16_t wCh , bool8_t bEnable );
#else
bool8_t ScpChSetAutoRanging( TpDeviceHandle_t hDevice , uint16_t wCh , bool8_t bEnable );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieScpChGetRanges_t)( TpDeviceHandle_t hDevice , uint16_t wCh , double* pList , uint32_t dwLength );
#else
uint32_t ScpChGetRanges( TpDeviceHandle_t hDevice , uint16_t wCh , double* pList , uint32_t dwLength );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieScpChGetRangesEx_t)( TpDeviceHandle_t hDevice , uint16_t wCh , uint64_t qwCoupling , double* pList , uint32_t dwLength );
#else
uint32_t ScpChGetRangesEx( TpDeviceHandle_t hDevice , uint16_t wCh , uint64_t qwCoupling , double* pList , uint32_t dwLength );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpChGetRange_t)( TpDeviceHandle_t hDevice , uint16_t wCh );
#else
double ScpChGetRange( TpDeviceHandle_t hDevice , uint16_t wCh );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpChSetRange_t)( TpDeviceHandle_t hDevice , uint16_t wCh , double dRange );
#else
double ScpChSetRange( TpDeviceHandle_t hDevice , uint16_t wCh , double dRange );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieScpChHasTrigger_t)( TpDeviceHandle_t hDevice , uint16_t wCh );
#else
bool8_t ScpChHasTrigger( TpDeviceHandle_t hDevice , uint16_t wCh );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieScpChTrGetEnabled_t)( TpDeviceHandle_t hDevice , uint16_t wCh );
#else
bool8_t ScpChTrGetEnabled( TpDeviceHandle_t hDevice , uint16_t wCh );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieScpChTrSetEnabled_t)( TpDeviceHandle_t hDevice , uint16_t wCh , bool8_t bEnable );
#else
bool8_t ScpChTrSetEnabled( TpDeviceHandle_t hDevice , uint16_t wCh , bool8_t bEnable );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpChTrGetKinds_t)( TpDeviceHandle_t hDevice , uint16_t wCh );
#else
uint64_t ScpChTrGetKinds( TpDeviceHandle_t hDevice , uint16_t wCh );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpChTrGetKindsEx_t)( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwMeasureMode );
#else
uint64_t ScpChTrGetKindsEx( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwMeasureMode );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpChTrGetKind_t)( TpDeviceHandle_t hDevice , uint16_t wCh );
#else
uint64_t ScpChTrGetKind( TpDeviceHandle_t hDevice , uint16_t wCh );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpChTrSetKind_t)( TpDeviceHandle_t hDevice , uint16_t wCh , uint64_t qwTriggerKind );
#else
uint64_t ScpChTrSetKind( TpDeviceHandle_t hDevice , uint16_t wCh , uint64_t qwTriggerKind );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieScpChTrGetLevelCount_t)( TpDeviceHandle_t hDevice , uint16_t wCh );
#else
uint32_t ScpChTrGetLevelCount( TpDeviceHandle_t hDevice , uint16_t wCh );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpChTrGetLevel_t)( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwIndex );
#else
double ScpChTrGetLevel( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwIndex );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpChTrSetLevel_t)( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwIndex , double dLevel );
#else
double ScpChTrSetLevel( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwIndex , double dLevel );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieScpChTrGetHysteresisCount_t)( TpDeviceHandle_t hDevice , uint16_t wCh );
#else
uint32_t ScpChTrGetHysteresisCount( TpDeviceHandle_t hDevice , uint16_t wCh );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpChTrGetHysteresis_t)( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwIndex );
#else
double ScpChTrGetHysteresis( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwIndex );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpChTrSetHysteresis_t)( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwIndex , double dHysteresis );
#else
double ScpChTrSetHysteresis( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwIndex , double dHysteresis );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieScpChTrGetConditions_t)( TpDeviceHandle_t hDevice , uint16_t wCh );
#else
uint32_t ScpChTrGetConditions( TpDeviceHandle_t hDevice , uint16_t wCh );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieScpChTrGetCondition_t)( TpDeviceHandle_t hDevice , uint16_t wCh );
#else
uint32_t ScpChTrGetCondition( TpDeviceHandle_t hDevice , uint16_t wCh );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieScpChTrSetCondition_t)( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwCondition );
#else
uint32_t ScpChTrSetCondition( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwCondition );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieScpChTrGetTimeCount_t)( TpDeviceHandle_t hDevice , uint16_t wCh );
#else
uint32_t ScpChTrGetTimeCount( TpDeviceHandle_t hDevice , uint16_t wCh );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpChTrGetTime_t)( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwIndex );
#else
double ScpChTrGetTime( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwIndex );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpChTrSetTime_t)( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwIndex , double dTime );
#else
double ScpChTrSetTime( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwIndex , double dTime );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpChTrVerifyTime_t)( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwIndex , double dTime );
#else
double ScpChTrVerifyTime( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwIndex , double dTime );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpChTrVerifyTimeEx_t)( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwIndex , double dTime , double dSampleFrequency );
#else
double ScpChTrVerifyTimeEx( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwIndex , double dTime , double dSampleFrequency );
#endif


// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef INCLUDED_BY_MATLAB
#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpGetData_t)( TpDeviceHandle_t hDevice , void** pBuffers , uint16_t wChannelCount , uint64_t qwStartIndex , uint64_t qwSampleCount );
#else
uint64_t ScpGetData( TpDeviceHandle_t hDevice , void** pBuffers , uint16_t wChannelCount , uint64_t qwStartIndex , uint64_t qwSampleCount );
#endif
#else
#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpGetData_t)( TpDeviceHandle_t hDevice , float** pBuffers , uint16_t wChannelCount , uint64_t qwStartIndex , uint64_t qwSampleCount );
#else
uint64_t ScpGetData( TpDeviceHandle_t hDevice , float** pBuffers , uint16_t wChannelCount , uint64_t qwStartIndex , uint64_t qwSampleCount );
#endif
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpGetData1Ch_t)( TpDeviceHandle_t hDevice , float* pBufferCh1 , uint64_t qwStartIndex , uint64_t qwSampleCount );
#else
uint64_t ScpGetData1Ch( TpDeviceHandle_t hDevice , float* pBufferCh1 , uint64_t qwStartIndex , uint64_t qwSampleCount );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpGetData2Ch_t)( TpDeviceHandle_t hDevice , float* pBufferCh1 , float* pBufferCh2 , uint64_t qwStartIndex , uint64_t qwSampleCount );
#else
uint64_t ScpGetData2Ch( TpDeviceHandle_t hDevice , float* pBufferCh1 , float* pBufferCh2 , uint64_t qwStartIndex , uint64_t qwSampleCount );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpGetData3Ch_t)( TpDeviceHandle_t hDevice , float* pBufferCh1 , float* pBufferCh2 , float* pBufferCh3 , uint64_t qwStartIndex , uint64_t qwSampleCount );
#else
uint64_t ScpGetData3Ch( TpDeviceHandle_t hDevice , float* pBufferCh1 , float* pBufferCh2 , float* pBufferCh3 , uint64_t qwStartIndex , uint64_t qwSampleCount );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpGetData4Ch_t)( TpDeviceHandle_t hDevice , float* pBufferCh1 , float* pBufferCh2 , float* pBufferCh3 , float* pBufferCh4 , uint64_t qwStartIndex , uint64_t qwSampleCount );
#else
uint64_t ScpGetData4Ch( TpDeviceHandle_t hDevice , float* pBufferCh1 , float* pBufferCh2 , float* pBufferCh3 , float* pBufferCh4 , uint64_t qwStartIndex , uint64_t qwSampleCount );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpGetValidPreSampleCount_t)( TpDeviceHandle_t hDevice );
#else
uint64_t ScpGetValidPreSampleCount( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieScpChGetDataValueRange_t)( TpDeviceHandle_t hDevice , uint16_t wCh , double* pMin , double* pMax );
#else
void ScpChGetDataValueRange( TpDeviceHandle_t hDevice , uint16_t wCh , double* pMin , double* pMax );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpChGetDataValueMax_t)( TpDeviceHandle_t hDevice , uint16_t wCh );
#else
double ScpChGetDataValueMax( TpDeviceHandle_t hDevice , uint16_t wCh );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpChGetDataValueMin_t)( TpDeviceHandle_t hDevice , uint16_t wCh );
#else
double ScpChGetDataValueMin( TpDeviceHandle_t hDevice , uint16_t wCh );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpGetDataRaw_t)( TpDeviceHandle_t hDevice , void** pBuffers , uint16_t wChannelCount , uint64_t qwStartIndex , uint64_t qwSampleCount );
#else
uint64_t ScpGetDataRaw( TpDeviceHandle_t hDevice , void** pBuffers , uint16_t wChannelCount , uint64_t qwStartIndex , uint64_t qwSampleCount );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpGetDataRaw1Ch_t)( TpDeviceHandle_t hDevice , void* pBufferCh1 , uint64_t qwStartIndex , uint64_t qwSampleCount );
#else
uint64_t ScpGetDataRaw1Ch( TpDeviceHandle_t hDevice , void* pBufferCh1 , uint64_t qwStartIndex , uint64_t qwSampleCount );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpGetDataRaw2Ch_t)( TpDeviceHandle_t hDevice , void* pBufferCh1 , void* pBufferCh2 , uint64_t qwStartIndex , uint64_t qwSampleCount );
#else
uint64_t ScpGetDataRaw2Ch( TpDeviceHandle_t hDevice , void* pBufferCh1 , void* pBufferCh2 , uint64_t qwStartIndex , uint64_t qwSampleCount );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpGetDataRaw3Ch_t)( TpDeviceHandle_t hDevice , void* pBufferCh1 , void* pBufferCh2 , void* pBufferCh3 , uint64_t qwStartIndex , uint64_t qwSampleCount );
#else
uint64_t ScpGetDataRaw3Ch( TpDeviceHandle_t hDevice , void* pBufferCh1 , void* pBufferCh2 , void* pBufferCh3 , uint64_t qwStartIndex , uint64_t qwSampleCount );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpGetDataRaw4Ch_t)( TpDeviceHandle_t hDevice , void* pBufferCh1 , void* pBufferCh2 , void* pBufferCh3 , void* pBufferCh4 , uint64_t qwStartIndex , uint64_t qwSampleCount );
#else
uint64_t ScpGetDataRaw4Ch( TpDeviceHandle_t hDevice , void* pBufferCh1 , void* pBufferCh2 , void* pBufferCh3 , void* pBufferCh4 , uint64_t qwStartIndex , uint64_t qwSampleCount );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieScpChGetDataRawType_t)( TpDeviceHandle_t hDevice , uint16_t wCh );
#else
uint32_t ScpChGetDataRawType( TpDeviceHandle_t hDevice , uint16_t wCh );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieScpChGetDataRawValueRange_t)( TpDeviceHandle_t hDevice , uint16_t wCh , int64_t* pMin , int64_t* pZero , int64_t* pMax );
#else
void ScpChGetDataRawValueRange( TpDeviceHandle_t hDevice , uint16_t wCh , int64_t* pMin , int64_t* pZero , int64_t* pMax );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef int64_t(*LibTiePieScpChGetDataRawValueMax_t)( TpDeviceHandle_t hDevice , uint16_t wCh );
#else
int64_t ScpChGetDataRawValueMax( TpDeviceHandle_t hDevice , uint16_t wCh );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef int64_t(*LibTiePieScpChGetDataRawValueZero_t)( TpDeviceHandle_t hDevice , uint16_t wCh );
#else
int64_t ScpChGetDataRawValueZero( TpDeviceHandle_t hDevice , uint16_t wCh );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef int64_t(*LibTiePieScpChGetDataRawValueMin_t)( TpDeviceHandle_t hDevice , uint16_t wCh );
#else
int64_t ScpChGetDataRawValueMin( TpDeviceHandle_t hDevice , uint16_t wCh );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieScpChIsRangeMaxReachable_t)( TpDeviceHandle_t hDevice , uint16_t wCh );
#else
bool8_t ScpChIsRangeMaxReachable( TpDeviceHandle_t hDevice , uint16_t wCh );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieScpSetCallbackDataReady_t)( TpDeviceHandle_t hDevice , TpCallback_t pCallback , void* pData );
#else
void ScpSetCallbackDataReady( TpDeviceHandle_t hDevice , TpCallback_t pCallback , void* pData );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieScpSetCallbackDataOverflow_t)( TpDeviceHandle_t hDevice , TpCallback_t pCallback , void* pData );
#else
void ScpSetCallbackDataOverflow( TpDeviceHandle_t hDevice , TpCallback_t pCallback , void* pData );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieScpSetCallbackConnectionTestCompleted_t)( TpDeviceHandle_t hDevice , TpCallback_t pCallback , void* pData );
#else
void ScpSetCallbackConnectionTestCompleted( TpDeviceHandle_t hDevice , TpCallback_t pCallback , void* pData );
#endif

#ifdef __linux__

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieScpSetEventDataReady_t)( TpDeviceHandle_t hDevice , int fdEvent );
#else
void ScpSetEventDataReady( TpDeviceHandle_t hDevice , int fdEvent );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieScpSetEventDataOverflow_t)( TpDeviceHandle_t hDevice , int fdEvent );
#else
void ScpSetEventDataOverflow( TpDeviceHandle_t hDevice , int fdEvent );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieScpSetEventConnectionTestCompleted_t)( TpDeviceHandle_t hDevice , int fdEvent );
#else
void ScpSetEventConnectionTestCompleted( TpDeviceHandle_t hDevice , int fdEvent );
#endif

#endif

#ifdef HAVE_WINDOWS_H

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieScpSetEventDataReady_t)( TpDeviceHandle_t hDevice , HANDLE hEvent );
#else
void ScpSetEventDataReady( TpDeviceHandle_t hDevice , HANDLE hEvent );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieScpSetEventDataOverflow_t)( TpDeviceHandle_t hDevice , HANDLE hEvent );
#else
void ScpSetEventDataOverflow( TpDeviceHandle_t hDevice , HANDLE hEvent );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieScpSetEventConnectionTestCompleted_t)( TpDeviceHandle_t hDevice , HANDLE hEvent );
#else
void ScpSetEventConnectionTestCompleted( TpDeviceHandle_t hDevice , HANDLE hEvent );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieScpSetMessageDataReady_t)( TpDeviceHandle_t hDevice , HWND hWnd , WPARAM wParam , LPARAM lParam );
#else
void ScpSetMessageDataReady( TpDeviceHandle_t hDevice , HWND hWnd , WPARAM wParam , LPARAM lParam );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieScpSetMessageDataOverflow_t)( TpDeviceHandle_t hDevice , HWND hWnd , WPARAM wParam , LPARAM lParam );
#else
void ScpSetMessageDataOverflow( TpDeviceHandle_t hDevice , HWND hWnd , WPARAM wParam , LPARAM lParam );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieScpSetMessageConnectionTestCompleted_t)( TpDeviceHandle_t hDevice , HWND hWnd , WPARAM wParam , LPARAM lParam );
#else
void ScpSetMessageConnectionTestCompleted( TpDeviceHandle_t hDevice , HWND hWnd , WPARAM wParam , LPARAM lParam );
#endif

#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieScpStart_t)( TpDeviceHandle_t hDevice );
#else
bool8_t ScpStart( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieScpStop_t)( TpDeviceHandle_t hDevice );
#else
void ScpStop( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieScpForceTrigger_t)( TpDeviceHandle_t hDevice );
#else
void ScpForceTrigger( TpDeviceHandle_t hDevice );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieScpGetMeasureModes_t)( TpDeviceHandle_t hDevice );
#else
uint32_t ScpGetMeasureModes( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieScpGetMeasureMode_t)( TpDeviceHandle_t hDevice );
#else
uint32_t ScpGetMeasureMode( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieScpSetMeasureMode_t)( TpDeviceHandle_t hDevice , uint32_t dwMeasureMode );
#else
uint32_t ScpSetMeasureMode( TpDeviceHandle_t hDevice , uint32_t dwMeasureMode );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieScpIsRunning_t)( TpDeviceHandle_t hDevice );
#else
bool8_t ScpIsRunning( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieScpIsTriggered_t)( TpDeviceHandle_t hDevice );
#else
bool8_t ScpIsTriggered( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieScpIsDataReady_t)( TpDeviceHandle_t hDevice );
#else
bool8_t ScpIsDataReady( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieScpIsDataOverflow_t)( TpDeviceHandle_t hDevice );
#else
bool8_t ScpIsDataOverflow( TpDeviceHandle_t hDevice );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieScpGetAutoResolutionModes_t)( TpDeviceHandle_t hDevice );
#else
uint32_t ScpGetAutoResolutionModes( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieScpGetAutoResolutionMode_t)( TpDeviceHandle_t hDevice );
#else
uint32_t ScpGetAutoResolutionMode( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieScpSetAutoResolutionMode_t)( TpDeviceHandle_t hDevice , uint32_t dwAutoResolutionMode );
#else
uint32_t ScpSetAutoResolutionMode( TpDeviceHandle_t hDevice , uint32_t dwAutoResolutionMode );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieScpGetResolutions_t)( TpDeviceHandle_t hDevice , uint8_t* pList , uint32_t dwLength );
#else
uint32_t ScpGetResolutions( TpDeviceHandle_t hDevice , uint8_t* pList , uint32_t dwLength );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint8_t(*LibTiePieScpGetResolution_t)( TpDeviceHandle_t hDevice );
#else
uint8_t ScpGetResolution( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint8_t(*LibTiePieScpSetResolution_t)( TpDeviceHandle_t hDevice , uint8_t byResolution );
#else
uint8_t ScpSetResolution( TpDeviceHandle_t hDevice , uint8_t byResolution );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieScpIsResolutionEnhanced_t)( TpDeviceHandle_t hDevice );
#else
bool8_t ScpIsResolutionEnhanced( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieScpIsResolutionEnhancedEx_t)( TpDeviceHandle_t hDevice , uint8_t byResolution );
#else
bool8_t ScpIsResolutionEnhancedEx( TpDeviceHandle_t hDevice , uint8_t byResolution );
#endif


// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieScpGetClockSources_t)( TpDeviceHandle_t hDevice );
#else
uint32_t ScpGetClockSources( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieScpGetClockSource_t)( TpDeviceHandle_t hDevice );
#else
uint32_t ScpGetClockSource( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieScpSetClockSource_t)( TpDeviceHandle_t hDevice , uint32_t dwClockSource );
#else
uint32_t ScpSetClockSource( TpDeviceHandle_t hDevice , uint32_t dwClockSource );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieScpGetClockOutputs_t)( TpDeviceHandle_t hDevice );
#else
uint32_t ScpGetClockOutputs( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieScpGetClockOutput_t)( TpDeviceHandle_t hDevice );
#else
uint32_t ScpGetClockOutput( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieScpSetClockOutput_t)( TpDeviceHandle_t hDevice , uint32_t dwClockOutput );
#else
uint32_t ScpSetClockOutput( TpDeviceHandle_t hDevice , uint32_t dwClockOutput );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpGetPreSampleRatio_t)( TpDeviceHandle_t hDevice );
#else
double ScpGetPreSampleRatio( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpSetPreSampleRatio_t)( TpDeviceHandle_t hDevice , double dPreSampleRatio );
#else
double ScpSetPreSampleRatio( TpDeviceHandle_t hDevice , double dPreSampleRatio );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpGetTriggerHoldOffCountMax_t)( TpDeviceHandle_t hDevice );
#else
uint64_t ScpGetTriggerHoldOffCountMax( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpGetTriggerHoldOffCountMaxEx_t)( TpDeviceHandle_t hDevice , uint32_t dwMeasureMode );
#else
uint64_t ScpGetTriggerHoldOffCountMaxEx( TpDeviceHandle_t hDevice , uint32_t dwMeasureMode );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpGetTriggerHoldOffCount_t)( TpDeviceHandle_t hDevice );
#else
uint64_t ScpGetTriggerHoldOffCount( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpSetTriggerHoldOffCount_t)( TpDeviceHandle_t hDevice , uint64_t qwTriggerHoldOffCount );
#else
uint64_t ScpSetTriggerHoldOffCount( TpDeviceHandle_t hDevice , uint64_t qwTriggerHoldOffCount );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpGetRecordLengthMax_t)( TpDeviceHandle_t hDevice );
#else
uint64_t ScpGetRecordLengthMax( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpGetRecordLengthMaxEx_t)( TpDeviceHandle_t hDevice , uint32_t dwMeasureMode , uint8_t byResolution );
#else
uint64_t ScpGetRecordLengthMaxEx( TpDeviceHandle_t hDevice , uint32_t dwMeasureMode , uint8_t byResolution );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpGetRecordLength_t)( TpDeviceHandle_t hDevice );
#else
uint64_t ScpGetRecordLength( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpSetRecordLength_t)( TpDeviceHandle_t hDevice , uint64_t qwRecordLength );
#else
uint64_t ScpSetRecordLength( TpDeviceHandle_t hDevice , uint64_t qwRecordLength );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpVerifyRecordLength_t)( TpDeviceHandle_t hDevice , uint64_t qwRecordLength );
#else
uint64_t ScpVerifyRecordLength( TpDeviceHandle_t hDevice , uint64_t qwRecordLength );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpVerifyRecordLengthEx_t)( TpDeviceHandle_t hDevice , uint64_t qwRecordLength , uint32_t dwMeasureMode , uint8_t byResolution , uint64_t qwActiveChannelMask );
#else
uint64_t ScpVerifyRecordLengthEx( TpDeviceHandle_t hDevice , uint64_t qwRecordLength , uint32_t dwMeasureMode , uint8_t byResolution , uint64_t qwActiveChannelMask );
#endif


// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpGetSampleFrequencyMax_t)( TpDeviceHandle_t hDevice );
#else
double ScpGetSampleFrequencyMax( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpGetSampleFrequency_t)( TpDeviceHandle_t hDevice );
#else
double ScpGetSampleFrequency( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpSetSampleFrequency_t)( TpDeviceHandle_t hDevice , double dSampleFrequency );
#else
double ScpSetSampleFrequency( TpDeviceHandle_t hDevice , double dSampleFrequency );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpVerifySampleFrequency_t)( TpDeviceHandle_t hDevice , double dSampleFrequency );
#else
double ScpVerifySampleFrequency( TpDeviceHandle_t hDevice , double dSampleFrequency );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpVerifySampleFrequencyEx_t)( TpDeviceHandle_t hDevice , double dSampleFrequency , uint32_t dwMeasureMode , uint8_t byResolution , uint64_t qwActiveChannelMask );
#else
double ScpVerifySampleFrequencyEx( TpDeviceHandle_t hDevice , double dSampleFrequency , uint32_t dwMeasureMode , uint8_t byResolution , uint64_t qwActiveChannelMask );
#endif


// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieScpGetSegmentCountMax_t)( TpDeviceHandle_t hDevice );
#else
uint32_t ScpGetSegmentCountMax( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieScpGetSegmentCount_t)( TpDeviceHandle_t hDevice );
#else
uint32_t ScpGetSegmentCount( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieScpSetSegmentCount_t)( TpDeviceHandle_t hDevice , uint32_t dwSegmentCount );
#else
uint32_t ScpSetSegmentCount( TpDeviceHandle_t hDevice , uint32_t dwSegmentCount );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieScpVerifySegmentCount_t)( TpDeviceHandle_t hDevice , uint32_t dwSegmentCount );
#else
uint32_t ScpVerifySegmentCount( TpDeviceHandle_t hDevice , uint32_t dwSegmentCount );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieScpVerifySegmentCountEx_t)( TpDeviceHandle_t hDevice , uint32_t dwSegmentCount , uint64_t qwRecordLength , double dSampleFrequency );
#else
uint32_t ScpVerifySegmentCountEx( TpDeviceHandle_t hDevice , uint32_t dwSegmentCount , uint64_t qwRecordLength , double dSampleFrequency );
#endif


// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpGetTriggerTimeOut_t)( TpDeviceHandle_t hDevice );
#else
double ScpGetTriggerTimeOut( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpSetTriggerTimeOut_t)( TpDeviceHandle_t hDevice , double dTimeout );
#else
double ScpSetTriggerTimeOut( TpDeviceHandle_t hDevice , double dTimeout );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpVerifyTriggerTimeOut_t)( TpDeviceHandle_t hDevice , double dTimeout );
#else
double ScpVerifyTriggerTimeOut( TpDeviceHandle_t hDevice , double dTimeout );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpVerifyTriggerTimeOutEx_t)( TpDeviceHandle_t hDevice , double dTimeout , uint32_t dwMeasureMode , double dSampleFrequency );
#else
double ScpVerifyTriggerTimeOutEx( TpDeviceHandle_t hDevice , double dTimeout , uint32_t dwMeasureMode , double dSampleFrequency );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpGetTriggerDelay_t)( TpDeviceHandle_t hDevice );
#else
double ScpGetTriggerDelay( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpSetTriggerDelay_t)( TpDeviceHandle_t hDevice , double dDelay );
#else
double ScpSetTriggerDelay( TpDeviceHandle_t hDevice , double dDelay );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpVerifyTriggerDelay_t)( TpDeviceHandle_t hDevice , double dDelay );
#else
double ScpVerifyTriggerDelay( TpDeviceHandle_t hDevice , double dDelay );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpVerifyTriggerDelayEx_t)( TpDeviceHandle_t hDevice , double dDelay , uint32_t dwMeasureMode , double dSampleFrequency );
#else
double ScpVerifyTriggerDelayEx( TpDeviceHandle_t hDevice , double dDelay , uint32_t dwMeasureMode , double dSampleFrequency );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpGetTriggerSources_t)( TpDeviceHandle_t hDevice );
#else
uint64_t ScpGetTriggerSources( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpGetTriggerSourcesEx_t)( TpDeviceHandle_t hDevice , uint32_t dwMeasureMode );
#else
uint64_t ScpGetTriggerSourcesEx( TpDeviceHandle_t hDevice , uint32_t dwMeasureMode );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpGetTriggerSourceOR_t)( TpDeviceHandle_t hDevice );
#else
uint64_t ScpGetTriggerSourceOR( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpSetTriggerSourceOR_t)( TpDeviceHandle_t hDevice , uint64_t qwTriggerSourceMask );
#else
uint64_t ScpSetTriggerSourceOR( TpDeviceHandle_t hDevice , uint64_t qwTriggerSourceMask );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpGetTriggerSourceAND_t)( TpDeviceHandle_t hDevice );
#else
uint64_t ScpGetTriggerSourceAND( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpSetTriggerSourceAND_t)( TpDeviceHandle_t hDevice , uint64_t qwTriggerSourceMask );
#else
uint64_t ScpSetTriggerSourceAND( TpDeviceHandle_t hDevice , uint64_t qwTriggerSourceMask );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpGetTriggerKinds_t)( TpDeviceHandle_t hDevice , uint64_t qwTriggerSourceMask );
#else
uint64_t ScpGetTriggerKinds( TpDeviceHandle_t hDevice , uint64_t qwTriggerSourceMask );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpGetTriggerKindsEx_t)( TpDeviceHandle_t hDevice , uint64_t qwTriggerSourceMask , uint32_t dwMeasureMode );
#else
uint64_t ScpGetTriggerKindsEx( TpDeviceHandle_t hDevice , uint64_t qwTriggerSourceMask , uint32_t dwMeasureMode );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpGetTriggerKind_t)( TpDeviceHandle_t hDevice , uint64_t qwTriggerSource );
#else
uint64_t ScpGetTriggerKind( TpDeviceHandle_t hDevice , uint64_t qwTriggerSource );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpSetTriggerKind_t)( TpDeviceHandle_t hDevice , uint64_t qwTriggerSource , uint64_t qwTriggerKind );
#else
uint64_t ScpSetTriggerKind( TpDeviceHandle_t hDevice , uint64_t qwTriggerSource , uint64_t qwTriggerKind );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpGetTriggerLevel_t)( TpDeviceHandle_t hDevice , uint64_t qwTriggerSource , uint32_t dwIndex );
#else
double ScpGetTriggerLevel( TpDeviceHandle_t hDevice , uint64_t qwTriggerSource , uint32_t dwIndex );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpSetTriggerLevel_t)( TpDeviceHandle_t hDevice , uint64_t qwTriggerSource , uint32_t dwIndex , double dLevel );
#else
double ScpSetTriggerLevel( TpDeviceHandle_t hDevice , uint64_t qwTriggerSource , uint32_t dwIndex , double dLevel );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpGetTriggerHysteresis_t)( TpDeviceHandle_t hDevice , uint64_t qwTriggerSource , uint32_t dwIndex );
#else
double ScpGetTriggerHysteresis( TpDeviceHandle_t hDevice , uint64_t qwTriggerSource , uint32_t dwIndex );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpSetTriggerHysteresis_t)( TpDeviceHandle_t hDevice , uint64_t qwTriggerSource , uint32_t dwIndex , double dHysteresis );
#else
double ScpSetTriggerHysteresis( TpDeviceHandle_t hDevice , uint64_t qwTriggerSource , uint32_t dwIndex , double dHysteresis );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpChGetTriggerKinds_t)( TpDeviceHandle_t hDevice , uint16_t wCh );
#else
uint64_t ScpChGetTriggerKinds( TpDeviceHandle_t hDevice , uint16_t wCh );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpChGetTriggerKindsEx_t)( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwMeasureMode );
#else
uint64_t ScpChGetTriggerKindsEx( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwMeasureMode );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpChGetTriggerKind_t)( TpDeviceHandle_t hDevice , uint16_t wCh );
#else
uint64_t ScpChGetTriggerKind( TpDeviceHandle_t hDevice , uint16_t wCh );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieScpChSetTriggerKind_t)( TpDeviceHandle_t hDevice , uint16_t wCh , uint64_t qwTriggerKind );
#else
uint64_t ScpChSetTriggerKind( TpDeviceHandle_t hDevice , uint16_t wCh , uint64_t qwTriggerKind );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpChGetTriggerLevel_t)( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwIndex );
#else
double ScpChGetTriggerLevel( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwIndex );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpChSetTriggerLevel_t)( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwIndex , double dLevel );
#else
double ScpChSetTriggerLevel( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwIndex , double dLevel );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpChGetTriggerHysteresis_t)( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwIndex );
#else
double ScpChGetTriggerHysteresis( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwIndex );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpChSetTriggerHysteresis_t)( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwIndex , double dHysteresis );
#else
double ScpChSetTriggerHysteresis( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwIndex , double dHysteresis );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpChGetTriggerPulseTime_t)( TpDeviceHandle_t hDevice , uint16_t wCh );
#else
double ScpChGetTriggerPulseTime( TpDeviceHandle_t hDevice , uint16_t wCh );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieScpChSetTriggerPulseTime_t)( TpDeviceHandle_t hDevice , uint16_t wCh , double dPulseTime );
#else
double ScpChSetTriggerPulseTime( TpDeviceHandle_t hDevice , uint16_t wCh , double dPulseTime );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieScpHasConnectionTest_t)( TpDeviceHandle_t hDevice );
#else
bool8_t ScpHasConnectionTest( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieScpChHasConnectionTest_t)( TpDeviceHandle_t hDevice , uint16_t wCh );
#else
bool8_t ScpChHasConnectionTest( TpDeviceHandle_t hDevice , uint16_t wCh );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieScpStartConnectionTest_t)( TpDeviceHandle_t hDevice , uint64_t qwChannelMask );
#else
bool8_t ScpStartConnectionTest( TpDeviceHandle_t hDevice , uint64_t qwChannelMask );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieScpIsConnectionTestCompleted_t)( TpDeviceHandle_t hDevice );
#else
bool8_t ScpIsConnectionTestCompleted( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint16_t(*LibTiePieScpGetConnectionTestData_t)( TpDeviceHandle_t hDevice , LibTiePieTriState_t* pBuffer , uint16_t wChannelCount );
#else
uint16_t ScpGetConnectionTestData( TpDeviceHandle_t hDevice , LibTiePieTriState_t* pBuffer , uint16_t wChannelCount );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieGenGetConnectorType_t)( TpDeviceHandle_t hDevice );
#else
uint32_t GenGetConnectorType( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieGenIsDifferential_t)( TpDeviceHandle_t hDevice );
#else
bool8_t GenIsDifferential( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenGetImpedance_t)( TpDeviceHandle_t hDevice );
#else
double GenGetImpedance( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint8_t(*LibTiePieGenGetResolution_t)( TpDeviceHandle_t hDevice );
#else
uint8_t GenGetResolution( TpDeviceHandle_t hDevice );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieGenIsControllable_t)( TpDeviceHandle_t hDevice );
#else
bool8_t GenIsControllable( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieGenGetOutputOn_t)( TpDeviceHandle_t hDevice );
#else
bool8_t GenGetOutputOn( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieGenSetOutputOn_t)( TpDeviceHandle_t hDevice , bool8_t bOutputOn );
#else
bool8_t GenSetOutputOn( TpDeviceHandle_t hDevice , bool8_t bOutputOn );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieGenStart_t)( TpDeviceHandle_t hDevice );
#else
void GenStart( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieGenStop_t)( TpDeviceHandle_t hDevice );
#else
void GenStop( TpDeviceHandle_t hDevice );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieGenIsBurstActive_t)( TpDeviceHandle_t hDevice );
#else
bool8_t GenIsBurstActive( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieGenGetBurstCount_t)( TpDeviceHandle_t hDevice );
#else
uint64_t GenGetBurstCount( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieGenGetBurstCountMax_t)( TpDeviceHandle_t hDevice );
#else
uint64_t GenGetBurstCountMax( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieGenSetBurstCount_t)( TpDeviceHandle_t hDevice , uint64_t qwBurstCount );
#else
uint64_t GenSetBurstCount( TpDeviceHandle_t hDevice , uint64_t qwBurstCount );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieGenGetBurstModes_t)( TpDeviceHandle_t hDevice );
#else
uint64_t GenGetBurstModes( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieGenGetBurstMode_t)( TpDeviceHandle_t hDevice );
#else
uint64_t GenGetBurstMode( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieGenSetBurstMode_t)( TpDeviceHandle_t hDevice , uint64_t qwBurstMode );
#else
uint64_t GenSetBurstMode( TpDeviceHandle_t hDevice , uint64_t qwBurstMode );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieGenGetSignalTypes_t)( TpDeviceHandle_t hDevice );
#else
uint32_t GenGetSignalTypes( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieGenGetSignalType_t)( TpDeviceHandle_t hDevice );
#else
uint32_t GenGetSignalType( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieGenSetSignalType_t)( TpDeviceHandle_t hDevice , uint32_t dwSignalType );
#else
uint32_t GenSetSignalType( TpDeviceHandle_t hDevice , uint32_t dwSignalType );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.


#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieGenGetAmplitudeMinMaxEx_t)( TpDeviceHandle_t hDevice , uint32_t dwSignalType , double* pMin , double* pMax );
#else
void GenGetAmplitudeMinMaxEx( TpDeviceHandle_t hDevice , uint32_t dwSignalType , double* pMin , double* pMax );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenGetAmplitudeMax_t)( TpDeviceHandle_t hDevice );
#else
double GenGetAmplitudeMax( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenGetAmplitudeMin_t)( TpDeviceHandle_t hDevice );
#else
double GenGetAmplitudeMin( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenGetAmplitude_t)( TpDeviceHandle_t hDevice );
#else
double GenGetAmplitude( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenSetAmplitude_t)( TpDeviceHandle_t hDevice , double dAmplitude );
#else
double GenSetAmplitude( TpDeviceHandle_t hDevice , double dAmplitude );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenVerifyAmplitude_t)( TpDeviceHandle_t hDevice , double dAmplitude );
#else
double GenVerifyAmplitude( TpDeviceHandle_t hDevice , double dAmplitude );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenVerifyAmplitudeEx_t)( TpDeviceHandle_t hDevice , double dAmplitude , uint32_t dwSignalType , uint32_t dwAmplitudeRangeIndex , double dOffset );
#else
double GenVerifyAmplitudeEx( TpDeviceHandle_t hDevice , double dAmplitude , uint32_t dwSignalType , uint32_t dwAmplitudeRangeIndex , double dOffset );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieGenGetAmplitudeAutoRanging_t)( TpDeviceHandle_t hDevice );
#else
bool8_t GenGetAmplitudeAutoRanging( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieGenSetAmplitudeAutoRanging_t)( TpDeviceHandle_t hDevice , bool8_t bEnable );
#else
bool8_t GenSetAmplitudeAutoRanging( TpDeviceHandle_t hDevice , bool8_t bEnable );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieGenGetAmplitudeRanges_t)( TpDeviceHandle_t hDevice , double* pList , uint32_t dwLength );
#else
uint32_t GenGetAmplitudeRanges( TpDeviceHandle_t hDevice , double* pList , uint32_t dwLength );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenGetAmplitudeRange_t)( TpDeviceHandle_t hDevice );
#else
double GenGetAmplitudeRange( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenSetAmplitudeRange_t)( TpDeviceHandle_t hDevice , double dRange );
#else
double GenSetAmplitudeRange( TpDeviceHandle_t hDevice , double dRange );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.


#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieGenGetFrequencyMinMaxEx_t)( TpDeviceHandle_t hDevice , uint32_t dwFrequencyMode , uint32_t dwSignalType , double* pMin , double* pMax );
#else
void GenGetFrequencyMinMaxEx( TpDeviceHandle_t hDevice , uint32_t dwFrequencyMode , uint32_t dwSignalType , double* pMin , double* pMax );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieGenGetFrequencyMinMax_t)( TpDeviceHandle_t hDevice , uint32_t dwFrequencyMode , double* pMin , double* pMax );
#else
void GenGetFrequencyMinMax( TpDeviceHandle_t hDevice , uint32_t dwFrequencyMode , double* pMin , double* pMax );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenGetFrequencyMin_t)( TpDeviceHandle_t hDevice );
#else
double GenGetFrequencyMin( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenGetFrequencyMax_t)( TpDeviceHandle_t hDevice );
#else
double GenGetFrequencyMax( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenGetFrequency_t)( TpDeviceHandle_t hDevice );
#else
double GenGetFrequency( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenSetFrequency_t)( TpDeviceHandle_t hDevice , double dFrequency );
#else
double GenSetFrequency( TpDeviceHandle_t hDevice , double dFrequency );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenVerifyFrequency_t)( TpDeviceHandle_t hDevice , double dFrequency );
#else
double GenVerifyFrequency( TpDeviceHandle_t hDevice , double dFrequency );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenVerifyFrequencyEx_t)( TpDeviceHandle_t hDevice , double dFrequency , uint32_t dwFrequencyMode );
#else
double GenVerifyFrequencyEx( TpDeviceHandle_t hDevice , double dFrequency , uint32_t dwFrequencyMode );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenVerifyFrequencyEx2_t)( TpDeviceHandle_t hDevice , double dFrequency , uint32_t dwFrequencyMode , uint32_t dwSignalType , uint64_t qwDataLength );
#else
double GenVerifyFrequencyEx2( TpDeviceHandle_t hDevice , double dFrequency , uint32_t dwFrequencyMode , uint32_t dwSignalType , uint64_t qwDataLength );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieGenGetFrequencyModes_t)( TpDeviceHandle_t hDevice );
#else
uint32_t GenGetFrequencyModes( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieGenGetFrequencyModesEx_t)( TpDeviceHandle_t hDevice , uint32_t dwSignalType );
#else
uint32_t GenGetFrequencyModesEx( TpDeviceHandle_t hDevice , uint32_t dwSignalType );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieGenGetFrequencyMode_t)( TpDeviceHandle_t hDevice );
#else
uint32_t GenGetFrequencyMode( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieGenSetFrequencyMode_t)( TpDeviceHandle_t hDevice , uint32_t dwFrequencyMode );
#else
uint32_t GenSetFrequencyMode( TpDeviceHandle_t hDevice , uint32_t dwFrequencyMode );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.


#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieGenGetOffsetMinMaxEx_t)( TpDeviceHandle_t hDevice , uint32_t dwSignalType , double* pMin , double* pMax );
#else
void GenGetOffsetMinMaxEx( TpDeviceHandle_t hDevice , uint32_t dwSignalType , double* pMin , double* pMax );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenGetOffsetMin_t)( TpDeviceHandle_t hDevice );
#else
double GenGetOffsetMin( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenGetOffsetMax_t)( TpDeviceHandle_t hDevice );
#else
double GenGetOffsetMax( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenGetOffset_t)( TpDeviceHandle_t hDevice );
#else
double GenGetOffset( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenSetOffset_t)( TpDeviceHandle_t hDevice , double dOffset );
#else
double GenSetOffset( TpDeviceHandle_t hDevice , double dOffset );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenVerifyOffset_t)( TpDeviceHandle_t hDevice , double dOffset );
#else
double GenVerifyOffset( TpDeviceHandle_t hDevice , double dOffset );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenVerifyOffsetEx_t)( TpDeviceHandle_t hDevice , double dOffset , uint32_t dwSignalType , double dAmplitude );
#else
double GenVerifyOffsetEx( TpDeviceHandle_t hDevice , double dOffset , uint32_t dwSignalType , double dAmplitude );
#endif


// Workaround: Without this line Doxygen adds the documentation below to the group above.


#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieGenGetPhaseMinMaxEx_t)( TpDeviceHandle_t hDevice , uint32_t dwSignalType , double* pMin , double* pMax );
#else
void GenGetPhaseMinMaxEx( TpDeviceHandle_t hDevice , uint32_t dwSignalType , double* pMin , double* pMax );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenGetPhaseMin_t)( TpDeviceHandle_t hDevice );
#else
double GenGetPhaseMin( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenGetPhaseMax_t)( TpDeviceHandle_t hDevice );
#else
double GenGetPhaseMax( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenGetPhase_t)( TpDeviceHandle_t hDevice );
#else
double GenGetPhase( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenSetPhase_t)( TpDeviceHandle_t hDevice , double dPhase );
#else
double GenSetPhase( TpDeviceHandle_t hDevice , double dPhase );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenVerifyPhase_t)( TpDeviceHandle_t hDevice , double dPhase );
#else
double GenVerifyPhase( TpDeviceHandle_t hDevice , double dPhase );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenVerifyPhaseEx_t)( TpDeviceHandle_t hDevice , double dPhase , uint32_t dwSignalType );
#else
double GenVerifyPhaseEx( TpDeviceHandle_t hDevice , double dPhase , uint32_t dwSignalType );
#endif


// Workaround: Without this line Doxygen adds the documentation below to the group above.


#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieGenGetSymmetryMinMaxEx_t)( TpDeviceHandle_t hDevice , uint32_t dwSignalType , double* pMin , double* pMax );
#else
void GenGetSymmetryMinMaxEx( TpDeviceHandle_t hDevice , uint32_t dwSignalType , double* pMin , double* pMax );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenGetSymmetryMin_t)( TpDeviceHandle_t hDevice );
#else
double GenGetSymmetryMin( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenGetSymmetryMax_t)( TpDeviceHandle_t hDevice );
#else
double GenGetSymmetryMax( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenGetSymmetry_t)( TpDeviceHandle_t hDevice );
#else
double GenGetSymmetry( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenSetSymmetry_t)( TpDeviceHandle_t hDevice , double dSymmetry );
#else
double GenSetSymmetry( TpDeviceHandle_t hDevice , double dSymmetry );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenVerifySymmetry_t)( TpDeviceHandle_t hDevice , double dSymmetry );
#else
double GenVerifySymmetry( TpDeviceHandle_t hDevice , double dSymmetry );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenVerifySymmetryEx_t)( TpDeviceHandle_t hDevice , double dSymmetry , uint32_t dwSignalType );
#else
double GenVerifySymmetryEx( TpDeviceHandle_t hDevice , double dSymmetry , uint32_t dwSignalType );
#endif


// Workaround: Without this line Doxygen adds the documentation below to the group above.


#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieGenGetDataLengthMinMaxEx_t)( TpDeviceHandle_t hDevice , uint32_t dwSignalType , uint64_t* pMin , uint64_t* pMax );
#else
void GenGetDataLengthMinMaxEx( TpDeviceHandle_t hDevice , uint32_t dwSignalType , uint64_t* pMin , uint64_t* pMax );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieGenGetDataLengthMin_t)( TpDeviceHandle_t hDevice );
#else
uint64_t GenGetDataLengthMin( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieGenGetDataLengthMax_t)( TpDeviceHandle_t hDevice );
#else
uint64_t GenGetDataLengthMax( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieGenGetDataLength_t)( TpDeviceHandle_t hDevice );
#else
uint64_t GenGetDataLength( TpDeviceHandle_t hDevice );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieGenVerifyDataLength_t)( TpDeviceHandle_t hDevice , uint64_t qwDataLength );
#else
uint64_t GenVerifyDataLength( TpDeviceHandle_t hDevice , uint64_t qwDataLength );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieGenVerifyDataLengthEx_t)( TpDeviceHandle_t hDevice , uint64_t qwDataLength , uint32_t dwSignalType );
#else
uint64_t GenVerifyDataLengthEx( TpDeviceHandle_t hDevice , uint64_t qwDataLength , uint32_t dwSignalType );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieGenGetDataRawType_t)( TpDeviceHandle_t hDevice );
#else
uint32_t GenGetDataRawType( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieGenSetData_t)( TpDeviceHandle_t hDevice , float* pBuffer , uint64_t qwSampleCount );
#else
void GenSetData( TpDeviceHandle_t hDevice , float* pBuffer , uint64_t qwSampleCount );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieGenSetDataEx_t)( TpDeviceHandle_t hDevice , float* pBuffer , uint64_t qwSampleCount , uint32_t dwSignalType , uint32_t dwReserved );
#else
void GenSetDataEx( TpDeviceHandle_t hDevice , float* pBuffer , uint64_t qwSampleCount , uint32_t dwSignalType , uint32_t dwReserved );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieGenSetDataRaw_t)( TpDeviceHandle_t hDevice , void* pBuffer , uint64_t qwSampleCount );
#else
void GenSetDataRaw( TpDeviceHandle_t hDevice , void* pBuffer , uint64_t qwSampleCount );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieGenSetDataRawEx_t)( TpDeviceHandle_t hDevice , void* pBuffer , uint64_t qwSampleCount , uint32_t dwSignalType , uint32_t dwReserved );
#else
void GenSetDataRawEx( TpDeviceHandle_t hDevice , void* pBuffer , uint64_t qwSampleCount , uint32_t dwSignalType , uint32_t dwReserved );
#endif


// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieGenSetCallbackBurstCompleted_t)( TpDeviceHandle_t hDevice , TpCallback_t pCallback , void* pData );
#else
void GenSetCallbackBurstCompleted( TpDeviceHandle_t hDevice , TpCallback_t pCallback , void* pData );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieGenSetCallbackControllableChanged_t)( TpDeviceHandle_t hDevice , TpCallback_t pCallback , void* pData );
#else
void GenSetCallbackControllableChanged( TpDeviceHandle_t hDevice , TpCallback_t pCallback , void* pData );
#endif

#ifdef __linux__

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieGenSetEventBurstCompleted_t)( TpDeviceHandle_t hDevice , int fdEvent );
#else
void GenSetEventBurstCompleted( TpDeviceHandle_t hDevice , int fdEvent );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieGenSetEventControllableChanged_t)( TpDeviceHandle_t hDevice , int fdEvent );
#else
void GenSetEventControllableChanged( TpDeviceHandle_t hDevice , int fdEvent );
#endif

#endif

#ifdef HAVE_WINDOWS_H

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieGenSetEventBurstCompleted_t)( TpDeviceHandle_t hDevice , HANDLE hEvent );
#else
void GenSetEventBurstCompleted( TpDeviceHandle_t hDevice , HANDLE hEvent );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieGenSetEventControllableChanged_t)( TpDeviceHandle_t hDevice , HANDLE hEvent );
#else
void GenSetEventControllableChanged( TpDeviceHandle_t hDevice , HANDLE hEvent );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieGenSetMessageBurstCompleted_t)( TpDeviceHandle_t hDevice , HWND hWnd , WPARAM wParam , LPARAM lParam );
#else
void GenSetMessageBurstCompleted( TpDeviceHandle_t hDevice , HWND hWnd , WPARAM wParam , LPARAM lParam );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieGenSetMessageControllableChanged_t)( TpDeviceHandle_t hDevice , HWND hWnd , WPARAM wParam , LPARAM lParam );
#else
void GenSetMessageControllableChanged( TpDeviceHandle_t hDevice , HWND hWnd , WPARAM wParam , LPARAM lParam );
#endif

#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieGenGetModes_t)( TpDeviceHandle_t hDevice );
#else
uint32_t GenGetModes( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieGenGetModesEx_t)( TpDeviceHandle_t hDevice , uint32_t dwSignalType );
#else
uint32_t GenGetModesEx( TpDeviceHandle_t hDevice , uint32_t dwSignalType );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieGenGetMode_t)( TpDeviceHandle_t hDevice );
#else
uint32_t GenGetMode( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieGenSetMode_t)( TpDeviceHandle_t hDevice , uint32_t dwMode );
#else
uint32_t GenSetMode( TpDeviceHandle_t hDevice , uint32_t dwMode );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieGenGetAutoRanging_t)( TpDeviceHandle_t hDevice );
#else
bool8_t GenGetAutoRanging( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieGenSetAutoRanging_t)( TpDeviceHandle_t hDevice , bool8_t bEnable );
#else
bool8_t GenSetAutoRanging( TpDeviceHandle_t hDevice , bool8_t bEnable );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint32_t(*LibTiePieGenGetRanges_t)( TpDeviceHandle_t hDevice , double* pList , uint32_t dwLength );
#else
uint32_t GenGetRanges( TpDeviceHandle_t hDevice , double* pList , uint32_t dwLength );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenGetRange_t)( TpDeviceHandle_t hDevice );
#else
double GenGetRange( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieGenSetRange_t)( TpDeviceHandle_t hDevice , double dRange );
#else
double GenSetRange( TpDeviceHandle_t hDevice , double dRange );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieGenGetTriggerSources_t)( TpDeviceHandle_t hDevice );
#else
uint64_t GenGetTriggerSources( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieGenGetTriggerSourceAND_t)( TpDeviceHandle_t hDevice );
#else
uint64_t GenGetTriggerSourceAND( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieGenSetTriggerSourceAND_t)( TpDeviceHandle_t hDevice , uint64_t qwTriggerSourceMask );
#else
uint64_t GenSetTriggerSourceAND( TpDeviceHandle_t hDevice , uint64_t qwTriggerSourceMask );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieGenGetTriggerSourceOR_t)( TpDeviceHandle_t hDevice );
#else
uint64_t GenGetTriggerSourceOR( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef uint64_t(*LibTiePieGenSetTriggerSourceOR_t)( TpDeviceHandle_t hDevice , uint64_t qwTriggerSourceMask );
#else
uint64_t GenSetTriggerSourceOR( TpDeviceHandle_t hDevice , uint64_t qwTriggerSourceMask );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieI2CIsInternalAddress_t)( TpDeviceHandle_t hDevice , uint16_t wAddress );
#else
bool8_t I2CIsInternalAddress( TpDeviceHandle_t hDevice , uint16_t wAddress );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieI2CRead_t)( TpDeviceHandle_t hDevice , uint16_t wAddress , void* pBuffer , uint32_t dwSize , bool8_t bStop );
#else
bool8_t I2CRead( TpDeviceHandle_t hDevice , uint16_t wAddress , void* pBuffer , uint32_t dwSize , bool8_t bStop );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieI2CReadByte_t)( TpDeviceHandle_t hDevice , uint16_t wAddress , uint8_t* pValue );
#else
bool8_t I2CReadByte( TpDeviceHandle_t hDevice , uint16_t wAddress , uint8_t* pValue );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieI2CReadWord_t)( TpDeviceHandle_t hDevice , uint16_t wAddress , uint16_t* pValue );
#else
bool8_t I2CReadWord( TpDeviceHandle_t hDevice , uint16_t wAddress , uint16_t* pValue );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieI2CWrite_t)( TpDeviceHandle_t hDevice , uint16_t wAddress , void* pBuffer , uint32_t dwSize , bool8_t bStop );
#else
bool8_t I2CWrite( TpDeviceHandle_t hDevice , uint16_t wAddress , void* pBuffer , uint32_t dwSize , bool8_t bStop );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieI2CWriteByte_t)( TpDeviceHandle_t hDevice , uint16_t wAddress , uint8_t byValue );
#else
bool8_t I2CWriteByte( TpDeviceHandle_t hDevice , uint16_t wAddress , uint8_t byValue );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieI2CWriteByteByte_t)( TpDeviceHandle_t hDevice , uint16_t wAddress , uint8_t byValue1 , uint8_t byValue2 );
#else
bool8_t I2CWriteByteByte( TpDeviceHandle_t hDevice , uint16_t wAddress , uint8_t byValue1 , uint8_t byValue2 );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieI2CWriteByteWord_t)( TpDeviceHandle_t hDevice , uint16_t wAddress , uint8_t byValue1 , uint16_t wValue2 );
#else
bool8_t I2CWriteByteWord( TpDeviceHandle_t hDevice , uint16_t wAddress , uint8_t byValue1 , uint16_t wValue2 );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef bool8_t(*LibTiePieI2CWriteWord_t)( TpDeviceHandle_t hDevice , uint16_t wAddress , uint16_t wValue );
#else
bool8_t I2CWriteWord( TpDeviceHandle_t hDevice , uint16_t wAddress , uint16_t wValue );
#endif

// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieI2CGetSpeed_t)( TpDeviceHandle_t hDevice );
#else
double I2CGetSpeed( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieI2CGetSpeedMax_t)( TpDeviceHandle_t hDevice );
#else
double I2CGetSpeedMax( TpDeviceHandle_t hDevice );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieI2CSetSpeed_t)( TpDeviceHandle_t hDevice , double dSpeed );
#else
double I2CSetSpeed( TpDeviceHandle_t hDevice , double dSpeed );
#endif


#ifdef LIBTIEPIE_DYNAMIC
typedef double(*LibTiePieI2CVerifySpeed_t)( TpDeviceHandle_t hDevice , double dSpeed );
#else
double I2CVerifySpeed( TpDeviceHandle_t hDevice , double dSpeed );
#endif


// Workaround: Without this line Doxygen adds the documentation below to the group above.

#ifdef LIBTIEPIE_DYNAMIC
typedef LibTiePiePointerArray_t(*LibTiePieHlpPointerArrayNew_t)( uint32_t dwLength );
#else
LibTiePiePointerArray_t HlpPointerArrayNew( uint32_t dwLength );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieHlpPointerArrayDelete_t)( LibTiePiePointerArray_t pArray );
#else
void HlpPointerArrayDelete( LibTiePiePointerArray_t pArray );
#endif

#ifdef LIBTIEPIE_DYNAMIC
typedef void(*LibTiePieHlpPointerArraySet_t)( LibTiePiePointerArray_t pArray , uint32_t dwIndex , void* pPointer );
#else
void HlpPointerArraySet( LibTiePiePointerArray_t pArray , uint32_t dwIndex , void* pPointer );
#endif

#ifdef __cplusplus
}
#endif

#endif