libtiepie.h

Go to the documentation of this file.

#ifndef _LIBTIEPIE_H_
#define _LIBTIEPIE_H_

#if ( defined( __STDC_VERSION__ ) && __STDC_VERSION__ >= 199901L ) || ( defined( __GNUC__ ) && defined( __cplusplus ) )
  #include <stdint.h>
#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
  // Assume the file is used from Matlab and define int8_t and similar types as follows:
  #include <tmwtypes.h>

  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;
#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 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 0x0000000000000000 

#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 MMN_COUNT  2 


#define MMB_STREAM 0 
#define MMB_BLOCK  1 


#define MM_UNKNOWN 0x00000000 

#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     0x0000000000000000

#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_ARBITRARY )
#define STM_PHASE      ( ST_SINE | ST_TRIANGLE | ST_SQUARE                    | ST_ARBITRARY )
#define STM_SYMMETRY   ( ST_SINE | ST_TRIANGLE | ST_SQUARE                                   )

#define TH_ALLPRESAMPLES 0xffffffffffffffff 


#define TKN_COUNT  7 


#define TKB_RISING         0
#define TKB_FALLING        1
#define TKB_INWINDOW       2
#define TKB_OUTWINDOW      3
#define TKB_EDGE           4
#define TKB_DROPINWINDOW   5
#define TKB_DROPOUTWINDOW  6

#define TK_UNKNOWN          0x0000000000000000ULL 

#define TK_RISING           ( 1ULL << TKB_RISING )
#define TK_FALLING          ( 1ULL << TKB_FALLING )
#define TK_INWINDOW         ( 1ULL << TKB_INWINDOW )
#define TK_OUTWINDOW        ( 1ULL << TKB_OUTWINDOW )
#define TK_EDGE             ( 1ULL << TKB_EDGE )
#define TK_DROPINWINDOW     ( 1ULL << TKB_DROPINWINDOW )
#define TK_DROPOUTWINDOW    ( 1ULL << TKB_DROPOUTWINDOW )

#define TKM_NONE             0x0000000000000000ULL 
#define TKM_EDGE             ( TK_RISING | TK_FALLING | TK_EDGE )
#define TKM_WINDOW           ( TK_INWINDOW | TK_OUTWINDOW | TK_DROPINWINDOW | TK_DROPOUTWINDOW )
#define TKM_ALL              ( ( 1ULL << TKN_COUNT ) - 1 ) 


#define TO_INFINITY -1 


#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 TSN_CHANNEL_COUNT    32                    


#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 ) 


typedef void(*TpCallback_t)( void* pData );

#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 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 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 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 BOOL8_FALSE 0
#define BOOL8_TRUE  1

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


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; 

#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

// work-a-round: without this line Doxygen adds the documentation below to the group above.

TpVersion_t LibGetVersion();

uint32_t LibGetConfig( uint8_t* pBuffer , uint32_t dwBufferLength );

LibTiePieStatus_t LibGetLastStatus();

const char* LibGetLastStatusStr();

// work-a-round: without this line Doxygen adds the documentation below to the group above.

uint32_t LstGetCount();

bool8_t LstGetDeviceCanOpen( uint32_t dwIdKind , uint32_t dwId , uint32_t dwDeviceType );

uint32_t LstGetDeviceProductId( uint32_t dwIdKind , uint32_t dwId );

uint32_t LstGetDeviceVendorId( uint32_t dwIdKind , uint32_t dwId );

uint32_t LstGetDeviceName( uint32_t dwIdKind , uint32_t dwId , char* pBuffer , uint32_t dwBufferLength );

uint32_t LstGetDeviceNameShort( uint32_t dwIdKind , uint32_t dwId , char* pBuffer , uint32_t dwBufferLength );

uint32_t LstGetDeviceSerialNumber( uint32_t dwIdKind , uint32_t dwId );

uint32_t LstGetDeviceTypes( uint32_t dwIdKind , uint32_t dwId );

TpDeviceHandle_t LstOpenDevice( uint32_t dwIdKind , uint32_t dwId , uint32_t dwDeviceType );

TpDeviceHandle_t LstOpenOscilloscope( uint32_t dwIdKind , uint32_t dwId );

TpDeviceHandle_t LstOpenGenerator( uint32_t dwIdKind , uint32_t dwId );

