#ifdef SGIF_EXPORTS
#define EXP __declspec(dllexport)
#else
#define EXP __declspec(dllimport)
#endif

#include "Winsock2.h"
#include "Ws2tcpip.h"

#include <stdlib.h>
#include <stdio.h>
#include <windows.h>
#pragma comment(lib, "WS2_32.lib")

// Return Code List
typedef enum {
	RC_OK = 0x0000,				
	// The operation is completed successfully.
	///////////////////////////////////////////////
	// Communication error from controller notification
	//
	RC_NAK_COMMAND = 0x1001,		// Command error
	RC_NAK_COMMAND_LENGTH,			// Command length error
	RC_NAK_TIMEOUT,					// Timeout
	RC_NAK_CHECKSUM,				// Check sum error
	RC_NAK_INVALID_STATE,			// Status error
	RC_NAK_OTHER,					// Other error
	RC_NAK_PARAMETER,				// Parameter error
	RC_NAK_OUT_STAGE,				// OUT calculation count limitation error
	RC_NAK_OUT_HEAD_NUM,			// No. of used head/OUT over error
	RC_NAK_PARAM_RANGE_DATA_STORED,	// OUT No which data reserved over acctive out count
	RC_NAK_OUT_INVALID_CALC,		// OUT which cannot be used for calculation was specified for calculation.
	RC_NAK_OUT_VOID,				// OUT which specified for calculation is not found.
	RC_NAK_INVALID_CYCLE,			// Unavailable sampling cycle
	RC_NAK_CTRL_ERROR,				// Main unit error
	RC_NAK_SRAM_ERROR,				// Setting value error
	///////////////////////////////////////////////
	// Communication DLL error notification
	//
	RC_ERR_OPEN_DEVICE = 0x2000,// Opening the device failed.
	RC_ERR_NO_DEVICE,			// The device is not open.
	RC_ERR_SEND,				// Command sending error
	RC_ERR_RECEIVE,				// Response receiving error
	RC_ERR_TIMEOUT,				// Timeout
	RC_ERR_NODATA,				// No data
	RC_ERR_NOMEMORY,			// No free memory

	RC_ERR_DISCONNECT,			// Cable disconnection suspected
	RC_ERR_UNKNOWN,				// Undefined error
	RC_ERR_DEVID_OVER,			// over dev_id scale
	RC_ERR_NET_NO_CONN,			// no connected at the deviceID 
	RC_ERR_IP_EXISTED,
	RC_ERR_SELECT,				// select of /socket error
	RC_ERR_NULL_PARAMETER,		// NULL point exception from parameter
	RC_ERR_DIY_FUNC,			// error due to dir function
	RC_ERR_OVER_PARAMENTER,		// paramenter over the limition
	RC_ERR_NOT_SUPPORT			// ¹¦Äܲ»Ö§³Ö
} RC;

//device Version
typedef enum {
	SG3035 = 0,
	SG3030 = 1,
	SG3085 = 2,
	SG3080 = 3,
	SG5025 = 4,
	SG5020 = 5,
	SG5055 = 6,
	SG5050 = 7,
	SG5085 = 8,
	SG5080 = 9,
	SG5155 = 10,
	SG5150 = 11,
	SC04025 = 12,
	SC03560 = 13,
	SGI500 = 14,
	SGI505 = 15,
	SGI400 = 16,
	SGI405 = 17,
	SGI150 = 18,
	SGI155 = 19,
	SGI080 = 20,
	SGI085 = 21,
	SGI050 = 22,
	SGI055 = 23,
	SGI030 = 24,
	SGI035 = 25,
	SGI020 = 26,
	SGI025 = 27,
	SG3155 = 28,
	SG3150 = 29,
	SC01045 = 30,
	SC10015 = 31,
	SC20011 = 32,
	SC01236 = 33,
	SCI04025 = 34,
	SCI03560 = 35,
	SCI01045 = 36,
	SCI10015 = 37,
	SCI20011 = 38,
	SCI01236 = 39,
}SGIF_DEVICE_TYPE;

// Measurement value structures
typedef enum {
	SGIF_FLOATRESULT_VALID,			// valid data
	SGIF_FLOATRESULT_RANGEOVER_P,	// over range at positive (+) side
	SGIF_FLOATRESULT_RANGEOVER_N,	// over range at negative (-) side
	SGIF_FLOATRESULT_WAITING,		// Wait for comparator result
	SGIF_FLOATRESULT_ALARM,			// alarm
	SGIF_FLOATRESULT_INVALID,		// Invalid (error, etc.)
} SGIF_FLOATRESULT;

// Set ABLE
typedef enum {
	SGIF_ABLEMODE_AUTO,				// AUTO
	SGIF_ABLEMODE_MANUAL,			// manual
} SGIF_ABLEMODE;

// Set Measurement Mode
typedef enum {
	SGIF_MEASUREMODE_NORMAL,						// normal
	SGIF_MEASUREMODE_HALF_T,						// translucent object
	SGIF_MEASUREMODE_TRAN_1,						// transparent object
	SGIF_MEASUREMODE_TRAN_2,						// transparent object 2
	SGIF_MEASUREMODE_MRS,							// multireflective object
	SGIF_MEASUREMODE_OPAQUE = SGIF_MEASUREMODE_MRS,	// Semi opaque object
} SGIF_MEASUREMODE;

// Set Basic Point
typedef enum {
	SGIF_BASICPOINT_NEAR,			// NEAR
	SGIF_BASICPOINT_FAR,			// FAR
} SGIF_BASICPOINT;

// Set Mounting Mode
typedef enum {
	SGIF_REFLECTIONMODE_DIFFUSION,	// diffuse reflection
	SGIF_REFLECTIONMODE_MIRROR,		// specular reflection
} SGIF_REFLECTIONMODE;

// Set Median
typedef enum {
	SGIF_MEDIAN_OFF,				// OFF
	SGIF_MEDIAN_7,					// 7 point
	SGIF_MEDIAN_15,					// 15 point
	SGIF_MEDIAN_31,					// 31 point
} SGIF_MEDIAN;

// Set LASER CTRL group.
typedef enum {
	SGIF_LASER_CTRL_GROUP_1,		// LASER CTRL 1
	SGIF_LASER_CTRL_GROUP_2,		// LASER CTRL 2
} SGIF_LASER_CTRL_GROUP;

// Set a range.
typedef enum {
	SGIF_RANGE_CENTER,				// CENTER
	SGIF_RANGE_FAR,					// FAR
} SGIF_RANGE;

// Set Mutual Interference Prevention Group
typedef enum {
	SGIF_MUTUAL_INTERFERENCE_PREVENTION_GROUP_A,	// Group A
	SGIF_MUTUAL_INTERFERENCE_PREVENTION_GROUP_B,	// Group B
	SGIF_MUTUAL_INTERFERENCE_PREVENTION_GROUP_C,	// Group C
} SGIF_MUTUAL_INTERFERENCE_PREVENTION_GROUP;

// Set calculation method.
typedef enum {
	SGIF_CALCMETHOD_HEADA,					// head A
	SGIF_CALCMETHOD_HEADB,					// head B
	SGIF_CALCMETHOD_HEAD_HEADA_PLUS_HEADB,	// head A+head B
	SGIF_CALCMETHOD_HEAD_HEADA_MINUS_HEADB,	// head A-head B
	SGIF_CALCMETHOD_HEAD_HEADA_TRANSPARENT,	// head A transparent object
	SGIF_CALCMETHOD_HEAD_HEADB_TRANSPARENT,	// head B transparent object

	SGIF_CALCMETHOD_HEAD = 0,	// head
	SGIF_CALCMETHOD_OUT,		// OUT
	SGIF_CALCMETHOD_ADD,		// ADD
	SGIF_CALCMETHOD_SUB,		// SUB
	SGIF_CALCMETHOD_AVE,		// AVE
	SGIF_CALCMETHOD_MAX,		// MAX
	SGIF_CALCMETHOD_MIN,		// MIN
	SGIF_CALCMETHOD_PP,			// P-P
} SGIF_CALCMETHOD;

// Set Target Surface
typedef enum {
	SGIF_CALCTARGET_PEAK_1,		// peak 1
	SGIF_CALCTARGET_PEAK_2,		// peak 2
	SGIF_CALCTARGET_PEAK_3,		// peak 3
	SGIF_CALCTARGET_PEAK_4,		// peak 4
	SGIF_CALCTARGET_PEAK_1_2,	// peak 1-peak 2
	SGIF_CALCTARGET_PEAK_1_3,	// peak 1-peak 3
	SGIF_CALCTARGET_PEAK_1_4,	// peak 1-peak 4
	SGIF_CALCTARGET_PEAK_2_3,	// peak 2-peak 3
	SGIF_CALCTARGET_PEAK_2_4,	// peak 2-peak 4
	SGIF_CALCTARGET_PEAK_3_4,	// peak 3-peak 4
} SGIF_CALCTARGET;

// Set Filter Mode
typedef enum {
	SGIF_FILTERMODE_MOVING_AVERAGE,			// moving average
} SGIF_FILTERMODE;

// Specify the filter parameter. (The number of averaging for moving average, or the cutoff frequency for LPF/HPF.) 

typedef enum {
	SGIF_FILTERPARA_AVE_1 = 0,		// 1 time
	SGIF_FILTERPARA_AVE_4,			// 4 times
	SGIF_FILTERPARA_AVE_16,			// 16 times
	SGIF_FILTERPARA_AVE_64,			// 64 times
	SGIF_FILTERPARA_AVE_256,		// 256 times
	SGIF_FILTERPARA_AVE_1024,		// 1024 times
	SGIF_FILTERPARA_AVE_4096,		// 4096 times
	SGIF_FILTERPARA_AVE_16384,		// 16384 times
	SGIF_FILTERPARA_AVE_65536,		// 65536 times
	SGIF_FILTERPARA_AVE_262144,		// 262144 times

}SGIF_FILTERPARA;

// Set Trigger Mode
typedef enum {
	SGIF_TRIGGERMODE_EXT1,		// external trigger 1
	SGIF_TRIGGERMODE_EXT2,		// external trigger 2
} SGIF_TRIGGERMODE;

// Set the Measurement Mode.
typedef enum {
	SGIF_CALCMODE_NORMAL,			// normal
	SGIF_CALCMODE_PEAKHOLD,			// peak hold
	SGIF_CALCMODE_BOTTOMHOLD,		// bottom hold
	SGIF_CALCMODE_PEAKTOPEAKHOLD,	// peak-to-peak hold
	SGIF_CALCMODE_SAMPLEHOLD,		// sample hold
} SGIF_CALCMODE;

// Set Minimum Display Unit
typedef enum {
	SGIF_DISPLAYUNIT_0000_01MM = 0,	// 0.01mm
	SGIF_DISPLAYUNIT_000_001MM,		// 0.001mm
	SGIF_DISPLAYUNIT_00_0001MM,		// 0.0001mm
	SGIF_DISPLAYUNIT_0_00001MM,		// 0.00001mm
	SGIF_DISPLAYUNIT_00000_1UM,		// 0.1um
	SGIF_DISPLAYUNIT_0000_01UM,		// 0.01um
	SGIF_DISPLAYUNIT_000_001UM,		// 0.001um

} SGIF_DISPLAYUNIT;

// Specify OUT
typedef enum {
	SGIF_OUTNO_01 = 0x0001,			// OUT01
	SGIF_OUTNO_02 = 0x0002,			// OUT02
	SGIF_OUTNO_03 = 0x0004,			// OUT03
	SGIF_OUTNO_04 = 0x0008,			// OUT04
	SGIF_OUTNO_ALL = 0x000F,		// All OUTs
} SGIF_OUTNO;

// Set Storage (Cycle)
typedef enum {
	SGIF_STORAGECYCLE_1,			// sampling rate x 1
	SGIF_STORAGECYCLE_2,			// sampling rate x 2
	SGIF_STORAGECYCLE_5,			// sampling rate x 5
	SGIF_STORAGECYCLE_10,			// sampling rate x 10
	SGIF_STORAGECYCLE_20,			// sampling rate x 20
	SGIF_STORAGECYCLE_50,			// sampling rate x 50
	SGIF_STORAGECYCLE_100,			// sampling rate x 100
	SGIF_STORAGECYCLE_200,			// sampling rate x 200
	SGIF_STORAGECYCLE_500,			// sampling rate x 500
	SGIF_STORAGECYCLE_1000,			// sampling rate x 1000
	SGIF_STORAGECYCLE_TIMING,		// Timing sync
} SGIF_STORAGECYCLE;

// Set Sampling Rate
typedef enum {
	//SG5000ϵÁÐ
	SGIF_5000_SAMPLINGCYCLE_590KHZ,     // 590kHz
	SGIF_5000_SAMPLINGCYCLE_400KHZ,		// 400kHz
	SGIF_5000_SAMPLINGCYCLE_200KHZ,		// 200kHz
	SGIF_5000_SAMPLINGCYCLE_88KHZ,		// 88kHz
	SGIF_5000_SAMPLINGCYCLE_50KHZ,		// 50kHz
	SGIF_5000_SAMPLINGCYCLE_20KHZ,		// 20kHz
	SGIF_5000_SAMPLINGCYCLE_10KHZ,		// 10kHz
	SGIF_5000_SAMPLINGCYCLE_5KHZ,		// 5kHz
	SGIF_5000_SAMPLINGCYCLE_2KHZ,		// 2kHz
	SGIF_5000_SAMPLINGCYCLE_1KHZ,		// 1kHz+

	//SG3000ϵÁÐ
	SGIF_3000_SAMPLINGCYCLE_88KHZ = 10,	// 88kHz
	SGIF_3000_SAMPLINGCYCLE_50KHZ,		// 50kHz
	SGIF_3000_SAMPLINGCYCLE_20KHZ,		// 20kHz
	SGIF_3000_SAMPLINGCYCLE_10KHZ,		// 10kHz
	SGIF_3000_SAMPLINGCYCLE_5KHZ,		// 5kHz
	//SGIF_3000_SAMPLINGCYCLE_2KHZ,		// 2kHz
	SGIF_3000_SAMPLINGCYCLE_1KHZ,		// 1kHz

	//SCIϵÁÐ
	SCI_SAMPLINGCYCLE_33KHZ = 30,	// 33kHz
	SCI_SAMPLINGCYCLE_20KHZ,		// 20kHz
	SCI_SAMPLINGCYCLE_15KHZ,		// 15kHz
	SCI_SAMPLINGCYCLE_10KHZ,		// 10kHz
	SCI_SAMPLINGCYCLE_5KHZ,			// 5kHz
	SCI_SAMPLINGCYCLE_2KHZ,			// 2kHz
	SCI_SAMPLINGCYCLE_1KHZ,			// 1kHz
	SCI_SAMPLINGCYCLE_05KHZ,		// 0.5kHz
} SGIF_SAMPLINGCYCLE;

// Set Mutual interference prevention
typedef enum {
	SGIF_MUTUAL_INTERFERENCE_PREVENTION_OFF,	// OFF
	SGIF_MUTUAL_INTERFERENCE_PREVENTION_AB_ON,	// AB-ON
	SGIF_MUTUAL_INTERFERENCE_PREVENTION_ABC_ON,	// ABC-ON
} SGIF_MUTUAL_INTERFERENCE_PREVENTION;


// Set Strobe Time
typedef enum {
	SGIF_STOROBETIME_2MS,		// 2ms
	SGIF_STOROBETIME_5MS,		// 5ms
	SGIF_STOROBETIME_10MS,		// 10ms
	SGIF_STOROBETIME_20MS,		// 20ms
} SGIF_STOROBETIME;

// Mode Switch
typedef enum {
	SGIF_MODE_NORMAL,				// normal mode
	SGIF_MODE_COMMUNICATION,		// setting mode
} SGIF_MODE;


//Encoder ext
typedef enum {
	SGIF_EmRunningMode_cont,//off
	SGIF_EmRunningMode_time,
	SGIF_EmRunningMode_trig,
}SGIF_EmRunningMode;

typedef enum {
	SGIF_EmDirection_all,//+-
	SGIF_EmDirection_pos,
	SGIF_EmDirection_neg,
}SGIF_EmDirection;