TpDeviceHandle_t LstOpenI2CHost( uint32_t dwIdKind , uint32_t dwId );

void LstRemoveDevice( uint32_t dwSerialNumber );

void LstUpdate( uint32_t dwDeviceIdMask );

// work-a-round: without this line Doxygen adds the documentation below to the group above.

void LstSetCallbackDeviceAdded( TpCallback_t pCallback , void* pData );

void LstSetCallbackDeviceRemoved( TpCallback_t pCallback , void* pData );

#ifdef HAVE_WINDOWS_H

void LstSetEventDeviceAdded( HANDLE hEvent );

void LstSetEventDeviceRemoved( HANDLE hEvent );

void LstSetMessageDeviceAdded( HWND hWnd );

void LstSetMessageDeviceRemoved( HWND hWnd );

#endif

// work-a-round: without this line Doxygen adds the documentation below to the group above.

void DevClose( TpDeviceHandle_t hDevice );

bool8_t DevIsRemoved( TpDeviceHandle_t hDevice );

TpVersion_t DevGetDriverVersion( TpDeviceHandle_t hDevice );

TpVersion_t DevGetFirmwareVersion( TpDeviceHandle_t hDevice );

TpDate_t DevGetCalibrationDate( TpDeviceHandle_t hDevice );

uint32_t DevGetSerialNumber( TpDeviceHandle_t hDevice );

uint32_t DevGetProductId( TpDeviceHandle_t hDevice );

uint32_t DevGetVendorId( TpDeviceHandle_t hDevice );

uint32_t DevGetType( TpDeviceHandle_t hDevice );

uint32_t DevGetName( TpDeviceHandle_t hDevice , char* pBuffer , uint32_t dwBufferLength );

uint32_t DevGetNameShort( TpDeviceHandle_t hDevice , char* pBuffer , uint32_t dwBufferLength );

// work-a-round: without this line Doxygen adds the documentation below to the group above.

void DevSetCallbackRemoved( TpDeviceHandle_t hDevice , TpCallback_t pCallback , void* pData );

#ifdef HAVE_WINDOWS_H

void DevSetEventRemoved( TpDeviceHandle_t hDevice , HANDLE hEvent );

void DevSetMessageRemoved( TpDeviceHandle_t hDevice , HWND hWnd , WPARAM wParam , LPARAM lParam );

#endif

// work-a-round: without this line Doxygen adds the documentation below to the group above.

uint16_t ScpGetChannelCount( TpDeviceHandle_t hDevice );

uint32_t ScpGetSharedChannelGroupCount( TpDeviceHandle_t hDevice );

uint32_t ScpGetSharedChannelGroup( TpDeviceHandle_t hDevice , uint32_t dwGroupIndex , uint16_t* pChannelNumbers , uint32_t dwLength );

bool8_t ScpChGetAutoRanging( TpDeviceHandle_t hDevice , uint16_t wCh );

bool8_t ScpChSetAutoRanging( TpDeviceHandle_t hDevice , uint16_t wCh , bool8_t bEnable );

uint32_t ScpChGetConnectorType( TpDeviceHandle_t hDevice , uint16_t wCh );

uint64_t ScpChGetCouplings( TpDeviceHandle_t hDevice , uint16_t wCh );

uint64_t ScpChGetCoupling( TpDeviceHandle_t hDevice , uint16_t wCh );

uint64_t ScpChSetCoupling( TpDeviceHandle_t hDevice , uint16_t wCh , uint64_t qwCoupling );

bool8_t ScpChGetEnabled( TpDeviceHandle_t hDevice , uint16_t wCh );

bool8_t ScpChSetEnabled( TpDeviceHandle_t hDevice , uint16_t wCh , bool8_t bEnable );

bool8_t ScpChIsDifferential( TpDeviceHandle_t hDevice , uint16_t wCh );

double ScpChGetProbeGain( TpDeviceHandle_t hDevice , uint16_t wCh );

double ScpChSetProbeGain( TpDeviceHandle_t hDevice , uint16_t wCh , double dProbeGain );

uint32_t ScpChGetRanges( TpDeviceHandle_t hDevice , uint16_t wCh , double* pList , uint32_t dwLength );

uint32_t ScpChGetRangesEx( TpDeviceHandle_t hDevice , uint16_t wCh , uint64_t qwCoupling , double* pList , uint32_t dwLength );

double ScpChGetRange( TpDeviceHandle_t hDevice , uint16_t wCh );

double ScpChSetRange( TpDeviceHandle_t hDevice , uint16_t wCh , double dRange );

// work-a-round: without this line Doxygen adds the documentation below to the group above.

uint64_t ScpGetData( TpDeviceHandle_t hDevice , float** pBuffers , uint16_t wChannelCount , uint64_t qwStartIndex , uint64_t qwSampleCount );

uint64_t ScpGetData1Ch( TpDeviceHandle_t hDevice , float* pBufferCh1 , uint64_t qwStartIndex , uint64_t qwSampleCount );

uint64_t ScpGetData2Ch( TpDeviceHandle_t hDevice , float* pBufferCh1 , float* pBufferCh2 , uint64_t qwStartIndex , uint64_t qwSampleCount );

uint64_t ScpGetData3Ch( TpDeviceHandle_t hDevice , float *pBufferCh1 , float* pBufferCh2 , float* pBufferCh3 , uint64_t qwStartIndex , uint64_t qwSampleCount );

uint64_t ScpGetData4Ch( TpDeviceHandle_t hDevice , float* pBufferCh1 , float* pBufferCh2 , float* pBufferCh3 , float* pBufferCh4 , uint64_t qwStartIndex , uint64_t qwSampleCount );

uint64_t ScpGetDataRaw( TpDeviceHandle_t hDevice , void** pBuffers , uint16_t wChannelCount , uint64_t qwStartIndex , uint64_t qwSampleCount );

uint64_t ScpGetDataRaw1Ch( TpDeviceHandle_t hDevice , void* pBufferCh1 , uint64_t qwStartIndex , uint64_t qwSampleCount );

uint64_t ScpGetDataRaw2Ch( TpDeviceHandle_t hDevice , void* pBufferCh1 , void* pBufferCh2 , uint64_t qwStartIndex , uint64_t qwSampleCount );

uint64_t ScpGetDataRaw3Ch( TpDeviceHandle_t hDevice , void* pBufferCh1 , void* pBufferCh2 , void* pBufferCh3 , uint64_t qwStartIndex , uint64_t qwSampleCount );

uint64_t ScpGetDataRaw4Ch( TpDeviceHandle_t hDevice , void* pBufferCh1 , void* pBufferCh2 , void* pBufferCh3 , void* pBufferCh4 , uint64_t qwStartIndex , uint64_t qwSampleCount );

bool8_t ScpChIsRangeMaxReachable( TpDeviceHandle_t hDevice , uint16_t wCh );

uint32_t ScpChGetDataRawType( TpDeviceHandle_t hDevice , uint16_t wCh );

uint64_t ScpGetValidPreSampleCount( TpDeviceHandle_t hDevice );

void ScpChGetDataValueRange( TpDeviceHandle_t hDevice , uint16_t wCh , double* pMin , double* pMax );

double ScpChGetDataValueMax( TpDeviceHandle_t hDevice , uint16_t wCh );

double ScpChGetDataValueMin( TpDeviceHandle_t hDevice , uint16_t wCh );

void ScpChGetDataRawValueRange( TpDeviceHandle_t hDevice , uint16_t wCh , int64_t* pMin , int64_t* pZero , int64_t* pMax );

int64_t ScpChGetDataRawValueMax( TpDeviceHandle_t hDevice , uint16_t wCh );

int64_t ScpChGetDataRawValueZero( TpDeviceHandle_t hDevice , uint16_t wCh );

int64_t ScpChGetDataRawValueMin( TpDeviceHandle_t hDevice , uint16_t wCh );

// work-a-round: without this line Doxygen adds the documentation below to the group above.

void ScpSetCallbackDataReady( TpDeviceHandle_t hDevice , TpCallback_t pCallback , void *pData );

void ScpSetCallbackDataOverflow( TpDeviceHandle_t hDevice , TpCallback_t pCallback , void *pData );

void ScpSetCallbackConnectionTestCompleted( TpDeviceHandle_t hDevice , TpCallback_t pCallback , void *pData );

#ifdef HAVE_WINDOWS_H