typedef enum {
	SGIF_EmEncoderInput_1x1,
	SGIF_EmEncoderInput_2x1,
	SGIF_EmEncoderInput_2x2,
	SGIF_EmEncoderInput_2x4,
}SGIF_EmEncoderInput;
typedef enum {
	SGIF_EmInputTime_100 = 100,
	SGIF_EmInputTime_200 = 200,
	SGIF_EmInputTime_500 = 500,
	SGIF_EmInputTime_1000 = 1000,
	SGIF_EmInputTime_2000 = 2000,
	SGIF_EmInputTime_5000 = 5000,
	SGIF_EmInputTime_10000 = 10000,
	SGIF_EmInputTime_20000 = 20000,
}SGIF_EmInputTime;


// Measurement value
typedef struct {
	int					OutNo;			// OUT No(1-4)
	SGIF_FLOATRESULT	FloatResult;	// valid or invalid data
	float				Value;			// Measurement value
} SGIF_FLOATVALUE_OUT;

typedef struct {
	SGIF_FLOATRESULT	FloatResult;	// valid or invalid data
	float				Value;			// Measurement value
} SGIF_FLOATVALUE;

// IP address
typedef struct {
	IN_ADDR				IPAddress;
} SGIF_OPENPARAM_ETHERNET;

//Mask Minimum Display Unit(0.01mm)
#define MASKUNIT 100 