void ScpSetEventDataReady( TpDeviceHandle_t hDevice , HANDLE hEvent );

void ScpSetEventDataOverflow( TpDeviceHandle_t hDevice , HANDLE hEvent );

void ScpSetEventConnectionTestCompleted( TpDeviceHandle_t hDevice , HANDLE hEvent );

void ScpSetMessageDataReady( TpDeviceHandle_t hDevice , HWND hWnd , WPARAM wParam , LPARAM lParam );

void ScpSetMessageDataOverflow( TpDeviceHandle_t hDevice , HWND hWnd , WPARAM wParam , LPARAM lParam );

void ScpSetMessageConnectionTestCompleted( TpDeviceHandle_t hDevice , HWND hWnd , WPARAM wParam , LPARAM lParam );

#endif

// work-a-round: without this line Doxygen adds the documentation below to the group above.

bool8_t ScpStart( TpDeviceHandle_t hDevice );

void ScpStop( TpDeviceHandle_t hDevice );

void ScpForceTrigger( TpDeviceHandle_t hDevice );

bool8_t ScpIsDataReady( TpDeviceHandle_t hDevice );

bool8_t ScpIsDataOverflow( TpDeviceHandle_t hDevice );

bool8_t ScpIsRunning( TpDeviceHandle_t hDevice );

bool8_t ScpIsTriggered( TpDeviceHandle_t hDevice );

uint32_t ScpGetMeasureModes( TpDeviceHandle_t hDevice );

uint32_t ScpGetMeasureMode( TpDeviceHandle_t hDevice );

uint32_t ScpSetMeasureMode( TpDeviceHandle_t hDevice , uint32_t dwMeasureMode );

// work-a-round: without this line Doxygen adds the documentation below to the group above.

uint32_t ScpGetResolutions( TpDeviceHandle_t hDevice , uint8_t *pList , uint32_t dwLength );

uint8_t ScpGetResolution( TpDeviceHandle_t hDevice );

uint8_t ScpSetResolution( TpDeviceHandle_t hDevice , uint8_t byResolution );

bool8_t ScpIsResolutionEnhanced( TpDeviceHandle_t hDevice );

bool8_t ScpIsResolutionEnhancedEx( TpDeviceHandle_t hDevice , uint8_t byResolution );

// work-a-round: without this line Doxygen adds the documentation below to the group above.

uint32_t ScpGetClockSources( TpDeviceHandle_t hDevice );

uint32_t ScpGetClockSource( TpDeviceHandle_t hDevice );

uint32_t ScpSetClockSource( TpDeviceHandle_t hDevice , uint32_t dwClockSource );

uint32_t ScpGetClockOutputs( TpDeviceHandle_t hDevice );

uint32_t ScpGetClockOutput( TpDeviceHandle_t hDevice );

uint32_t ScpSetClockOutput( TpDeviceHandle_t hDevice , uint32_t dwClockOutput );

// work-a-round: without this line Doxygen adds the documentation below to the group above.

double ScpGetPreSampleRatio( TpDeviceHandle_t hDevice );

double ScpSetPreSampleRatio( TpDeviceHandle_t hDevice , double dPreSampleRatio );

uint64_t ScpGetTriggerHoldOffCountMax( TpDeviceHandle_t hDevice );

uint64_t ScpGetTriggerHoldOffCountMaxEx( TpDeviceHandle_t hDevice , uint32_t dwMeasureMode );

uint64_t ScpGetTriggerHoldOffCount( TpDeviceHandle_t hDevice );

uint64_t ScpSetTriggerHoldOffCount( TpDeviceHandle_t hDevice , uint64_t qwTriggerHoldOffCount );

uint64_t ScpGetRecordLengthMax( TpDeviceHandle_t hDevice );

uint64_t ScpGetRecordLengthMaxEx( TpDeviceHandle_t hDevice , uint32_t dwMeasureMode , uint8_t byResolution );

uint64_t ScpGetRecordLength( TpDeviceHandle_t hDevice );

uint64_t ScpSetRecordLength( TpDeviceHandle_t hDevice , uint64_t qwRecordLength );

uint64_t ScpVerifyRecordLength( TpDeviceHandle_t hDevice , uint64_t qwRecordLength );

uint64_t ScpVerifyRecordLengthEx( TpDeviceHandle_t hDevice , uint64_t qwRecordLength , uint32_t dwMeasureMode , uint8_t byResolution , uint64_t qwActiveChannelMask );

double ScpGetSampleFrequencyMax( TpDeviceHandle_t hDevice );

double ScpGetSampleFrequency( TpDeviceHandle_t hDevice );

double ScpSetSampleFrequency( TpDeviceHandle_t hDevice , double dSampleFrequency );

double ScpVerifySampleFrequency( TpDeviceHandle_t hDevice , double dSampleFrequency );

double ScpVerifySampleFrequencyEx( TpDeviceHandle_t hDevice , double dSampleFrequency , uint32_t dwMeasureMode , uint8_t byResolution , uint64_t qwActiveChannelMask );

// work-a-round: without this line Doxygen adds the documentation below to the group above.

double ScpGetTriggerTimeOut( TpDeviceHandle_t hDevice );

double ScpSetTriggerTimeOut( TpDeviceHandle_t hDevice , double dTimeout );

double ScpVerifyTriggerTimeOut( TpDeviceHandle_t hDevice , double dTimeout );

uint64_t ScpGetTriggerSources( TpDeviceHandle_t hDevice );

uint64_t ScpGetTriggerSourcesEx( TpDeviceHandle_t hDevice , uint32_t dwMeasureMode );

uint64_t ScpGetTriggerSourceOR( TpDeviceHandle_t hDevice );

uint64_t ScpSetTriggerSourceOR( TpDeviceHandle_t hDevice , uint64_t qwTriggerSourceMask );

uint64_t ScpGetTriggerSourceAND( TpDeviceHandle_t hDevice );

uint64_t ScpSetTriggerSourceAND( TpDeviceHandle_t hDevice , uint64_t qwTriggerSourceMask );

uint64_t ScpGetTriggerKinds( TpDeviceHandle_t hDevice , uint64_t qwTriggerSourceMask );

uint64_t ScpGetTriggerKindsEx( TpDeviceHandle_t hDevice , uint64_t qwTriggerSourceMask , uint32_t dwMeasureMode );

uint64_t ScpGetTriggerKind( TpDeviceHandle_t hDevice , uint64_t qwTriggerSource );

uint64_t ScpSetTriggerKind( TpDeviceHandle_t hDevice , uint64_t qwTriggerSource , uint64_t qwTriggerKind );

double ScpGetTriggerLevel( TpDeviceHandle_t hDevice , uint64_t qwTriggerSource , uint32_t dwIndex );

double ScpSetTriggerLevel( TpDeviceHandle_t hDevice , uint64_t qwTriggerSource , uint32_t dwIndex , double dLevel );

double ScpGetTriggerHysteresis( TpDeviceHandle_t hDevice , uint64_t qwTriggerSource , uint32_t dwIndex );

double ScpSetTriggerHysteresis( TpDeviceHandle_t hDevice , uint64_t qwTriggerSource , uint32_t dwIndex , double dHysteresis );

uint64_t ScpChGetTriggerKinds( TpDeviceHandle_t hDevice , uint16_t wCh );

uint64_t ScpChGetTriggerKindsEx( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwMeasureMode );

uint64_t ScpChGetTriggerKind( TpDeviceHandle_t hDevice , uint16_t wCh );

uint64_t ScpChSetTriggerKind( TpDeviceHandle_t hDevice , uint16_t wCh , uint64_t qwTriggerKind );

double ScpChGetTriggerLevel( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwIndex );

double ScpChSetTriggerLevel( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwIndex , double dLevel );

double ScpChGetTriggerHysteresis( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwIndex );

double ScpChSetTriggerHysteresis( TpDeviceHandle_t hDevice , uint16_t wCh , uint32_t dwIndex , double dHysteresis );

double ScpChGetTriggerPulseTime( TpDeviceHandle_t hDevice , uint16_t wCh );

double ScpChSetTriggerPulseTime( TpDeviceHandle_t hDevice , uint16_t wCh , double dPulseTime );

// work-a-round: without this line Doxygen adds the documentation below to the group above.

bool8_t ScpHasConnectionTest( TpDeviceHandle_t hDevice );