#ifdef __cplusplus
extern "C"
{
#endif
	
	EXP RC WINAPI SGIF_GetDeviceType(IN int DeviceID, OUT SGIF_DEVICE_TYPE* deviceType);

	// Measured control commands
	///
	/// \brief SGIF_GetCameraSpotType	¹â°ßÀàÐÍ(²»Ö§³ÖSCI)
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param ControlType:				Êä³ö0£ºÐ¡¹â°ß£¬1£º´ó¹â°ß
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_GetCameraSpotType(IN int DeviceID, OUT int *EissionSpotType);


	///////////////////////////////////////////////
	// Measurement control commands
	//
	// Measured value output (single)
	///
	/// \brief SGIF_GetCalcDataSingle	²âÁ¿ÖµÊä³ö
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo:					Êä³öOUT±àºÅ
	/// \param CalcData:				²âÁ¿Öµ
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_GetCalcDataSingle(IN int DeviceID, IN int OutNo, OUT SGIF_FLOATVALUE_OUT * CalcData);

	// Measured value output (multiple)
	///
	/// \brief SGIF_GetCalcDataMulti	¶à¸ö²âÁ¿ÖµÊä³ö
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo:					Êä³öOUT±àºÅ×éºÏ
	/// \param CalcData:				²âÁ¿ÖµÊý×é
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_GetCalcDataMulti(IN int DeviceID, IN SGIF_OUTNO OutNo, OUT SGIF_FLOATVALUE_OUT * CalcData);

	// Measured value output (ALL)
	///
	/// \brief SGIF_GetCalcDataALL		È«²¿²âÁ¿ÖµÊä³ö
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param CalcData:				²âÁ¿ÖµÊý×é
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_GetCalcDataALL(IN int DeviceID, OUT SGIF_FLOATVALUE_OUT * CalcData);

	// Timing ON/OFF (single)
	///
	/// \brief SGIF_SetTimingSingle		¼ÆʱON/OFF(Ò»¸ö)
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo:					Êä³öOUT±àºÅ
	/// \param OnOff:					¿ª»ò¹Ø
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_SetTimingSingle(IN int DeviceID, IN int OutNo, IN BOOL OnOff);

	// Timing ON/OFF (multiple)
	///
	/// \brief SGIF_SetTimingMulti		¼ÆʱON/OFF(¶à¸ö)
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo:					Êä³öOUT±àºÅ×éºÏ
	/// \param OnOff:					¿ª»ò¹Ø
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_SetTimingMulti(IN int DeviceID, IN SGIF_OUTNO OutNo, IN BOOL OnOff);

	// Timing ON/OFF (synchronous)
	///
	/// \brief SGIF_SetTimingSync		¼ÆʱON/OFF(ͬ²½)
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OnOff:					¿ª»ò¹Ø
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_SetTimingSync(IN int DeviceID, IN BOOL OnOff);

	// Auto-zero ON/OFF (single)
	///
	/// \brief SGIF_SetZeroSingle		×Ô¶¯¹éÁ㣨һ¸ö£©
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo:					Êä³öOUT±àºÅ
	/// \param OnOff:					¿ª»ò¹Ø
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_SetZeroSingle(IN int DeviceID, IN int OutNo, IN BOOL OnOff);

	// Auto-zero ON/OFF (multiple)
	///
	/// \brief SGIF_SetZeroMulti		×Ô¶¯¹éÁ㣨¶à¸ö£©
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo:					Êä³öOUT±àºÅ×éºÏ
	/// \param OnOff:					¿ª»ò¹Ø
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_SetZeroMulti(IN int DeviceID, IN SGIF_OUTNO OutNo, IN BOOL OnOff);

	// Auto-zero ON/OFF (synchronous)
	///
	/// \brief SGIF_SetZeroSync			×Ô¶¯¹éÁ㣨ͬ²½£©
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OnOff:					¿ª»ò¹Ø
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_SetZeroSync(IN int DeviceID, IN BOOL OnOff);

	// Measured value reset (single)
	///
	/// \brief SGIF_SetResetSingle		ÖØÖã¨Ò»¸ö£©
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo:					Êä³öOUT±àºÅ
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_SetResetSingle(IN int DeviceID, IN int OutNo);

	// Measured value reset (multiple)
	///
	/// \brief SGIF_SetResetMulti		ÖØÖ㨶à¸ö£©
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo:					Êä³öOUT±àºÅ×éºÏ
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_SetResetMulti(IN int DeviceID, IN SGIF_OUTNO OutNo);

	// Measured value reset (synchronous)
	///
	/// \brief SGIF_SetResetSync		ÖØÖã¨Í¬²½£©
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_SetResetSync(IN int DeviceID);

	// Program Change
	///
	/// \brief SGIF_SetProgramNo		³ÌÐòÇл»
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param ProgramNo:				³ÌÐò±àºÅ£¨0µ½7£©
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_SetProgramNo(IN int DeviceID, IN int ProgramNo);

	// Program Check
	///
	/// \brief SGIF_GetProgramNo		³ÌÐòÈ·ÈÏ
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param ProgramNo:				³ÌÐò±àºÅ£¨0µ½7£©
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_GetProgramNo(IN int DeviceID, OUT int * ProgramNo);

	// Starting the Data Storage
	///
	/// \brief SGIF_DataStorageStart	Êý¾Ý´æ´¢¿ªÊ¼
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_DataStorageStart(IN int DeviceID);

	// Stopping the Data Storage
	///
	/// \brief SGIF_DataStorageStop		Êý¾Ý´æ´¢Í£Ö¹
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_DataStorageStop(IN int DeviceID);

	// Outputting the Data Storage
	///
	/// \brief SGIF_DataStorageGetData	Êý¾Ý´æ´¢Êý¾ÝÊä³ö
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo					Êä³öOUT±àºÅ
	/// \param NumOfBuffer				»º³åÇø´óС£¨×î¶à¿É½ÓÊܶàÉÙ¸öÊý¾Ý£©
	/// \param OutBuffer				Êý¾ÝÊý×é
	/// \param NumReceived				ʵ¼Ê½ÓÊÕµÄÊý¾Ý¸öÊý
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_DataStorageGetData(IN int DeviceID, IN int OutNo, IN int NumOfBuffer, OUT float * OutBuffer, OUT int *NumReceived);
 
	// Initializing the Data Storage
	///
	/// \brief SGIF_DataStorageInit		Êý¾Ý´æ´¢³õʼ»¯
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_DataStorageInit(IN int DeviceID);

	// Data Storage Accumulation Status Output	
	///
	/// \brief SGIF_DataStorageGetStatus	Êý¾Ý´æ´¢×´Ì¬Êä³ö
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param lsStorage					´æ´¢×´Ì¬
	/// \param NumStorageData				¸÷Êä³ö¿Ú´æ´¢ÊýÁ¿Êý×é
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///
	EXP RC WINAPI SGIF_DataStorageGetStatus(IN int DeviceID, OUT BOOL * lsStorage, OUT int  * NumStorageData);

	///////////////////////////////////////////////
	// Setting change commands
	//

	// Set Tolerance
	///
	/// \brief SGIF_SetTolerance			¹«²îÉ趨
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo						Êä³öOUT±àºÅ
	/// \param UpperLimit					ÉÏÏÞ£¬´«ÈëΪÓÐЧÊý×Ö£¨È¥µôСÊýµãºóµÄÕûÐΣ©
	/// \param LowerLimit					ÏÂÏÞ£¬´«ÈëΪÓÐЧÊý×Ö£¨È¥µôСÊýµãºóµÄÕûÐΣ©
	/// \param Hystersys					Öͺ󣬴«ÈëΪÓÐЧÊý×Ö£¨È¥µôСÊýµãºóµÄÕûÐΣ©
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///
	EXP RC WINAPI SGIF_SetTolerance(IN int DeviceID, IN int OutNo, IN int UpperLimit, IN int LowerLimit, IN int Hystersys);

	// Set ABLE
	///
	/// \brief SGIF_SetAbleMode				AbleģʽÉ趨
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param HeadNo						´«¸ÐÍ·±àºÅ
	/// \param AbleMode						ģʽ
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///
	EXP RC WINAPI SGIF_SetAbleMode(IN int DeviceID, IN int HeadNo, IN SGIF_ABLEMODE AbleMode);

	// Set ABLE Control Range
	///
	/// \brief SGIF_SetAbleMinMax			Able¿ØÖÆ·¶Î§É趨
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param HeadNo						´«¸ÐÍ·±àºÅ
	/// \param Min							ÏÂÏÞ
	/// \param Max							ÉÏÏÞ
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///
	EXP RC WINAPI SGIF_SetAbleMinMax(IN int DeviceID, IN int HeadNo, IN int Min, IN int Max);

	// Set Detection mode
	///
	/// \brief SGIF_SetMeasureMode			²âÁ¿Ä£Ê½É趨
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param HeadNo						´«¸ÐÍ·±àºÅ
	/// \MeasureMode                        ²âÁ¿Ä£Ê½
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///
	EXP RC WINAPI SGIF_SetMeasureMode(IN int DeviceID, IN int HeadNo, IN SGIF_MEASUREMODE MeasureMode);

	// Set Base point
	///
	/// \brief SGIF_SetBasicPoint			»ù×¼µãÉ趨
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param HeadNo						´«¸ÐÍ·±àºÅ
	/// \param BasicPoint					»ù×¼µã
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///
	EXP RC WINAPI SGIF_SetBasicPoint(IN int DeviceID, IN int HeadNo, IN SGIF_BASICPOINT BasicPoint);

	// Set Number of Times of Alarm Processing
	///
	/// \brief SGIF_SetNumAlarm				¾¯±¨ÊýÁ¿É趨
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param HeadNo						´«¸ÐÍ·±àºÅ
	/// \param AlarmNum						¾¯±¨ÊýÁ¿
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///
	EXP RC WINAPI SGIF_SetNumAlarm(IN int DeviceID, IN int HeadNo, IN int AlarmNum);

	// Set Number of Times of Alarm Recovery
	///
	/// \brief SGIF_SetNumRecovery			»Ö¸´ÊýÁ¿É趨
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param HeadNo						´«¸ÐÍ·±àºÅ
	/// \param RecoveryNum					»Ö¸´´ÎÊý
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///
	EXP RC WINAPI SGIF_SetNumRecovery(IN int DeviceID, IN int HeadNo, IN int RecoveryNum);

	// Set Alarm Level
	///
	/// \brief SGIF_SetAlarmLevel			¾¯±¨¼¶±ðÉ趨
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param HeadNo						´«¸ÐÍ·±àºÅ
	/// \param AlarmLevel					¾¯±¨¼¶±ð
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///
	EXP RC WINAPI SGIF_SetAlarmLevel(IN int DeviceID, IN int HeadNo, IN int AlarmLevel);

	// Starting the ABLE Calibration
	///
	/// \brief SGIF_AbleStart				AbleУ׼¿ªÊ¼
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param HeadNo						´«¸ÐÍ·±àºÅ
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///
	EXP RC WINAPI SGIF_AbleStart(IN int DeviceID, IN int HeadNo);

	// Finishing the ABLE Calibration
	///
	/// \brief SGIF_AbleStop				AbleУ׼Íê³É
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///
	EXP RC WINAPI SGIF_AbleStop(IN int DeviceID);

	// Stopping the ABLE Calibration
	///
	/// \brief SGIF_AbleCancel				AbleУ׼ֹͣ
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///
	EXP RC WINAPI SGIF_AbleCancel(IN int DeviceID);

	// Set Mounting Mode
	///
	/// \brief SGIF_SetReflectionMode		°²×°Ä£Ê½É趨
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param HeadNo						´«¸ÐÍ·±àºÅ
	/// \param ReflectionMode				·´Éäģʽ
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///
	EXP RC WINAPI SGIF_SetReflectionMode(IN int DeviceID, IN int HeadNo, IN SGIF_REFLECTIONMODE ReflectionMode);

	// Set Mask
	///
	/// \brief SGIF_SetMask					ÆÁ±ÎÉ趨
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param HeadNo						´«¸ÐÍ·±àºÅ
	/// \param OnOff						¿ª¹Ø
	/// \param HeadNo						µãλ1
	/// \param HeadNo						µãλ2
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///
	EXP RC WINAPI SGIF_SetMask(IN int DeviceID, IN int HeadNo, IN BOOL OnOff, IN int Pos1, IN int Pos2);

	// Set Median
	///
	/// \brief SGIF_SetMedian				ÖÐλÊýÉ趨
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param HeadNo						´«¸ÐÍ·±àºÅ
	/// \param Median						ÖÐλÊý
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///
	EXP RC WINAPI SGIF_SetMedian(IN int DeviceID, IN int HeadNo, IN SGIF_MEDIAN Median);

	// Set LASER CTRL group
	///
	/// \brief SGIF_SetLaserCtrlGroup		Laser Ctrl×éÉ趨
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param HeadNo						´«¸ÐÍ·±àºÅ
	/// \param LaserCtrlGroup				Laser Ctrl×é
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///  
	EXP RC WINAPI SGIF_SetLaserCtrlGroup(IN int DeviceID, IN int HeadNo, IN SGIF_LASER_CTRL_GROUP LaserCtrlGroup);

	// Set Mutual interference prevention group
	///
	/// \brief SGIF_SetMutualInterferencePreventionGroup		·ÀÖ¹»¥Ïà¸ÉÈÅ×éÉ趨
	/// \param DeviceID											É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param HeadNo											´«¸ÐÍ·±àºÅ
	/// \param Group											×é
	/// \return
	///     >0:													ʧ°Ü.
	///     =0:													³É¹¦.
	///  
	EXP RC WINAPI SGIF_SetMutualInterferencePreventionGroup(IN int DeviceID, IN int HeadNo, IN SGIF_MUTUAL_INTERFERENCE_PREVENTION_GROUP Group);

	// Set Calculation method
	///
	/// \brief SGIF_SetCalcMethod		¼ÆË㷽ʽÉ趨
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo					Êä³öOUT±àºÅ
	/// \param CalcMethod				¼ÆËã·½·¨
	/// \param HeadOutNo				´«¸ÐÍ·Êä³ö±àºÅ
	/// \return
	///     >0:													ʧ°Ü.
	///     =0:													³É¹¦.
	///  
	EXP RC WINAPI SGIF_SetCalcMethod(IN int DeviceID, IN int OutNo, IN SGIF_CALCMETHOD CalcMethod, IN int HeadOutNo);

	// Set Surface to be measured
	///
	/// \brief SGIF_SetCalcTarget		²âÁ¿Ä¿±êÉ趨
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo					Êä³öOUT±àºÅ
	/// \param CalcTarget				¼ÆËã±êÇ©
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///  
	EXP RC WINAPI SGIF_SetCalcTarget(IN int DeviceID, IN int OutNo, IN SGIF_CALCTARGET CalcTarget);

	// Set OUT to be calculated (ADD, SUB)
	///
	/// \brief SGIF_SetOutAddSub		´ý¼ÆËãµÄOUT(Add,Sub)É趨
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo					Êä³öOUT±àºÅ
	/// \param AddSub1					´ý¼ÆËãµÄOUT
	/// \param AddSub2					´ý¼ÆËãµÄOUT
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///  
	EXP RC WINAPI SGIF_SetOutAddSub(IN int DeviceID, IN int OutNo, IN int AddSub1, IN int AddSub2);

	// Set OUT to be calculated (AVE, MAX, MIN, P-P)
	///
	/// \brief SGIF_SetOutOperation		´ý¼ÆËãµÄOUT(Ave,Max,Min,P-P)É趨
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo					Êä³öOUT±àºÅ
	/// \param TargetOut				¶à¸öOUT×éºÏ
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///  
	EXP RC WINAPI SGIF_SetOutOperation(IN int DeviceID, IN int OutNo, IN SGIF_OUTNO TargetOut);

	// Set Scaling
	///
	/// \brief SGIF_SetScaling			Ëõ·ÅÉ趨
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo					Êä³öOUT±àºÅ
	/// \param InputValue1				µã1µÄ²âÁ¿Öµ£¨ÊäÈëÖµ£©£¬´«ÓÐЧÊý×Ö£¨È¥µôСÊýµãºóµÄÕûÐΣ©
	/// \param OutputValue1				µã1µÄÏÔʾֵ£¨Êä³öÖµ£©£¬´«ÓÐЧÊý×Ö£¨È¥µôСÊýµãºóµÄÕûÐΣ©
	/// \param InputValue2				µã2µÄ²âÁ¿Öµ£¨ÊäÈëÖµ£©£¬´«ÓÐЧÊý×Ö£¨È¥µôСÊýµãºóµÄÕûÐΣ©
	/// \param OutputValue2				µã2µÄÏÔʾֵ£¨Êä³öÖµ£©£¬´«ÓÐЧÊý×Ö£¨È¥µôСÊýµãºóµÄÕûÐΣ©
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///  
	EXP RC WINAPI SGIF_SetScaling(IN int DeviceID, IN int OutNo, IN int InputValue1, IN int OutputValue1, IN int InputValue2, IN int OutputValue2);

	// Set Filter Mode
	///
	/// \brief SGIF_SetFilter			Â˲¨Æ÷É趨
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo					Êä³öOUT±àºÅ
	/// \param FilterMode				Â˲¨Ä£Ê½
	/// \param FilterPara				Â˲¨²ÎÊý
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///  
	EXP RC WINAPI SGIF_SetFilter(IN int DeviceID, IN int OutNo, IN SGIF_FILTERMODE FilterMode, IN SGIF_FILTERPARA FilterPara);

	// Set Trigger Mode
	///
	/// \brief SGIF_SetTriggerMode		´¥·¢Ä£Ê½É趨
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo					Êä³öOUT±àºÅ
	/// \param TriggerMode				´¥·¢Ä£Ê½
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///  
	EXP RC WINAPI SGIF_SetTriggerMode(IN int DeviceID, IN int OutNo, IN SGIF_TRIGGERMODE TriggerMode);

	// Set Offset
	///
	/// \brief SGIF_SetOffset			Æ«ÒÆÉ趨
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo					Êä³öOUT±àºÅ
	/// \param Offset					Æ«ÒÆÁ¿
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///  
	EXP RC WINAPI SGIF_SetOffset(IN int DeviceID, IN int OutNo, IN int Offset);

	// Set Calculation Mode
	///
	/// \brief SGIF_SetCalcMode			¼ì²âģʽ£¨²âÁ¿Ä£Ê½£©É趨
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo					Êä³öOUT±àºÅ
	/// \param CalcMode					¼ì²âģʽ±àºÅ
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///  
	EXP RC WINAPI SGIF_SetCalcMode(IN int DeviceID, IN int OutNo, IN SGIF_CALCMODE CalcMode);

	// Set Minimum Display Unit
	///
	/// \brief SGIF_SetDisplayUnit		É趨ÏÔʾµ¥Î»É趨
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo					Êä³öOUT±àºÅ
	/// \param DisplayUnit				ÏÔʾµ¥Î»
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///  
	EXP RC WINAPI SGIF_SetDisplayUnit(IN int DeviceID, IN int OutNo, IN SGIF_DISPLAYUNIT DisplayUnit);

	// Set Synchronization
	///
	/// \brief SGIF_SetSynchronization		ͬ²½É趨
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo						Êä³öOUT±àºÅ
	/// \param OnOff						¿ª¹Ø
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///  
	EXP RC WINAPI SGIF_SetSynchronization(IN int DeviceID, IN int OutNo, IN BOOL OnOff);

	// Set Storage (OUT No. specification)
	///
	/// \brief SGIF_SetStorageTarget		´æ´¢£¨OUT±àºÅ¹æ¸ñ£©É趨
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo						Êä³öOUT±àºÅ
	/// \param OnOff						¿ª¹Ø
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///  
	EXP RC WINAPI SGIF_SetStorageTarget(IN int DeviceID, IN int OutNo, IN BOOL OnOff);

	// Set Sampling Rate
	///
	/// \brief SGIF_SetSamplingCycle		²ÉÑùÖÜÆÚÉ趨
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param SamplingCycle				²ÉÑùÖÜÆÚ
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///  
	EXP RC WINAPI SGIF_SetSamplingCycle(IN int DeviceID, IN SGIF_SAMPLINGCYCLE SamplingCycle);

	// Set Mutual Interference Prevention
	///
	/// \brief SGIF_SetMutualInterferencePrevention		·ÀÖ¹»¥Ïà¸ÉÈÅ×éÉ趨
	/// \param DeviceID									É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OnOff									×éÉ趨
	/// \return
	///     >0:											ʧ°Ü.
	///     =0:											³É¹¦.
	///  
	EXP RC WINAPI SGIF_SetMutualInterferencePrevention(IN int DeviceID, IN SGIF_MUTUAL_INTERFERENCE_PREVENTION OnOff);

	// Set Strobe Time
	///
	/// \brief SGIF_SetStrobeTime			ѡͨʱ¼äÉ趨
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param StrobeTime					ѡͨʱ¼ä
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///  
	EXP RC WINAPI SGIF_SetStrobeTime(IN int DeviceID, IN SGIF_STOROBETIME StrobeTime);

	// Set Data Storage
	///
	/// \brief SGIF_SetDataStorage			Êý¾Ý´æ´¢É趨
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param NumStorage					´ý´æ´¢Êý¾ÝµÄ±àºÅ
	/// \param StorageCycle					´æ´¢ÖÜÆÚ
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///  
	EXP RC WINAPI SGIF_SetDataStorage(IN int DeviceID, IN int NumStorage, IN SGIF_STORAGECYCLE StorageCycle);

	// EncoderSetting
	///
	/// \brief SGIF_SetRunningMode			ÔËÐÐģʽÉèÖÃ(²»Ö§³ÖSCIÉ豸)
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param runningmode					ÔËÐÐģʽ 0:OFF/1:¶¨Ê±/2:´¥·¢
	/// \param CatchDirection               ¼ì²â·½Ïò 0:Õý¸º¼Æʱ/1:Õý¼Æʱ/2:¸º¼Æʱ
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///  
	EXP RC WINAPI SGIF_SetRunningMode(IN int DeviceID, IN SGIF_EmRunningMode Runningmode, IN SGIF_EmDirection CatchDirection);


	// EncoderInputSetting
	///
	/// \brief SGIF_SetEncoderMode			±àÂëÆ÷ÊäÈëģʽÉèÖÃ(²»Ö§³ÖSCIÉ豸)
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param Inputmode					ÔËÐÐģʽ 0:1Ïà1µÝÔö/1:2Ïà1µÝÔö/2:2Ïà2µÝÔö,3:2Ïà4µÝÔö
	/// \param MinInputTime					×îСÊäÈëʱ¼ä
	/// \param TrigInterval					´¥·¢¼ä¸ô
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///  

	EXP RC WINAPI SGIF_SetEncoderMode(IN int DeviceID, IN SGIF_EmEncoderInput Inputmode,IN SGIF_EmInputTime InputTime,IN int TrigInterval);

	// SGIF_SetFormula
	///
	/// \brief SGIF_SetFormula				ÉèÖÃÅä·½
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param filePath						Å䷽·¾¶
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///  derive

	EXP RC WINAPI SGIF_SetFormula(IN int DeviceID, IN char* filePath );

	// SGIF_SetFormula
	///
	/// \brief SGIF_SetFormula				ÉèÖÃÅä·½
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param filePath						Å䷽·¾¶
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///  
	EXP RC WINAPI SGIF_DeriveFormula(IN int DeviceID, IN char* filePath);
	///////////////////////////////////////////////
	// Setting confirmation commands
	//
	// Get Tolerance
	///
	/// \brief SGIF_GetTolerance			¹«²îÉ趨»ñÈ¡
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo						Êä³öOUT±àºÅ
	/// \param UpperLimit					ÉÏÏÞ£¬´«³öΪÓÐЧÊý×Ö£¨È¥µôСÊýµãºóµÄÕûÐΣ©
	/// \param LowerLimit					ÏÂÏÞ£¬´«³öΪÓÐЧÊý×Ö£¨È¥µôСÊýµãºóµÄÕûÐΣ©
	/// \param Hysteresis					Öͺ󣬴«³öΪÓÐЧÊý×Ö£¨È¥µôСÊýµãºóµÄÕûÐΣ©
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///  
	EXP RC WINAPI SGIF_GetTolerance(IN int DeviceID, IN int OutNo, OUT int * UpperLimit, OUT int * LowerLimit, OUT int * Hysteresis);

	// Get ABLE
	///
	/// \brief SGIF_GetAbleMode				AbleÉ趨»ñÈ¡
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param HeadNo						´«¸ÐÍ·±àºÅ
	/// \param AbleMode						Ableģʽ
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///  
	EXP RC WINAPI SGIF_GetAbleMode(IN int DeviceID, IN int HeadNo, OUT SGIF_ABLEMODE * AbleMode);

	// Get ABLE Control Range
	///
	/// \brief SGIF_GetAbleMinMax			Able¿ØÖÆ·¶Î§»ñÈ¡
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param HeadNo						´«¸ÐÍ·±àºÅ
	/// \param Min							×îСֵ
	/// \param Max							×î´óÖµ
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///  
	EXP RC WINAPI SGIF_GetAbleMinMax(IN int DeviceID, IN int HeadNo, OUT int * Min, OUT int * Max);

	// Get Detection mode
	///
	/// \brief SGIF_GetMeasureMode			²âÁ¿Ä£Ê½»ñÈ¡
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param HeadNo						´«¸ÐÍ·±àºÅ
	/// \param MeasureMode					²âÁ¿Ä£Ê½
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///  
	EXP RC WINAPI SGIF_GetMeasureMode(IN int DeviceID, IN int HeadNo, OUT SGIF_MEASUREMODE * MeasureMode);

	// Get Base point
	///
	/// \brief SGIF_GetBasicPoint			»ù×¼µã»ñÈ¡
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param HeadNo						´«¸ÐÍ·±àºÅ
	/// \param BasicPoint					»ù×¼µã
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///  
	EXP RC WINAPI SGIF_GetBasicPoint(IN int DeviceID, IN int HeadNo, OUT SGIF_BASICPOINT * BasicPoint);

	// Get Number of Times of Alarm Processing
	///
	/// \brief SGIF_GetNumAlarm				¾¯±¨´¦Àí´ÎÊý»ñÈ¡
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param HeadNo						´«¸ÐÍ·±àºÅ
	/// \param AlarmNum						¾¯±¨´ÎÊý
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///  
	EXP RC WINAPI SGIF_GetNumAlarm(IN int DeviceID, IN int HeadNo, OUT int * AlarmNum);

	// Get Number of Times of Alarm Recovery
	///
	/// \brief SGIF_GetNumRecovery			¾¯±¨»Ö¸´´ÎÊý»ñÈ¡
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param HeadNo						´«¸ÐÍ·±àºÅ
	/// \param RecoveryNum					»Ö¸´´ÎÊý
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///  
	EXP RC WINAPI SGIF_GetNumRecovery(IN int DeviceID, IN int HeadNo, OUT int * RecoveryNum);

	// Get Alarm Level
	///
	/// \brief SGIF_GetAlarmLevel			¾¯±¨¼¶±ð»ñÈ¡
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param HeadNo						´«¸ÐÍ·±àºÅ
	/// \param AlarmLevel					¾¯±¨¼¶±ð
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///  
	EXP RC WINAPI SGIF_GetAlarmLevel(IN int DeviceID, IN int HeadNo, OUT int * AlarmLevel);

	// Get Mounting Mode
	///
	/// \brief SGIF_GetReflectionMode		°²×°Ä£Ê½»ñÈ¡
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param HeadNo						´«¸ÐÍ·±àºÅ
	/// \param ReflectionMode				·´Éäģʽ
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///  
	EXP RC WINAPI SGIF_GetReflectionMode(IN int DeviceID, IN int HeadNo, OUT SGIF_REFLECTIONMODE * ReflectionMode);

	// Get Mask
	///
	/// \brief SGIF_GetMask					ÆÁ±ÎÉ趨»ñÈ¡
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param HeadNo						´«¸ÐÍ·±àºÅ
	/// \param OnOff						¿ª¹Ø
	/// \param Pos1							λÖÃ1
	/// \param Pos2							λÖÃ2
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///  
	EXP RC WINAPI SGIF_GetMask(IN int DeviceID, IN int HeadNo, OUT BOOL * OnOff, OUT int * Pos1, OUT int * Pos2);

	// Get Median
	///
	/// \brief SGIF_GetMedian				ÖÐλÊý»ñÈ¡
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param HeadNo						´«¸ÐÍ·±àºÅ
	/// \param Median						ÖÐλÊý
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///  
	EXP RC WINAPI SGIF_GetMedian(IN int DeviceID, IN int HeadNo, OUT SGIF_MEDIAN * Median);

	// Get LASER CTRL group
	///
	/// \brief SGIF_GetLaserCtrlGroup		Laser Ctrl×é»ñÈ¡
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param HeadNo						´«¸ÐÍ·±àºÅ
	/// \param LaserCtrlGroup				Laser Ctrl×é
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///  
	EXP RC WINAPI SGIF_GetLaserCtrlGroup(IN int DeviceID, IN int HeadNo, OUT SGIF_LASER_CTRL_GROUP * LaserCtrlGroup);

	// Get Mutual interference prevention group
	///
	/// \brief SGIF_GetMutualInterferencePreventionGroup	·ÀÖ¹»¥Ïà¸ÉÈÅ×é»ñÈ¡
	/// \param DeviceID										É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param HeadNo										´«¸ÐÍ·±àºÅ
	/// \param Group										×é
	/// \return
	///     >0:												ʧ°Ü.
	///     =0:												³É¹¦.
	///  
	EXP RC WINAPI SGIF_GetMutualInterferencePreventionGroup(IN int DeviceID, IN int HeadNo, OUT SGIF_MUTUAL_INTERFERENCE_PREVENTION_GROUP * Group);

	// Get Calculation method
	///
	/// \brief SGIF_GetCalcMethod		¼ÆË㷽ʽ»ñÈ¡
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo					Êä³öOUT±àºÅ
	/// \param CalcMethod				¼ÆËã·½·¨
	/// \param HeadOutNo				´«¸ÐÍ·»òOUT±àºÅ
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///  
	EXP RC WINAPI SGIF_GetCalcMethod(IN int DeviceID, IN int OutNo, OUT SGIF_CALCMETHOD * CalcMethod, OUT int * HeadOutNo);

	// Get Surface to be measured
	///
	/// \brief SGIF_GetCalcTarget		²âÁ¿Ä¿±ê»ñÈ¡
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo					Êä³öOUT±àºÅ
	/// \param CalcTarget				¼ÆËã±êÇ©
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///  
	EXP RC WINAPI SGIF_GetCalcTarget(IN int DeviceID, IN int OutNo, OUT SGIF_CALCTARGET * CalcTarget);

	// Get OUT to be calculated (ADD, SUB)
	///
	/// \brief SGIF_GetOutAddSub		´ý¼ÆËãµÄOUT(Add,Sub)»ñÈ¡
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo					Êä³öOUT±àºÅ
	/// \param AddSub1					´ý¼ÆËãµÄOUT±àºÅ1
	/// \param AddSub2					´ý¼ÆËãµÄOUT±àºÅ2
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///  
	EXP RC WINAPI SGIF_GetOutAddSub(IN int DeviceID, IN int OutNo, OUT int * AddSub1, OUT int * AddSub2);

	// Get OUT to be calculated (AVE, MAX, MIN, P-P)
	///
	/// \brief SGIF_GetOutOperation		´ý¼ÆËãµÄOUT(Ave,Max,Min,P-P)»ñÈ¡
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo					Êä³öOUT±àºÅ
	/// \param TargetOut				¶à¸öOUT»òHEAD×éºÏ
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///  
	EXP RC WINAPI SGIF_GetOutOperation(IN int DeviceID, IN int OutNo, OUT SGIF_OUTNO * TargetOut);

	// Get Scaling
	///
	/// \brief SGIF_GetScaling			Ëõ·ÅÉ趨»ñÈ¡
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo					Êä³öOUT±àºÅ
	/// \param InputValue1				µã1µÄ²âÁ¿Öµ£¨ÊäÈëÖµ£©£¬´«³öΪÓÐЧÊý×Ö£¨È¥µôСÊýµãºóµÄÕûÐΣ©
	/// \param OutputValue1				µã1µÄÏÔʾֵ£¨Êä³öÖµ£©£¬´«³öΪÓÐЧÊý×Ö£¨È¥µôСÊýµãºóµÄÕûÐΣ©
	/// \param InputValue2				µã2µÄ²âÁ¿Öµ£¨ÊäÈëÖµ£©£¬´«³öΪÓÐЧÊý×Ö£¨È¥µôСÊýµãºóµÄÕûÐΣ©
	/// \param OutputValue2				µã2µÄÏÔʾֵ£¨Êä³öÖµ£©£¬´«³öΪÓÐЧÊý×Ö£¨È¥µôСÊýµãºóµÄÕûÐΣ©
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///  
	EXP RC WINAPI SGIF_GetScaling(IN int DeviceID, IN int OutNo, OUT int * InputValue1, OUT int * OutputValue1, OUT int * InputValue2, OUT int * OutputValue2);

	// Get Filter Mode
	///
	/// \brief SGIF_GetFilter			Â˲¨Æ÷É趨»ñÈ¡
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo					Êä³öOUT±àºÅ
	/// \param FilterMode				Â˲¨Æ÷ģʽ
	/// \param FilterPara				Â˲¨²ÎÊý
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///  
	EXP RC WINAPI SGIF_GetFilter(IN int DeviceID, IN int OutNo, OUT SGIF_FILTERMODE * FilterMode, OUT SGIF_FILTERPARA * FilterPara);

	// Get Trigger Mode
	///
	/// \brief SGIF_GetTriggerMode		´¥·¢Ä£Ê½»ñÈ¡
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo					Êä³öOUT±àºÅ
	/// \param TriggerMode				´¥·¢Ä£Ê½
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///  
	EXP RC WINAPI SGIF_GetTriggerMode(IN int DeviceID, IN int OutNo, OUT SGIF_TRIGGERMODE * TriggerMode);

	// Get Offset
	///
	/// \brief SGIF_GetOffset			Æ«ÒÆ»ñÈ¡
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo					Êä³öOUT±àºÅ
	/// \param Offset					Æ«ÒÆÁ¿
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///  
	EXP RC WINAPI SGIF_GetOffset(IN int DeviceID, IN int OutNo, OUT int * Offset);

	// Get Calculation Mode
	///
	/// \brief SGIF_GetCalcMode			¼ì²âģʽ£¨²âÁ¿Ä£Ê½£©»ñÈ¡
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo					Êä³öOUT±àºÅ
	/// \param CalcMode					²âÁ¿Ä£Ê½
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///  
	EXP RC WINAPI SGIF_GetCalcMode(IN int DeviceID, IN int OutNo, OUT SGIF_CALCMODE * CalcMode);

	// Get Minimum Display Unit
	///
	/// \brief SGIF_GetDisplayUnit		ÏÔʾ×îСµ¥Î»»ñÈ¡
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo					Êä³öOUT±àºÅ
	/// \param DisplayUnit				ÏÔʾ×îСµ¥Î»
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///  
	EXP RC WINAPI SGIF_GetDisplayUnit(IN int DeviceID, IN int OutNo, OUT SGIF_DISPLAYUNIT * DisplayUnit);

	// Get Synchronization
	///
	/// \brief SGIF_GetSynchronization		ͬ²½É趨»ñÈ¡
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo						Êä³öOUT±àºÅ
	/// \param OnOff						¿ª¹Ø
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///  
	EXP RC WINAPI SGIF_GetSynchronization(IN int DeviceID, IN int OutNo, OUT BOOL * OnOff);

	// Get Storage (OUT No. specification)
	///
	/// \brief SGIF_GetStorageTarget		´æ´¢£¨OUT±àºÅÉ趨£©»ñÈ¡
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo						Êä³öOUT±àºÅ
	/// \param OnOff						¿ª¹Ø
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///  
	EXP RC WINAPI SGIF_GetStorageTarget(IN int DeviceID, IN int OutNo, OUT BOOL * OnOff);

	// Get Sampling Rate
	///
	/// \brief SGIF_GetSamplingCycle		²ÉÑùÖÜÆÚ»ñÈ¡
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param SamplingCycle				²ÉÑùÖÜÆÚ
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///  
	EXP RC WINAPI SGIF_GetSamplingCycle(IN int DeviceID, OUT SGIF_SAMPLINGCYCLE * SamplingCycle);

	// Get Mutual Interference Prevention
	///
	/// \brief SGIF_GetMutualInterferencePrevention		·ÀÖ¹»¥Ïà¸ÉÈÅ»ñÈ¡
	/// \param DeviceID									É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OnOff									¿ª¹Ø
	/// \return
	///     >0:											ʧ°Ü.
	///     =0:											³É¹¦.
	///  
	EXP RC WINAPI SGIF_GetMutualInterferencePrevention(IN int DeviceID, OUT SGIF_MUTUAL_INTERFERENCE_PREVENTION * OnOff);

	// Get Strobe Time
	///
	/// \brief SGIF_GetStrobeTime		ѡͨʱ¼ä»ñÈ¡
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutputFormat				Êä³öÐÎʽ
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_GetStrobeTime(IN int DeviceID, OUT SGIF_STOROBETIME * StrobeTime);

	// Get Data Storage
	///
	/// \brief SGIF_GetDataStorage		Êý¾Ý´æ´¢»ñÈ¡
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param NumStorage				´ø´æ´¢Êý¾Ý±àºÅ
	/// \param StorageCycle				´æ´¢ÖÜÆÚ
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_GetDataStorage(IN int DeviceID, OUT int * NumStorage, OUT SGIF_STORAGECYCLE * StorageCycle);

	// Get Active head count
	///
	/// \brief SGIF_GetNumOfUsedHeads		Ö÷¶¯OUT¼ÆÊý»ñÈ¡
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param NumOfUsedHeads				Ö÷¶¯OUT/´«¸ÐÍ·¼ÆÊý
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///
	EXP RC WINAPI SGIF_GetNumOfUsedHeads(IN int DeviceID, OUT int * NumOfUsedHeads);

	// Get Active OUT count
	///
	/// \brief SGIF_GetNumOfUsedOut			Ö÷¶¯´«¸ÐÍ·¼ÆÊý»ñÈ¡
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param NumOfUsedHeads				Ö÷¶¯OUT/´«¸ÐÍ·¼ÆÊý
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///
	EXP RC WINAPI SGIF_GetNumOfUsedOut(IN int DeviceID, OUT int * NumOfUsedOut);

	// Get Active Running Time
	///
	/// \brief SGIF_GetDeviceRuningTime		»ñÈ¡Ïà»úÔËÐÐʱ³¤£¬µ¥Î»s
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param HeadNo						0:¿ØÖÆÆ÷£» 1-4£º´«¸ÐÍ·±àºÅ
	/// \param RuningTime					ÔËÐÐʱ¼ä
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///
	EXP RC WINAPI SGIF_GetDeviceRuningTime(IN int DeviceID, IN int HeadNo, OUT unsigned int * RuningTime);

	///////////////////////////////////////////////
	// Other commands
	//
	// Opens the Ethernet device.
	///
	/// \brief SGIF_OpenDeviceETHER			´ò¿ªÉ豸ÍøÂçÁ¬½Ó
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OpenParam					ÍøÂçÁ¬½Ó²ÎÊý
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///
	EXP RC WINAPI SGIF_OpenDeviceETHER(IN int DeviceID, SGIF_OPENPARAM_ETHERNET * OpenParam,DWORD TIMEOUT=3);

	// Closes the currently open device.
	///
	/// \brief SGIF_CloseDevice				¹Ø±ÕÉ豸ÍøÂçÁ¬½Ó
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///
	EXP RC WINAPI SGIF_CloseDevice(IN int DeviceID);

	///////////////////////////////////////////////
	// Mode change commands
	//
	// Mode Switch
	///
	/// \brief SGIF_SetMode					ģʽÇл»
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param Mode							ģʽ
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///
	EXP RC WINAPI SGIF_SetMode(IN int DeviceID, IN SGIF_MODE Mode);
	
	EXP RC WINAPI SGIF_Refresh(IN int DeviceID);

	//////////////////////////////////////////////Ò»´Î»Øµ÷Ïà¹Ø///////////////////////////////////////
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutBuffer				Êý¾ÝÊý×é
	/// \param NumReceived				ʵ¼Ê½ÓÊÕµÄÊý¾Ý¸öÊý
	///
	typedef void(*SGIF_DataStorageOneTimeCallBack)(OUT int DeviceID);

	///////////////////////////////////////////////
	/// \brief SGIF_SetOneDataStorage		×¢²áÒ»´Î»Øµ÷
	/// \param DeviceID						É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param SGIF_BatchOneTimeCallBack	»Øµ÷º¯Êý
	/// \return
	///     >0:								ʧ°Ü.
	///     =0:								³É¹¦.
	///
	EXP RC WINAPI SGIF_SetOneDataStorage(IN int DeviceID, IN SGIF_DataStorageOneTimeCallBack CallFunc);
	//////////////////////////////////////////////////////////////////////////////////////////////

	// Get encoder store value
	/// \brief SGIF_GetEncoderStoreValue±àÂëÆ÷Öµ´æ´¢Êý¾ÝÊä³ö(½öSCIÉ豸֧³Ö)
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo					±àÂëÆ÷±àºÅ
	/// \param NumOfBuffer				»º³åÇø´óС£¨×î¶à¿É½ÓÊܶàÉÙ¸öÊý¾Ý£©
	/// \param OutBuffer				Êý¾ÝÊý×é
	/// \param NumReceived				ʵ¼Ê½ÓÊÕµÄÊý¾Ý¸öÊý
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_GetEncoderStoreValue(IN int DeviceID, IN int OutNo, IN int NumOfBuffer, OUT int * OutBuffer, OUT int *NumReceived);

	// Get encoder value
	/// \brief SGIF_GetEncoderCurrentValue	¶ÁÈ¡±àÂëÆ÷µ±Ç°Öµ(½öSCIÉ豸֧³Ö)
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo					±àÂëÆ÷±àºÅ(1-3)
	/// \param OutBuffer				Êý¾ÝÖ¸Õë
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_GetEncoderCurrentValue(IN int DeviceID, IN int OutNo, OUT int * OutBuffer);

	// encoder Reset
	/// \brief SGIF_EncoderReset		±àÂëÆ÷ÖµÖÃÁã(½öSCIÉ豸֧³Ö)
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo					±àÂëÆ÷±àºÅ(1-3)
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_EncoderReset(IN int DeviceID, IN int OutNo);

	// Set Encoder Number
	/// \brief SGIF_SetEncoderNumber	Ñ¡Ôñ±àÂëÆ÷(½öSCIÉ豸֧³Ö)
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo					±àÂëÆ÷±àºÅ(1-3)
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_SetEncoderNumber(IN int DeviceID, IN int OutNo);

	// Get encoder number
	/// \brief SGIF_GetEncoderNumber	¶ÁÈ¡ÉèÖõıàÂëÆ÷±àºÅ(½öSCIÉ豸֧³Ö)
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutBuffer				Êý¾ÝÖ¸Õë
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_GetEncoderNumber(IN int DeviceID, OUT int * OutBuffer);

	//Set Encoder Parameters
	/// \brief SGIF_SetEncoderParametersÉèÖñàÂëÆ÷²ÎÊý(½öSCIÉ豸֧³Ö)
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo					±àÂëÆ÷±àºÅ(1-3)
	/// \param InputMode				ÊäÈëģʽ£¨0-3£©
	/// \param InputTime				×îµÍÊäÈëʱ¼ä£¨100,200,500,1000,2000,5000,10000,20000£©(ns)
	/// \param interval					¼ä¸ô£¨1-10000£©
	/// \param OperatingMode			ÔËÐÐģʽ£¨0-2£©
	/// \param DetectionDirection		¼ì²â·½Ïò£¨0-2£©
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_SetEncoderParameters(IN int DeviceID, IN int OutNo, IN int InputMode, IN int InputTime, IN int interval, IN int OperatingMode, IN int DetectionDirection);

	//Get Encoder Parameters
	/// \brief SGIF_GetEncoderParameters¶ÁÈ¡±àÂëÆ÷²ÎÊý(½öSCIÉ豸֧³Ö)
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo					±àÂëÆ÷±àºÅ(1-3)
	/// \param InputMode				ÊäÈëģʽ£¨0-3£©
	/// \param InputTime				×îµÍÊäÈëʱ¼ä£¨100,200,500,1000,2000,5000,10000,20000£©(ns)
	/// \param interval					¼ä¸ô£¨1-10000£©
	/// \param OperatingMode			ÔËÐÐģʽ£¨0-2£©
	/// \param DetectionDirection		¼ì²â·½Ïò£¨0-2£©
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_GetEncoderParameters(IN int DeviceID, IN int OutNo, OUT int * InputMode, OUT int * InputTime, OUT int * interval, OUT int * OperatingMode, OUT int * DetectionDirection);

	//Set Analog Output
	/// \brief SGIF_SetAnalogOutput		ÉèÖÃÄ£ÄâÁ¿Êä³ö(½öSCIÉ豸֧³Ö)
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo					Ä£ÄâÁ¿±àºÅ(1-3)
	/// \param OutputChannel			Êä³öͨµÀ£¨0-3£©
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_SetAnalogOutput(IN int DeviceID, IN int OutNo, IN int OutputChannel);

	// Retrieve Analog Output Channel Number
	/// \brief SGIF_GetAnalogOutputChannel	»ñÈ¡Ä£ÄâÁ¿Êä³öͨµÀ±àºÅ(½öSCIÉ豸֧³Ö)
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo					Ä£ÄâÁ¿±àºÅ(1-3)
	/// \param OutBuffer				Êý¾ÝÖ¸Õë
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_GetAnalogOutputChannel(IN int DeviceID, IN int OutNo, OUT int * OutBuffer);

	//Set IO Digital Output
	/// \brief SGIF_SetIODigitalOutput	ÉèÖÃIOÊý×ÖÊä³ö(½öSCIÉ豸֧³Ö)
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo					Êý×ÖÊä³ö±àºÅ(1-4)
	/// \param Level					Êä³öλÊý£¨0:OFF,1:HI,2:GO,3:LO,4:STROBE£©
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_SetIODigitalOutput(IN int DeviceID, IN int OutNo, IN int Level);

	// Retrieve IO Digital Output Channel Number
	/// \brief SGIF_GetIOOutputChannel	»ñÈ¡IOÊý×ÖÁ¿Êä³öͨµÀ±àºÅ(½öSCIÉ豸֧³Ö)
	/// \param DeviceID					É豸IDºÅ£¬·¶Î§Îª0-63.
	/// \param OutNo					Êý×ÖÊä³ö±àºÅ(1-4)
	/// \param OutBuffer				Êý¾ÝÖ¸Õë
	/// \return
	///     >0:							ʧ°Ü.
	///     =0:							³É¹¦.
	///
	EXP RC WINAPI SGIF_GetIOOutputChannel(IN int DeviceID, IN int OutNo, OUT int * OutBuffer);
#ifdef __cplusplus
}
#endif