bool8_t ScpChHasConnectionTest( TpDeviceHandle_t hDevice , uint16_t wCh );

bool8_t ScpStartConnectionTest( TpDeviceHandle_t hDevice , uint64_t qwChannelMask );

bool8_t ScpIsConnectionTestCompleted( TpDeviceHandle_t hDevice );

uint16_t ScpGetConnectionTestData( TpDeviceHandle_t hDevice , LibTiePieTriState_t* pBuffer , uint16_t wChannelCount );

// work-a-round: without this line Doxygen adds the documentation below to the group above.

uint32_t GenGetConnectorType( TpDeviceHandle_t hDevice );

bool8_t GenIsDifferential( TpDeviceHandle_t hDevice );

double GenGetImpedance( TpDeviceHandle_t hDevice );

// work-a-round: without this line Doxygen adds the documentation below to the group above.

bool8_t GenIsControllable( TpDeviceHandle_t hDevice );

bool8_t GenGetOutputOn( TpDeviceHandle_t hDevice );

bool8_t GenSetOutputOn( TpDeviceHandle_t hDevice , bool8_t bOutputOn );

void GenStart( TpDeviceHandle_t hDevice );

void GenStop( TpDeviceHandle_t hDevice );

bool8_t GenIsBurstActive( TpDeviceHandle_t hDevice );

uint64_t GenGetBurstCount( TpDeviceHandle_t hDevice );

uint64_t GenGetBurstCountMax( TpDeviceHandle_t hDevice );

uint64_t GenSetBurstCount( TpDeviceHandle_t hDevice , uint64_t qwBurstCount );

uint32_t GenGetModes( TpDeviceHandle_t hDevice );

uint32_t GenGetModesEx( TpDeviceHandle_t hDevice , uint32_t dwSignalType );

uint32_t GenGetMode( TpDeviceHandle_t hDevice );

uint32_t GenSetMode( TpDeviceHandle_t hDevice , uint32_t dwMode );

uint32_t GenGetSignalTypes( TpDeviceHandle_t hDevice );

uint32_t GenGetSignalType( TpDeviceHandle_t hDevice );

uint32_t GenSetSignalType( TpDeviceHandle_t hDevice , uint32_t dwSignalType );

double GenGetAmplitudeMax( TpDeviceHandle_t hDevice );

double GenGetAmplitudeMin( TpDeviceHandle_t hDevice );

double GenGetAmplitude( TpDeviceHandle_t hDevice );

double GenSetAmplitude( TpDeviceHandle_t hDevice , double dAmplitude );

double GenVerifyAmplitude( TpDeviceHandle_t hDevice , double dAmplitude );

void GenGetFrequencyMinMax( TpDeviceHandle_t hDevice , uint32_t dwMode , double* pMin , double* pMax );

double GenGetFrequencyMin( TpDeviceHandle_t hDevice );

double GenGetFrequencyMax( TpDeviceHandle_t hDevice );

double GenGetFrequency( TpDeviceHandle_t hDevice );

double GenSetFrequency( TpDeviceHandle_t hDevice , double dFrequency );

double GenVerifyFrequency( TpDeviceHandle_t hDevice , double dFrequency );

double GenVerifyFrequencyEx( TpDeviceHandle_t hDevice , double dFrequency , uint32_t dwMode );

double GenGetOffsetMin( TpDeviceHandle_t hDevice );

double GenGetOffsetMax( TpDeviceHandle_t hDevice );

double GenGetOffset( TpDeviceHandle_t hDevice );

double GenSetOffset( TpDeviceHandle_t hDevice , double dOffset );

double GenVerifyOffset( TpDeviceHandle_t hDevice , double dOffset );

double GenGetPhase( TpDeviceHandle_t hDevice );

double GenSetPhase( TpDeviceHandle_t hDevice , double dPhase );

double GenVerifyPhase( TpDeviceHandle_t hDevice , double dPhase );

double GenGetSymmetry( TpDeviceHandle_t hDevice );

double GenSetSymmetry( TpDeviceHandle_t hDevice , double dSymmetry );

double GenVerifySymmetry( TpDeviceHandle_t hDevice , double dSymmetry );

// work-a-round: without this line Doxygen adds the documentation below to the group above.

void GenSetCallbackBurstCompleted( TpDeviceHandle_t hDevice , TpCallback_t pCallback , void* pData );

void GenSetCallbackControllableChanged( TpDeviceHandle_t hDevice , TpCallback_t pCallback , void* pData );

#ifdef HAVE_WINDOWS_H

void GenSetEventBurstCompleted( TpDeviceHandle_t hDevice , HANDLE hEvent );

void GenSetEventControllableChanged( TpDeviceHandle_t hDevice , HANDLE hEvent );

void GenSetMessageBurstCompleted( TpDeviceHandle_t hDevice , HWND hWnd , WPARAM wParam , LPARAM lParam );

void GenSetMessageControllableChanged( TpDeviceHandle_t hDevice , HWND hWnd , WPARAM wParam , LPARAM lParam );

#endif

// work-a-round: without this line Doxygen adds the documentation below to the group above.

bool8_t GenGetAutoRanging( TpDeviceHandle_t hDevice );

bool8_t GenSetAutoRanging( TpDeviceHandle_t hDevice , bool8_t bEnable );

uint32_t GenGetRanges( TpDeviceHandle_t hDevice , double* pList , uint32_t dwLength );

double GenGetRange( TpDeviceHandle_t hDevice );

double GenSetRange( TpDeviceHandle_t hDevice , double dRange );

// work-a-round: without this line Doxygen adds the documentation below to the group above.

uint64_t GenGetTriggerSources( TpDeviceHandle_t hDevice );

uint64_t GenGetTriggerSourceAND( TpDeviceHandle_t hDevice );

uint64_t GenSetTriggerSourceAND( TpDeviceHandle_t hDevice , uint64_t qwTriggerSourceMask );

uint64_t GenGetTriggerSourceOR( TpDeviceHandle_t hDevice );

uint64_t GenSetTriggerSourceOR( TpDeviceHandle_t hDevice , uint64_t qwTriggerSourceMask );

// work-a-round: without this line Doxygen adds the documentation below to the group above.

uint64_t GenGetDataLengthMax( TpDeviceHandle_t hDevice );

uint64_t GenGetDataLength( TpDeviceHandle_t hDevice );

uint64_t GenVerifyDataLength( TpDeviceHandle_t hDevice , uint64_t qwDataLength );

uint32_t GenGetDataRawType( TpDeviceHandle_t hDevice );

void GenSetData( TpDeviceHandle_t hDevice , float* pBuffer , uint64_t qwSampleCount );

void GenSetDataRaw( TpDeviceHandle_t hDevice , void* pBuffer , uint64_t qwSampleCount );

// work-a-round: without this line Doxygen adds the documentation below to the group above.

bool8_t I2CRead( TpDeviceHandle_t hDevice , uint16_t wAddress , void* pBuffer , uint32_t dwSize , bool8_t bStop );

bool8_t I2CReadByte( TpDeviceHandle_t hDevice , uint16_t wAddress , uint8_t* pValue );

bool8_t I2CReadWord( TpDeviceHandle_t hDevice , uint16_t wAddress , uint16_t* pValue );

bool8_t I2CWrite( TpDeviceHandle_t hDevice , uint16_t wAddress , void* pBuffer , uint32_t dwSize , bool8_t bStop );

bool8_t I2CWriteByte( TpDeviceHandle_t hDevice , uint16_t wAddress , uint8_t byValue );

bool8_t I2CWriteByteByte( TpDeviceHandle_t hDevice , uint16_t wAddress , uint8_t byValue1 , uint8_t byValue2 );

bool8_t I2CWriteByteWord( TpDeviceHandle_t hDevice , uint16_t wAddress , uint8_t byValue1 , uint16_t wValue2 );

bool8_t I2CWriteWord( TpDeviceHandle_t hDevice , uint16_t wAddress , uint16_t wValue );

double I2CGetSpeed( TpDeviceHandle_t hDevice );

double I2CGetSpeedMax( TpDeviceHandle_t hDevice );

double I2CSetSpeed( TpDeviceHandle_t hDevice , double dSpeed );

double I2CVerifySpeed( TpDeviceHandle_t hDevice , double dSpeed );

bool8_t I2CIsInternalAddress( TpDeviceHandle_t hDevice , uint16_t wAddress );

#ifdef __cplusplus
}
#endif

#endif