1. 添加光谱传感器模块

mrDarker

2025-08-01 2be151c6f9148d9326c9642866e0b92e086284f0

1. 添加光谱传感器模块

 SourceCode/Bond/GangBond2860.sln

@@ -1,7 +1,7 @@

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 16
VisualStudioVersion = 16.0.31729.503
# Visual Studio Version 17
VisualStudioVersion = 17.13.35913.81 d17.13
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "BEQLibrary", "BEQLibrary\BEQLibrary.vcxproj", "{8421CE64-06F9-48F4-A3F3-ACFB683C94D4}"
EndProject
@@ -16,6 +16,8 @@
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "BoounionPLC", "BoounionPLC\BoounionPLC.vcxproj", "{6DC0600E-5588-4033-A281-3626A4F74B67}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "EAPSimulator", "EAPSimulator\EAPSimulator.vcxproj", "{9EA43050-B71C-47A7-AC90-F0D7A88C5F50}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SGMeasurement", "SGMeasurement\SGMeasurement.vcxproj", "{F8087F20-3A3E-18F2-09E3-9C139642EB58}"
EndProject
Global
    GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -81,6 +83,14 @@
        {9EA43050-B71C-47A7-AC90-F0D7A88C5F50}.Release|x64.Build.0 = Release|x64
        {9EA43050-B71C-47A7-AC90-F0D7A88C5F50}.Release|x86.ActiveCfg = Release|Win32
        {9EA43050-B71C-47A7-AC90-F0D7A88C5F50}.Release|x86.Build.0 = Release|Win32
        {F8087F20-3A3E-18F2-09E3-9C139642EB58}.Debug|x64.ActiveCfg = Debug|x64
        {F8087F20-3A3E-18F2-09E3-9C139642EB58}.Debug|x64.Build.0 = Debug|x64
        {F8087F20-3A3E-18F2-09E3-9C139642EB58}.Debug|x86.ActiveCfg = Debug|Win32
        {F8087F20-3A3E-18F2-09E3-9C139642EB58}.Debug|x86.Build.0 = Debug|Win32
        {F8087F20-3A3E-18F2-09E3-9C139642EB58}.Release|x64.ActiveCfg = Release|x64
        {F8087F20-3A3E-18F2-09E3-9C139642EB58}.Release|x64.Build.0 = Release|x64
        {F8087F20-3A3E-18F2-09E3-9C139642EB58}.Release|x86.ActiveCfg = Release|Win32
        {F8087F20-3A3E-18F2-09E3-9C139642EB58}.Release|x86.Build.0 = Release|Win32
    EndGlobalSection
    GlobalSection(SolutionProperties) = preSolution
        HideSolutionNode = FALSE

 SourceCode/Bond/SGMeasurement/DLL/32bit/SGIF.h

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,1641 @@


#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:                            æˆåŠŸ.
    ///4
    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

 SourceCode/Bond/SGMeasurement/DLL/32bit/SGIFPJ.dll

Binary files differ

 SourceCode/Bond/SGMeasurement/DLL/32bit/SGIFPJ.lib

Binary files differ

 SourceCode/Bond/SGMeasurement/DLL/64bit/SGIF.h

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,1641 @@


#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

 SourceCode/Bond/SGMeasurement/DLL/64bit/SGIFPJ.dll

Binary files differ

 SourceCode/Bond/SGMeasurement/DLL/64bit/SGIFPJ.lib

Binary files differ

 SourceCode/Bond/SGMeasurement/DLL/ZYϵÁÐͨÐÅ¿â²Î¿¼ÊÖ²á-V2.3.pdf

Binary files differ

 SourceCode/Bond/SGMeasurement/SGMeasurement.cpp

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,104 @@

// SGMeasurement.cpp: å®šä¹‰åº”用程序的类行为。
//

#include "pch.h"
#include "framework.h"
#include "SGMeasurement.h"
#include "SGMeasurementDlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif


// CSGMeasurementApp

BEGIN_MESSAGE_MAP(CSGMeasurementApp, CWinApp)
    ON_COMMAND(ID_HELP, &CWinApp::OnHelp)
END_MESSAGE_MAP()


// CSGMeasurementApp æž„造

CSGMeasurementApp::CSGMeasurementApp()
{
    // æ”¯æŒé‡æ–°å¯åŠ¨ç®¡ç†å™¨
    m_dwRestartManagerSupportFlags = AFX_RESTART_MANAGER_SUPPORT_RESTART;

    // TODO: åœ¨æ­¤å¤„添加构造代码，
    // å°†æ‰€æœ‰é‡è¦çš„初始化放置在 InitInstance ä¸­
}


// å”¯ä¸€çš„ CSGMeasurementApp å¯¹è±¡

CSGMeasurementApp theApp;


// CSGMeasurementApp åˆå§‹åŒ–

BOOL CSGMeasurementApp::InitInstance()
{
    // å¦‚果应用程序存在以下情况，Windows XP ä¸Šéœ€è¦ InitCommonControlsEx()
    // ä½¿ç”¨ ComCtl32.dll ç‰ˆæœ¬ 6 æˆ–更高版本来启用可视化方式，则需要 InitCommonControlsEx()。否则，将无法创建窗口。
    INITCOMMONCONTROLSEX InitCtrls;
    InitCtrls.dwSize = sizeof(InitCtrls);
    // å°†å®ƒè®¾ç½®ä¸ºåŒ…括所有要在应用程序中使用的
    // å…¬å…±æŽ§ä»¶ç±»ã€‚
    InitCtrls.dwICC = ICC_WIN95_CLASSES;
    InitCommonControlsEx(&InitCtrls);

    CWinApp::InitInstance();

    // åˆå§‹åŒ– MFC RichEdit æŽ§ä»¶
    AfxInitRichEdit2();

    AfxEnableControlContainer();

    // åˆ›å»º shell ç®¡ç†å™¨ï¼Œä»¥é˜²å¯¹è¯æ¡†åŒ…含
    // ä»»ä½• shell æ ‘视图控件或 shell åˆ—表视图控件。
    CShellManager *pShellManager = new CShellManager;

    // æ¿€æ´»â€œWindows Native”视觉管理器，以便在 MFC æŽ§ä»¶ä¸­å¯ç”¨ä¸»é¢˜
    CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerWindows));

    // æ ‡å‡†åˆå§‹åŒ–
    // å¦‚果未使用这些功能并希望减小
    // æœ€ç»ˆå¯æ‰§è¡Œæ–‡ä»¶çš„大小，则应移除下列
    // ä¸éœ€è¦çš„特定初始化例程
    // æ›´æ”¹ç”¨äºŽå­˜å‚¨è®¾ç½®çš„注册表项
    // TODO: åº”适当修改该字符串，
    // ä¾‹å¦‚修改为公司或组织名
    SetRegistryKey(_T("应用程序向导生成的本地应用程序"));

    CSGMeasurementDlg dlg;
    m_pMainWnd = &dlg;
    INT_PTR nResponse = dlg.DoModal();
    if (nResponse == IDOK)
    {
        // TODO:“确定”来关闭对话框的代码
    }
    else if (nResponse == IDCANCEL)
    {
        // TODO:“取消”来关闭对话框的代码 
    }
    else if (nResponse == -1)
    {
        TRACE(traceAppMsg, 0, "警告: å¯¹è¯æ¡†åˆ›å»ºå¤±è´¥ï¼Œåº”用程序将意外终止。\n");
        TRACE(traceAppMsg, 0, "警告: å¦‚果您在对话框上使用 MFC æŽ§ä»¶ï¼Œåˆ™æ— æ³• #define _AFX_NO_MFC_CONTROLS_IN_DIALOGS。\n");
    }

    // åˆ é™¤ä¸Šé¢åˆ›å»ºçš„ shell ç®¡ç†å™¨ã€‚
    if (pShellManager != nullptr)
    {
        delete pShellManager;
    }

#if !defined(_AFXDLL) && !defined(_AFX_NO_MFC_CONTROLS_IN_DIALOGS)
    ControlBarCleanUp();
#endif

    // ç”±äºŽå¯¹è¯æ¡†å·²å…³é—­ï¼Œæ‰€ä»¥å°†è¿”回 FALSE ä»¥ä¾¿é€€å‡ºåº”用程序，而不是启动应用程序的消息泵。
    return FALSE;
}

 SourceCode/Bond/SGMeasurement/SGMeasurement.h

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,32 @@

// SGMeasurement.h: PROJECT_NAME åº”用程序的主头文件
//

#pragma once

#ifndef __AFXWIN_H__
    #error "在包含此文件之前包含 'pch.h' ä»¥ç”Ÿæˆ PCH"
#endif

#include "resource.h"        // ä¸»ç¬¦å·


// CSGMeasurementApp:
// æœ‰å…³æ­¤ç±»çš„实现，请参阅 SGMeasurement.cpp
//

class CSGMeasurementApp : public CWinApp
{
public:
    CSGMeasurementApp();

// é‡å†™
public:
    virtual BOOL InitInstance();

// å®žçŽ°

    DECLARE_MESSAGE_MAP()
};

extern CSGMeasurementApp theApp;

 SourceCode/Bond/SGMeasurement/SGMeasurement.rc

Binary files differ

 SourceCode/Bond/SGMeasurement/SGMeasurement.vcxproj

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,229 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup Label="ProjectConfigurations">
    <ProjectConfiguration Include="Debug|Win32">
      <Configuration>Debug</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|Win32">
      <Configuration>Release</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Debug|x64">
      <Configuration>Debug</Configuration>
      <Platform>x64</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|x64">
      <Configuration>Release</Configuration>
      <Platform>x64</Platform>
    </ProjectConfiguration>
  </ItemGroup>
  <PropertyGroup Label="Globals">
    <VCProjectVersion>17.0</VCProjectVersion>
    <ProjectGuid>{F8087F20-3A3E-18F2-09E3-9C139642EB58}</ProjectGuid>
    <Keyword>MFCProj</Keyword>
    <RootNamespace>SGMeasurement</RootNamespace>
    <WindowsTargetPlatformVersion>10.0.22621.0</WindowsTargetPlatformVersion>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>true</UseDebugLibraries>
    <PlatformToolset>v141</PlatformToolset>
    <CharacterSet>Unicode</CharacterSet>
    <UseOfMfc>Dynamic</UseOfMfc>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <PlatformToolset>v141</PlatformToolset>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>Unicode</CharacterSet>
    <UseOfMfc>Dynamic</UseOfMfc>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>true</UseDebugLibraries>
    <PlatformToolset>v141</PlatformToolset>
    <CharacterSet>Unicode</CharacterSet>
    <UseOfMfc>Dynamic</UseOfMfc>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <PlatformToolset>v141</PlatformToolset>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>Unicode</CharacterSet>
    <UseOfMfc>Dynamic</UseOfMfc>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
  <ImportGroup Label="ExtensionSettings">
  </ImportGroup>
  <ImportGroup Label="Shared">
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <PropertyGroup Label="UserMacros" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <LinkIncremental>true</LinkIncremental>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <LinkIncremental>true</LinkIncremental>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <LinkIncremental>false</LinkIncremental>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <LinkIncremental>false</LinkIncremental>
  </PropertyGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <ClCompile>
      <PrecompiledHeader>Use</PrecompiledHeader>
      <WarningLevel>Level3</WarningLevel>
      <SDLCheck>true</SDLCheck>
      <PreprocessorDefinitions>_WINDOWS;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
      <AdditionalIncludeDirectories>.\DLL\64bit;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <AdditionalLibraryDirectories>.\DLL\64bit;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
      <AdditionalDependencies>SGIFPJ.lib;%(AdditionalDependencies)</AdditionalDependencies>
    </Link>
    <Midl>
      <MkTypLibCompatible>false</MkTypLibCompatible>
      <ValidateAllParameters>true</ValidateAllParameters>
      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
    </Midl>
    <ResourceCompile>
      <Culture>0x0804</Culture>
      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <AdditionalIncludeDirectories>$(IntDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
    </ResourceCompile>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <ClCompile>
      <PrecompiledHeader>Use</PrecompiledHeader>
      <WarningLevel>Level3</WarningLevel>
      <SDLCheck>true</SDLCheck>
      <PreprocessorDefinitions>WIN32;_WINDOWS;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
      <AdditionalIncludeDirectories>.\DLL\32bit;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <AdditionalLibraryDirectories>.\DLL\32bit;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
      <AdditionalDependencies>SGIFPJ.lib;%(AdditionalDependencies)</AdditionalDependencies>
    </Link>
    <Midl>
      <MkTypLibCompatible>false</MkTypLibCompatible>
      <ValidateAllParameters>true</ValidateAllParameters>
      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
    </Midl>
    <ResourceCompile>
      <Culture>0x0804</Culture>
      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <AdditionalIncludeDirectories>$(IntDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
    </ResourceCompile>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <ClCompile>
      <PrecompiledHeader>Use</PrecompiledHeader>
      <WarningLevel>Level3</WarningLevel>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <SDLCheck>true</SDLCheck>
      <PreprocessorDefinitions>WIN32;_WINDOWS;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
      <AdditionalIncludeDirectories>.\DLL\32bit;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <AdditionalLibraryDirectories>.\DLL\32bit;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
      <AdditionalDependencies>SGIFPJ.lib;%(AdditionalDependencies)</AdditionalDependencies>
    </Link>
    <Midl>
      <MkTypLibCompatible>false</MkTypLibCompatible>
      <ValidateAllParameters>true</ValidateAllParameters>
      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
    </Midl>
    <ResourceCompile>
      <Culture>0x0804</Culture>
      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <AdditionalIncludeDirectories>$(IntDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
    </ResourceCompile>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <ClCompile>
      <PrecompiledHeader>Use</PrecompiledHeader>
      <WarningLevel>Level3</WarningLevel>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <SDLCheck>true</SDLCheck>
      <PreprocessorDefinitions>_WINDOWS;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
      <AdditionalIncludeDirectories>.\DLL\64bit;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <AdditionalLibraryDirectories>.\DLL\64bit;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
      <AdditionalDependencies>SGIFPJ.lib;%(AdditionalDependencies)</AdditionalDependencies>
    </Link>
    <Midl>
      <MkTypLibCompatible>false</MkTypLibCompatible>
      <ValidateAllParameters>true</ValidateAllParameters>
      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
    </Midl>
    <ResourceCompile>
      <Culture>0x0804</Culture>
      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <AdditionalIncludeDirectories>$(IntDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
    </ResourceCompile>
  </ItemDefinitionGroup>
  <ItemGroup>
    <ClInclude Include="framework.h" />
    <ClInclude Include="pch.h" />
    <ClInclude Include="Resource.h" />
    <ClInclude Include="SGMeasurement.h" />
    <ClInclude Include="SGMeasurementDlg.h" />
    <ClInclude Include="targetver.h" />
  </ItemGroup>
  <ItemGroup>
    <ClCompile Include="pch.cpp">
      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
    </ClCompile>
    <ClCompile Include="SGMeasurement.cpp" />
    <ClCompile Include="SGMeasurementDlg.cpp" />
  </ItemGroup>
  <ItemGroup>
    <ResourceCompile Include="SGMeasurement.rc" />
  </ItemGroup>
  <ItemGroup>
    <None Include="res\SGMeasurement.rc2" />
  </ItemGroup>
  <ItemGroup>
    <Image Include="res\menu_close.ico" />
    <Image Include="res\menu_restore.ico" />
    <Image Include="res\SGMeasurement.ico" />
  </ItemGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
  <ImportGroup Label="ExtensionTargets">
  </ImportGroup>
</Project>

 SourceCode/Bond/SGMeasurement/SGMeasurement.vcxproj.filters

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,69 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup>
    <Filter Include="源文件">
      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
      <Extensions>cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
    </Filter>
    <Filter Include="头文件">
      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
      <Extensions>h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd</Extensions>
    </Filter>
    <Filter Include="资源文件">
      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
    </Filter>
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="SGMeasurement.h">
      <Filter>头文件</Filter>
    </ClInclude>
    <ClInclude Include="SGMeasurementDlg.h">
      <Filter>头文件</Filter>
    </ClInclude>
    <ClInclude Include="framework.h">
      <Filter>头文件</Filter>
    </ClInclude>
    <ClInclude Include="targetver.h">
      <Filter>头文件</Filter>
    </ClInclude>
    <ClInclude Include="Resource.h">
      <Filter>头文件</Filter>
    </ClInclude>
    <ClInclude Include="pch.h">
      <Filter>头文件</Filter>
    </ClInclude>
  </ItemGroup>
  <ItemGroup>
    <ClCompile Include="SGMeasurement.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="SGMeasurementDlg.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="pch.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
  </ItemGroup>
  <ItemGroup>
    <ResourceCompile Include="SGMeasurement.rc">
      <Filter>资源文件</Filter>
    </ResourceCompile>
  </ItemGroup>
  <ItemGroup>
    <None Include="res\SGMeasurement.rc2">
      <Filter>资源文件</Filter>
    </None>
  </ItemGroup>
  <ItemGroup>
    <Image Include="res\SGMeasurement.ico">
      <Filter>资源文件</Filter>
    </Image>
    <Image Include="res\menu_restore.ico">
      <Filter>资源文件</Filter>
    </Image>
    <Image Include="res\menu_close.ico">
      <Filter>资源文件</Filter>
    </Image>
  </ItemGroup>
</Project>

 SourceCode/Bond/SGMeasurement/SGMeasurement.vcxproj.user

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,6 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <RESOURCE_FILE>SGMeasurement.rc</RESOURCE_FILE>
  </PropertyGroup>
</Project>

 SourceCode/Bond/SGMeasurement/SGMeasurementDlg.cpp

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,952 @@

// SGMeasurementDlg.cpp: å®žçŽ°æ–‡ä»¶
//

#include "pch.h"
#include "framework.h"
#include "SGMeasurement.h"
#include "SGMeasurementDlg.h"
#include "afxdialogex.h"
#include "SGIF.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

#define DeviceID 0

// æ‰˜ç›˜å›¾æ ‡ ID ä¸Žæ¶ˆæ¯å®
#define ID_TRAY_RESTORE           2001                // æ¢å¤çª—口
#define ID_TRAY_EXIT           2002                // é€€å‡ºç¨‹åº
#define WM_TRAY_ICON_NOTIFY    (WM_USER + 1000) // æ‰˜ç›˜å›¾æ ‡å›žè°ƒæ¶ˆæ¯ ID

// æ‰˜ç›˜æç¤ºæ–‡æœ¬å®
#define TRAY_ICON_TOOLTIP_TEXT  _T("SGMeasurement")

// æ—¥å¿—颜色宏定义
#define LOG_COLOR_NORMAL   RGB(0, 0, 0)         // æ™®é€šï¼šé»‘色
#define LOG_COLOR_SUCCESS  RGB(0, 128, 0)       // æˆåŠŸï¼šç»¿è‰²
#define LOG_COLOR_ERROR    RGB(255, 0, 0)       // é”™è¯¯ï¼šçº¢è‰²
#define LOG_COLOR_WARNING  RGB(255, 165, 0)     // è­¦å‘Šï¼šæ©™è‰²
#define LOG_COLOR_TIME     RGB(0, 0, 255)       // æ—¶é—´æˆ³ï¼šè“è‰²

// å®šæ—¶å™¨ç›¸å…³å®å®šä¹‰
#define TIMER_INTERVAL_MS        500
#define TIMER_ID_OUTPUT_UPDATE    1

class CAboutDlg : public CDialogEx
{
public:
    CAboutDlg();

// å¯¹è¯æ¡†æ•°æ®
#ifdef AFX_DESIGN_TIME
    enum { IDD = IDD_ABOUTBOX };
#endif

    protected:
    virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV æ”¯æŒ

// å®žçŽ°
protected:
    DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialogEx(IDD_ABOUTBOX)
{
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
    CDialogEx::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialogEx)
END_MESSAGE_MAP()

CSGMeasurementDlg::CSGMeasurementDlg(CWnd* pParent /*=nullptr*/)
    : CDialogEx(IDD_SGMEASUREMENT_DIALOG, pParent)
    , m_bConnected(false)
    , m_bSaving(false)
    , m_dOutValues{ 0.0, 0.0, 0.0, 0.0 }
    , m_nUseTrigger(0)
    , m_nSavePointCount(100000)
    , m_fJumpThreshold(1.0f)
    , m_nJumpWindow(3)
    , m_nValleyMargin(0)
    , m_nMinGlass1Count(10)
    , m_nFixedCount(5)
    , m_fMaxDelta(0.05f)
    , m_nTrayIconID(0)
    , m_bTrayIconCreated(FALSE)
    , m_bExitingFromTray(FALSE)
{
    m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CSGMeasurementDlg::DoDataExchange(CDataExchange* pDX)
{
    CDialogEx::DoDataExchange(pDX);
    DDX_Text(pDX, IDC_EDIT_OUT1, m_dOutValues[0]);
    DDX_Text(pDX, IDC_EDIT_OUT2, m_dOutValues[1]);
    DDX_Text(pDX, IDC_EDIT_OUT3, m_dOutValues[2]);
    DDX_Text(pDX, IDC_EDIT_OUT4, m_dOutValues[3]);
    DDX_Control(pDX, IDC_RICHEDIT_LOG, m_editLog);
    DDX_Check(pDX, IDC_CHECK_USE_TRIGGER, m_nUseTrigger);
    DDX_Control(pDX, IDC_COMBO_OUTPUT_PORT, m_comboOutputPort);
    DDX_Text(pDX, IDC_EDIT_STORE_COUNT, m_nSavePointCount);
    DDX_Text(pDX, IDC_EDIT_JUMP_WINDOW, m_nJumpWindow);
    DDX_Text(pDX, IDC_EDIT_VALLEY_MARGIN, m_nValleyMargin);
    DDX_Text(pDX, IDC_EDIT_MIN_GLASS_COUNT, m_nMinGlass1Count);
    DDX_Text(pDX, IDC_EDIT_FIXED_COUNT, m_nFixedCount);
    DDX_Text(pDX, IDC_EDIT_JUMP_THRESHOLD, m_fJumpThreshold);
    DDX_Text(pDX, IDC_EDIT_MAX_DELTA, m_fMaxDelta);
}

void CSGMeasurementDlg::ExitApplication()
{
    // æ–­å¼€è®¾å¤‡è¿žæŽ¥ï¼ˆå¦‚已连接）
    if (m_bConnected) {
        DisconnectFromDevice();
    }

    // åˆ é™¤æ‰˜ç›˜å›¾æ ‡ï¼ˆå¦‚已添加）
    if (m_bTrayIconCreated) {
        Shell_NotifyIcon(NIM_DELETE, &m_trayIconData);
        m_bTrayIconCreated = FALSE;
    }

    DestroyWindow();
    CDialogEx::OnClose();
}

void CSGMeasurementDlg::UpdateControlStatus(BOOL bConnected, BOOL bStoring/* = FALSE*/)
{
    // è¿žæŽ¥æŒ‰é’®å’Œæ–­å¼€æŒ‰é’®çŠ¶æ€äº’æ–¥
    GetDlgItem(IDC_BUTTON_CONNECT)->EnableWindow(!bConnected);
    GetDlgItem(IDC_BUTTON_DISCONNECT)->EnableWindow(bConnected);

    // IP地址输入只允许在未连接时修改
    GetDlgItem(IDC_IPADDRESS)->EnableWindow(!bConnected);

    // å­˜å‚¨é…ç½®æŽ§ä»¶ä»…在已连接且未开始存储时允许操作
    BOOL bCanConfigure = bConnected && !bStoring;
    /*GetDlgItem(IDC_CHECK_USE_TRIGGER)->EnableWindow(bCanConfigure);*/
    GetDlgItem(IDC_COMBO_OUTPUT_PORT)->EnableWindow(bCanConfigure);
    GetDlgItem(IDC_EDIT_STORE_COUNT)->EnableWindow(bCanConfigure);
    GetDlgItem(IDC_EDIT_JUMP_THRESHOLD)->EnableWindow(bCanConfigure);
    GetDlgItem(IDC_EDIT_JUMP_WINDOW)->EnableWindow(bCanConfigure);
    GetDlgItem(IDC_EDIT_VALLEY_MARGIN)->EnableWindow(bCanConfigure);
    GetDlgItem(IDC_EDIT_MIN_GLASS_COUNT)->EnableWindow(bCanConfigure);
    GetDlgItem(IDC_EDIT_FIXED_COUNT)->EnableWindow(bCanConfigure);
    GetDlgItem(IDC_EDIT_MAX_DELTA)->EnableWindow(bCanConfigure);
	
    // å­˜å‚¨ç›¸å…³æŒ‰é’®
    GetDlgItem(IDC_BUTTON_RECEIVE_FROM_CTRL)->EnableWindow(bCanConfigure);
    GetDlgItem(IDC_BUTTON_SEND_TO_CTRL)->EnableWindow(bCanConfigure);
    GetDlgItem(IDC_BUTTON_CLEAR_STORE)->EnableWindow(bCanConfigure);
    GetDlgItem(IDC_BUTTON_START_STORE)->EnableWindow(bCanConfigure);
    GetDlgItem(IDC_BUTTON_STOP_STORE)->EnableWindow(bStoring);
}

void CSGMeasurementDlg::AppendLogLineBatchBegin()
{
    m_editLog.SetRedraw(FALSE);
    m_editLog.SetEventMask(0); // é˜²æ­¢è§¦å‘不必要的通知
}

void CSGMeasurementDlg::AppendLogLineBatchEnd()
{
    m_editLog.SetRedraw(TRUE);
    m_editLog.Invalidate();    // å¼ºåˆ¶é‡ç»˜
    m_editLog.SetEventMask(ENM_CHANGE | ENM_SELCHANGE);
}

void CSGMeasurementDlg::TrimRichEditLineLimit(int nMaxLines)
{
    int nLineCount = m_editLog.GetLineCount();
    if (nLineCount < nMaxLines) {
        return;
    }

    // èŽ·å–多余行的字符数范围
    int charIndex = m_editLog.LineIndex(nMaxLines);
    m_editLog.SetSel(0, charIndex); // é€‰ä¸­å¤šä½™å†…容
    m_editLog.ReplaceSel(_T(""));   // åˆ é™¤
}

void CSGMeasurementDlg::AppendLogLineRichStyled(const CString& content, COLORREF color /*= RGB(0, 0, 0)*/)
{
    if (!::IsWindow(GetSafeHwnd()) || !::IsWindow(m_editLog.GetSafeHwnd())) {
        return;
    }

    // æ—¶é—´æˆ³
    CString strTimestamp;
    CTime now = CTime::GetCurrentTime();
    strTimestamp.Format(_T("[%02d:%02d:%02d] "), now.GetHour(), now.GetMinute(), now.GetSecond());

    // æ’入点移到最后（也可以设为 0 è¡¨ç¤ºé¡¶éƒ¨ï¼‰
    m_editLog.SetSel(-1, -1);

    // æ’入时间（蓝色）
    CHARFORMAT2 cfTime = {};
    cfTime.cbSize = sizeof(cfTime);
    cfTime.dwMask = CFM_COLOR;
    cfTime.crTextColor = LOG_COLOR_TIME;
    m_editLog.SetSelectionCharFormat(cfTime);
    m_editLog.ReplaceSel(strTimestamp);

    // æ’入日志正文（传入颜色）
    CHARFORMAT2 cfMsg = {};
    cfMsg.cbSize = sizeof(cfMsg);
    cfMsg.dwMask = CFM_COLOR;
    cfMsg.crTextColor = color;
    m_editLog.SetSelectionCharFormat(cfMsg);
    m_editLog.ReplaceSel(content + _T("\r\n"));

    // é™åˆ¶æœ€å¤§è¡Œæ•°
    TrimRichEditLineLimit(100);
}

void CSGMeasurementDlg::HighlightAllMatches(const CString& strSearch, COLORREF clrHighlight/* = RGB(255, 165, 0)*/)
{
    if (strSearch.IsEmpty()) {
        return;
    }

    long nStart = 0;
    long nEnd = m_editLog.GetTextLength();
    FINDTEXTEX ft = { 0 };
    ft.chrg.cpMin = 0;
    ft.chrg.cpMax = nEnd;
    ft.lpstrText = strSearch.GetString();

    // é«˜äº®å‰ä¸æ¸…除全文颜色，避免历史多色混淆
    while (m_editLog.FindText(FR_DOWN, &ft) != -1) {
        m_editLog.SetSel(ft.chrgText.cpMin, ft.chrgText.cpMax);

        CHARFORMAT2 cf = {};
        cf.cbSize = sizeof(cf);
        cf.dwMask = CFM_COLOR;
        cf.crTextColor = clrHighlight;
        m_editLog.SetSelectionCharFormat(cf);

        // ä¸‹æ¬¡æœç´¢ä»ŽåŽé¢å¼€å§‹
        ft.chrg.cpMin = ft.chrgText.cpMax;
    }
    m_editLog.SetSel(-1, 0);
}

void CSGMeasurementDlg::PrintSampleData(int nOutNo, const std::vector<float>& vecBuffer)
{
    int nReceived = static_cast<int>(vecBuffer.size());
    if (vecBuffer.empty() || nReceived < 0) {
        CString strError;
        strError.Format(_T("OUT%d: æŽ¥æ”¶æ•°æ®ä¸ºç©ºæˆ–无效，无法打印。"), nOutNo);
        AppendLogLineRichStyled(strError, LOG_COLOR_WARNING);
        return;
    }

    CString strLine;
    for (int i = 0; i < nReceived; ++i) {
        CString strOne;
        strOne.Format(_T("%10.3f "), vecBuffer[i]);
        strLine += strOne;

        // æ¯ 7 ä¸ªå€¼è¾“出一行
        if ((i + 1) % 7 == 0 || i == nReceived - 1) {
            AppendLogLineRichStyled(strLine, LOG_COLOR_NORMAL);
            strLine.Empty();
        }
    }
}

bool CSGMeasurementDlg::ConnectToDevice()
{
    if (m_bConnected) {
        AppendLogLineRichStyled(_T("设备已连接，请先断开连接。"), LOG_COLOR_WARNING);
        return false;
    }

    SGIF_OPENPARAM_ETHERNET stIpAddress = { 0 };

    CIPAddressCtrl* pIPCtrl = (CIPAddressCtrl*)GetDlgItem(IDC_IPADDRESS);
    if (!::IsWindow(pIPCtrl->GetSafeHwnd())) {
        AppendLogLineRichStyled(_T("IP æŽ§ä»¶æ— æ•ˆï¼Œè¿žæŽ¥å¤±è´¥ï¼"), LOG_COLOR_ERROR);
        return false;
    }

    pIPCtrl->GetAddress(
        stIpAddress.IPAddress.S_un.S_un_b.s_b1,
        stIpAddress.IPAddress.S_un.S_un_b.s_b2,
        stIpAddress.IPAddress.S_un.S_un_b.s_b3,
        stIpAddress.IPAddress.S_un.S_un_b.s_b4
    );

    RC nRet = SGIF_OpenDeviceETHER(DeviceID, &stIpAddress);
    if (nRet == RC_OK) {
        AppendLogLineRichStyled(_T("打开连接成功！"), LOG_COLOR_SUCCESS);

        m_bConnected = TRUE;
        UpdateControlStatus(TRUE, FALSE);
        SetTimer(TIMER_ID_OUTPUT_UPDATE, TIMER_INTERVAL_MS, nullptr);
        return true;
    }
    else {
        CString strError;
        strError.Format(_T("打开连接失败，错误码：%#X"), nRet);
        AppendLogLineRichStyled(strError, LOG_COLOR_ERROR);

        m_bConnected = FALSE;
        UpdateControlStatus(FALSE, FALSE);
        return false;
    }
}

bool CSGMeasurementDlg::DisconnectFromDevice()
{
    if (!m_bConnected) {
        AppendLogLineRichStyled(_T("设备未连接，无需断开。"), LOG_COLOR_WARNING);
        return false;
    }

    RC nRet = SGIF_CloseDevice(DeviceID);
    if (nRet == RC_OK) {
        if (m_bSaving) {
            m_bSaving = FALSE;
            nRet = SGIF_DataStorageStop(DeviceID);
            if (nRet == RC_OK) {
                AppendLogLineRichStyled(_T("数据存储已停止。"), LOG_COLOR_SUCCESS);
            }
            else {
                CString strError;
                strError.Format(_T("停止数据存储失败，错误码：%#X"), nRet);
                AppendLogLineRichStyled(strError, LOG_COLOR_ERROR);
            }
        }

        AppendLogLineRichStyled(_T("断开连接成功！"), LOG_COLOR_SUCCESS);

        m_bConnected = FALSE;
        UpdateControlStatus(FALSE, FALSE);
        KillTimer(TIMER_ID_OUTPUT_UPDATE);
        return true;
    }
    else {
        CString strError;
        strError.Format(_T("断开连接失败，错误码：%#X"), nRet);
        AppendLogLineRichStyled(strError, LOG_COLOR_ERROR);

        UpdateControlStatus(m_bConnected, m_bSaving);
        return false;
    }
}

void CSGMeasurementDlg::CleanInvalidValuesInPlace(int nOutNo, std::vector<float>& vecData, float fInvalid/* = -999.0f*/)
{
    // æ‰¾åˆ°ç¬¬ä¸€ä¸ªæœ‰æ•ˆå€¼
    auto itStart = std::find_if(vecData.begin(), vecData.end(), [=](float v) { return v > fInvalid; });

    // æ‰¾åˆ°æœ€åŽä¸€ä¸ªæœ‰æ•ˆå€¼
    auto itEnd = std::find_if(vecData.rbegin(), vecData.rend(), [=](float v) { return v > fInvalid; }).base();

    // æ£€æŸ¥æ˜¯å¦æœ‰æœ‰æ•ˆæ•°æ®
    if (itStart < itEnd) {
        // å…ˆè£è¾¹
        std::vector<float> vecTrimmed(itStart, itEnd);

        // å†ç§»é™¤ä¸­é—´çš„无效值
        auto itNewEnd = std::remove_if(vecTrimmed.begin(), vecTrimmed.end(), [=](float v) { return v == fInvalid; });
        vecTrimmed.erase(itNewEnd, vecTrimmed.end());

        vecData = std::move(vecTrimmed);

        CString strLog;
        strLog.Format(_T("OUT%d: å·²è£å‰ªæ— æ•ˆè¾¹ç•Œæ•°æ®ï¼Œå‰©ä½™æœ‰æ•ˆæ•°æ® %d ä¸ªã€‚"), nOutNo, static_cast<int>(vecData.size()));
        AppendLogLineRichStyled(strLog, LOG_COLOR_NORMAL);

        if (vecData.size() < 20) {
            AppendLogLineRichStyled(_T("警告：有效数据量过少，可能影响后续处理。"), LOG_COLOR_WARNING);
        }
        else {
            CString strInfo;
            strInfo.Format(_T("OUT%d: æœ‰æ•ˆæ•°æ®èŒƒå›´ [%f, %f]"), nOutNo, *std::min_element(vecData.begin(), vecData.end()), *std::max_element(vecData.begin(), vecData.end()));
            AppendLogLineRichStyled(strInfo, LOG_COLOR_NORMAL);
        }

        PrintSampleData(nOutNo, vecData);
    }
    else {
        vecData.clear();
    }
}

bool CSGMeasurementDlg::SplitGlassSegments(int nOutNo, const std::vector<float>& vecData, std::vector<float>& vecGlass1, std::vector<float>& vecGlass2, float fJumpThreshold /*= 0.2f*/, int nWindow /*= 3*/, int nValleyMargin /*= 0*/, int nMinGlass1Count /*= 10*/)
{
    const int n = static_cast<int>(vecData.size());
    if (n < 2 * nWindow + 1 + nMinGlass1Count) {
        CString strError;
        strError.Format(_T("OUT%d: æ•°æ®é‡ä¸è¶³ï¼Œè‡³å°‘需要 %d ä¸ªç‚¹æ‰èƒ½è¿›è¡Œåˆ‡å‰²ã€‚"), nOutNo, 2 * nWindow + 1 + nMinGlass1Count);
        AppendLogLineRichStyled(strError, LOG_COLOR_WARNING);
        return false;
    }

    int nValleyIdx = -1;
    for (int i = nWindow; i < n - nWindow - nMinGlass1Count; ++i) {
        float fDelta = std::fabs(vecData[i + nWindow] - vecData[i - nWindow]);
        if (fDelta > fJumpThreshold) {
            // æ‰¾ valley ç‚¹ï¼ˆç¨å¾®å¾€åŽè·³å‡ æ­¥ä»¥é¿å¼€è¾¹ç¼˜æŠ–动）
            int nSearchStart = i + nWindow + 2;
            int nSearchEnd = min(nSearchStart + 10, n);

            auto itValley = std::min_element(vecData.begin() + nSearchStart, vecData.begin() + nSearchEnd,
                [](float a, float b) {
                    return (a > -900.0f && b > -900.0f) ? a < b : false;
                });

            if (itValley != vecData.begin() + nSearchEnd) {
                nValleyIdx = static_cast<int>(std::distance(vecData.begin(), itValley));
                break;
            }
        }
    }

    if (nValleyIdx < 0 || nValleyIdx < nMinGlass1Count) {
        AppendLogLineRichStyled(_T("未找到合适 valley ç‚¹ï¼Œæˆ– valley å¤ªé å‰ã€‚"), LOG_COLOR_WARNING);
        return false;
    }

    // ä»Ž valley å¤„开始切割，或者往后偏移
    int nCutStart = min(nValleyIdx + nValleyMargin, n);
    vecGlass1.assign(vecData.begin(), vecData.begin() + nCutStart);
    vecGlass2.assign(vecData.begin() + nCutStart, vecData.end());

    int nGlass1Count = static_cast<int>(vecGlass1.size());
    int nGlass2Count = static_cast<int>(vecGlass2.size());

    // æ—¥å¿—输出
    CString strLog;
    strLog.Format(_T("OUT%d: åˆ‡å‰²æˆåŠŸï¼Œç¬¬ä¸€ç‰‡çŽ»ç’ƒæ•°æ®é‡ %d，第二片玻璃数据量 %d。"), nOutNo, nGlass1Count, nGlass2Count);
    AppendLogLineRichStyled(strLog, LOG_COLOR_SUCCESS);

    if (nGlass1Count < nMinGlass1Count) {
        strLog.Format(_T("OUT%d: ç¬¬ä¸€ç‰‡çŽ»ç’ƒæ•°æ®é‡è¿‡å°‘，可能影响后续处理。"), nOutNo);
        AppendLogLineRichStyled(strLog, LOG_COLOR_WARNING);
    }
    if (nGlass2Count < nMinGlass1Count) {
        strLog.Format(_T("OUT%d: ç¬¬äºŒç‰‡çŽ»ç’ƒæ•°æ®é‡è¿‡å°‘，可能影响后续处理。"), nOutNo);
        AppendLogLineRichStyled(strLog, LOG_COLOR_WARNING);
    }

    AppendLogLineRichStyled(_T("第一片玻璃数据："), LOG_COLOR_NORMAL);
    PrintSampleData(nOutNo, vecGlass1);

    AppendLogLineRichStyled(_T("第二片玻璃数据："), LOG_COLOR_NORMAL);
    PrintSampleData(nOutNo, vecGlass2);

    return !vecGlass1.empty() && !vecGlass2.empty();
}

bool CSGMeasurementDlg::ExtractStableRegionFixed(int nOutNo, const std::vector<float>& vecIn, std::vector<float>& vecOut, int nFixedCount/* = 5*/, float fMaxDelta/* = 0.04f*/)
{
    const int n = static_cast<int>(vecIn.size());
    if (n < nFixedCount) {
        CString strError;
        strError.Format(_T("OUT%d: æ•°æ®é‡ä¸è¶³ï¼Œè‡³å°‘需要 %d ä¸ªç‚¹æ‰èƒ½æå–稳定区。"), nOutNo, nFixedCount);
        return false;
    }

    int nBestStart = -1;
    float fBestRange = FLT_MAX;

    for (int i = 0; i <= n - nFixedCount; ++i) {
        auto first = vecIn.begin() + i;
        auto last = first + nFixedCount;

        float fMinVal = *std::min_element(first, last);
        float fMaxVal = *std::max_element(first, last);
        float fRange = fMaxVal - fMinVal;

        if (fRange <= fMaxDelta && fRange < fBestRange) {
            fBestRange = fRange;
            nBestStart = i;
        }
    }

    if (nBestStart < 0) {
        return false;
    }

    vecOut.assign(vecIn.begin() + nBestStart, vecIn.begin() + nBestStart + nFixedCount);

    CString strLog;
    strLog.Format(_T("OUT%d: æå–稳定区成功，起始点索引 %d，范围 %.3f。"), nOutNo, nBestStart, fBestRange);
    AppendLogLineRichStyled(strLog, LOG_COLOR_SUCCESS);

    if (vecOut.size() < nFixedCount) {
        CString strWarning;
        strWarning.Format(_T("OUT%d: æå–的稳定区数据量不足，可能影响后续处理。"), nOutNo);
        AppendLogLineRichStyled(strWarning, LOG_COLOR_WARNING);
    }

    // æ‰“印提取的稳定区数据
    AppendLogLineRichStyled(_T("提取的稳定区数据："), LOG_COLOR_NORMAL);
    PrintSampleData(nOutNo, vecOut);

    return true;
}

bool CSGMeasurementDlg::CalcGlassOffset(const std::vector<float>& vecGlass1, const std::vector<float>& vecGlass2, float& fAvg1, float& fAvg2, float& fOffset)
{
    if (vecGlass1.empty() || vecGlass2.empty()) {
        AppendLogLineRichStyled(_T("稳定区数据为空，无法计算平均值和偏移。"), LOG_COLOR_WARNING);
        return false;
    }

    auto CalcAverage = [](const std::vector<float>& data) -> float {
        float sum = std::accumulate(data.begin(), data.end(), 0.0f);
        return sum / static_cast<float>(data.size());
    };

    fAvg1 = CalcAverage(vecGlass1);
    fAvg2 = CalcAverage(vecGlass2);
    fOffset = std::fabs(fAvg2 - fAvg1);  // ç¬¬äºŒç‰‡ - ç¬¬ä¸€ç‰‡

    CString strLog;
    strLog.Format(_T("第一片玻璃平均值: %.3f，第二片玻璃平均值: %.3f，偏移量: %.3f"), fAvg1, fAvg2, fOffset);
    AppendLogLineRichStyled(strLog, LOG_COLOR_SUCCESS);

    return true;
}

BEGIN_MESSAGE_MAP(CSGMeasurementDlg, CDialogEx)
    ON_WM_SYSCOMMAND()
    ON_WM_PAINT()
    ON_WM_QUERYDRAGICON()
    ON_WM_TIMER()
    ON_WM_MEASUREITEM()
    ON_WM_DRAWITEM()
    ON_WM_CLOSE()
    ON_MESSAGE(WM_TRAY_ICON_NOTIFY, &CSGMeasurementDlg::OnTrayIconClick)
    ON_COMMAND(ID_TRAY_RESTORE, &CSGMeasurementDlg::OnTrayRestore)
    ON_COMMAND(ID_TRAY_EXIT, &CSGMeasurementDlg::OnTrayExit)
    ON_BN_CLICKED(IDC_BUTTON_CONNECT, &CSGMeasurementDlg::OnBnClickedButtonConnect)
    ON_BN_CLICKED(IDC_BUTTON_DISCONNECT, &CSGMeasurementDlg::OnBnClickedButtonDisconnect)
    ON_BN_CLICKED(IDC_BUTTON_RECEIVE_FROM_CTRL, &CSGMeasurementDlg::OnBnClickedButtonReceiveFromCtrl)
    ON_BN_CLICKED(IDC_BUTTON_SEND_TO_CTRL, &CSGMeasurementDlg::OnBnClickedButtonSendToCtrl)
    ON_BN_CLICKED(IDC_BUTTON_CLEAR_STORE, &CSGMeasurementDlg::OnBnClickedButtonClearStore)
    ON_BN_CLICKED(IDC_BUTTON_START_STORE, &CSGMeasurementDlg::OnBnClickedButtonStartStore)
    ON_BN_CLICKED(IDC_BUTTON_STOP_STORE, &CSGMeasurementDlg::OnBnClickedButtonStopStore)
    ON_BN_CLICKED(IDC_BUTTON_CLEAR_LOG, &CSGMeasurementDlg::OnBnClickedButtonClearLog)
END_MESSAGE_MAP()

BOOL CSGMeasurementDlg::OnInitDialog()
{
    CDialogEx::OnInitDialog();

    // å°†â€œå…³äºŽ...”菜单项添加到系统菜单中。

    // IDM_ABOUTBOX å¿…须在系统命令范围内。
    ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
    ASSERT(IDM_ABOUTBOX < 0xF000);

    CMenu* pSysMenu = GetSystemMenu(FALSE);
    if (pSysMenu != nullptr)
    {
        BOOL bNameValid;
        CString strAboutMenu;
        bNameValid = strAboutMenu.LoadString(IDS_ABOUTBOX);
        ASSERT(bNameValid);
        if (!strAboutMenu.IsEmpty())
        {
            pSysMenu->AppendMenu(MF_SEPARATOR);
            pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
        }
    }

    // è®¾ç½®æ­¤å¯¹è¯æ¡†çš„图标。  å½“应用程序主窗口不是对话框时，框架将自动
    //  æ‰§è¡Œæ­¤æ“ä½œ
    SetIcon(m_hIcon, TRUE);            // è®¾ç½®å¤§å›¾æ ‡
    SetIcon(m_hIcon, FALSE);        // è®¾ç½®å°å›¾æ ‡

    // TODO: åœ¨æ­¤æ·»åŠ é¢å¤–的初始化代码
    UpdateData(FALSE);
    UpdateControlStatus(FALSE, FALSE);

    // æ‰˜ç›˜å›¾æ ‡åˆå§‹åŒ–
    m_trayIconData.cbSize = sizeof(NOTIFYICONDATA);                  // è®¾ç½®æ‰˜ç›˜å›¾æ ‡æ•°æ®ç»“构的大小
    m_trayIconData.hWnd = m_hWnd;                                    // è®¾ç½®çª—口句柄
    m_trayIconData.uID = m_nTrayIconID;                              // è®¾ç½®æ‰˜ç›˜å›¾æ ‡ ID
    m_trayIconData.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;          // è®¾ç½®æ‰˜ç›˜å›¾æ ‡çš„标志（图标、消息、提示文本）
    m_trayIconData.uCallbackMessage = WM_TRAY_ICON_NOTIFY;           // è®¾ç½®å›žè°ƒæ¶ˆæ¯ WM_TRAY_ICON_NOTIFY
    m_trayIconData.hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);      // åŠ è½½æ‰˜ç›˜å›¾æ ‡
    lstrcpy(m_trayIconData.szTip, TRAY_ICON_TOOLTIP_TEXT);           // è®¾ç½®æ‰˜ç›˜æç¤ºæ–‡æœ¬

    // æ·»åŠ æ‰˜ç›˜å›¾æ ‡
    Shell_NotifyIcon(NIM_ADD, &m_trayIconData);
    m_bTrayIconCreated = TRUE;

    for (int i = 0; i < 4; i++) {
        CString str;
        str.Format(_T("OUT%d"), i + 1);
        m_comboOutputPort.AddString(str);
    }
    m_comboOutputPort.SetCurSel(0);

    // åˆå§‹åŒ–IP地址控件，设置为默认IP地址
    ((CIPAddressCtrl*)GetDlgItem(IDC_IPADDRESS))->SetAddress(192, 168, 0, 10);

    // åˆå§‹åŒ–日志框
    AppendLogLineRichStyled(_T("准备就绪..."), LOG_COLOR_SUCCESS);

    return TRUE;  // é™¤éžå°†ç„¦ç‚¹è®¾ç½®åˆ°æŽ§ä»¶ï¼Œå¦åˆ™è¿”回 TRUE
}

void CSGMeasurementDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
    if ((nID & 0xFFF0) == IDM_ABOUTBOX)
    {
        CAboutDlg dlgAbout;
        dlgAbout.DoModal();
    }
    else
    {
        CDialogEx::OnSysCommand(nID, lParam);
    }
}

void CSGMeasurementDlg::OnPaint()
{
    if (IsIconic()) {
        CPaintDC dc(this);

        SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

        // ä½¿å›¾æ ‡åœ¨å·¥ä½œåŒºçŸ©å½¢ä¸­å±…中
        int cxIcon = GetSystemMetrics(SM_CXICON);
        int cyIcon = GetSystemMetrics(SM_CYICON);
        CRect rect;
        GetClientRect(&rect);
        int x = (rect.Width() - cxIcon + 1) / 2;
        int y = (rect.Height() - cyIcon + 1) / 2;

        // ç»˜åˆ¶å›¾æ ‡
        dc.DrawIcon(x, y, m_hIcon);
    }
    else {
        CDialogEx::OnPaint();
    }
}

//当用户拖动最小化窗口时系统调用此函数取得光标显示。
HCURSOR CSGMeasurementDlg::OnQueryDragIcon()
{
    return static_cast<HCURSOR>(m_hIcon);
}

void CSGMeasurementDlg::OnTimer(UINT_PTR nIDEvent)
{
    // TODO: åœ¨æ­¤æ·»åŠ æ¶ˆæ¯å¤„理程序代码和/或调用默认值
    if (nIDEvent == TIMER_ID_OUTPUT_UPDATE) {
        SGIF_FLOATVALUE_OUT value[4] = { 0 };
        RC nRet = SGIF_GetCalcDataALL(DeviceID, value);
        if (nRet == RC_OK) {
            for (int i = 0; i < 4; ++i) {
                m_dOutValues[i] = value[i].Value;
            }

            // æ›´æ–°ç»‘定控件
            UpdateData(FALSE);
        }
        else {
            CString strError;
            strError.Format(_T("获取测量值失败，错误码：%#X"), nRet);
            AppendLogLineRichStyled(strError, LOG_COLOR_ERROR);
        }
    }

    CDialogEx::OnTimer(nIDEvent);
}

void CSGMeasurementDlg::OnMeasureItem(int nIDCtl, LPMEASUREITEMSTRUCT lpMeasureItemStruct)
{
    if (lpMeasureItemStruct->CtlType == ODT_MENU) {
        lpMeasureItemStruct->itemHeight = 24;
        lpMeasureItemStruct->itemWidth = 140;
    }
}

void CSGMeasurementDlg::OnDrawItem(int nIDCtl, LPDRAWITEMSTRUCT lpDrawItemStruct)
{
    if (lpDrawItemStruct->CtlType != ODT_MENU) { 
        return;
    }

    CDC* pDC = CDC::FromHandle(lpDrawItemStruct->hDC);
    CRect rc = lpDrawItemStruct->rcItem;
    UINT id = lpDrawItemStruct->itemID;

    // èƒŒæ™¯
    COLORREF bgColor = (lpDrawItemStruct->itemState & ODS_SELECTED) ? RGB(200, 220, 255) : RGB(255, 255, 255);
    pDC->FillSolidRect(rc, bgColor);

    // å›¾æ ‡
    HICON hIcon = nullptr;
    if (id == ID_TRAY_RESTORE) {
        hIcon = AfxGetApp()->LoadIcon(IDI_ICON_RESTORE);
    }

    if (id == ID_TRAY_EXIT) {
        hIcon = AfxGetApp()->LoadIcon(IDI_ICON_EXIT);
    }

    if (hIcon) {
        DrawIconEx(pDC->GetSafeHdc(), rc.left + 4, rc.top + 4, hIcon, 16, 16, 0, NULL, DI_NORMAL);
    }

    // æ–‡æœ¬
    CString str;
    if (id == ID_TRAY_RESTORE) { 
        str = _T("恢复界面");
    }

    if (id == ID_TRAY_EXIT) { 
        str = _T("退出程序");
    }

    pDC->SetBkMode(TRANSPARENT);
    pDC->SetTextColor(RGB(0, 0, 0));
    pDC->DrawText(str, CRect(rc.left + 28, rc.top, rc.right, rc.bottom), DT_SINGLELINE | DT_VCENTER | DT_LEFT);
}

void CSGMeasurementDlg::OnClose()
{
    // TODO: åœ¨æ­¤æ·»åŠ æ¶ˆæ¯å¤„理程序代码和/或调用默认值
    if (m_bExitingFromTray) {
        // ä»Žæ‰˜ç›˜é€€å‡ºæµç¨‹
        ExitApplication();
    }
    else {
        // æ­£å¸¸å…³é—­æŒ‰é’®
        int nResult = AfxMessageBox(_T("是否最小化到托盘？"), MB_YESNO | MB_ICONQUESTION);
        if (nResult == IDYES) {
            ShowWindow(SW_HIDE);
        }
        else {
            ExitApplication();
        }
    }
}

LRESULT CSGMeasurementDlg::OnTrayIconClick(WPARAM wParam, LPARAM lParam) {
    if (wParam == m_nTrayIconID) {
        if (LOWORD(lParam) == WM_LBUTTONUP) {
            // å·¦é”®ç‚¹å‡»æ¢å¤çª—口
            ShowWindow(SW_SHOW);
            SetForegroundWindow();
        }
        else if (LOWORD(lParam) == WM_RBUTTONUP) {
            // å³é”®ç‚¹å‡»å¼¹å‡ºèœå•
            CMenu menu;
            menu.CreatePopupMenu();
            menu.AppendMenu(MF_OWNERDRAW, ID_TRAY_RESTORE, (LPCTSTR)ID_TRAY_RESTORE);
            menu.AppendMenu(MF_OWNERDRAW, ID_TRAY_EXIT, (LPCTSTR)ID_TRAY_EXIT);

            // åŠ è½½å›¾æ ‡
            HICON hIconRestore = (HICON)::LoadImage(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDI_ICON_RESTORE), IMAGE_ICON, 16, 16, LR_SHARED);
            HICON hIconExit = (HICON)::LoadImage(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDI_ICON_EXIT), IMAGE_ICON, 16, 16, LR_SHARED);

            // è®¾ç½®å›¾æ ‡åˆ°èœå•é¡¹
            MENUITEMINFO mii = { sizeof(MENUITEMINFO) };
            mii.fMask = MIIM_BITMAP;

            // æ¢å¤èœå•é¡¹å›¾æ ‡
            mii.hbmpItem = HBMMENU_CALLBACK;
            menu.SetMenuItemInfo(ID_TRAY_RESTORE, &mii);

            // é€€å‡ºèœå•é¡¹å›¾æ ‡
            mii.hbmpItem = HBMMENU_CALLBACK;
            menu.SetMenuItemInfo(ID_TRAY_EXIT, &mii);

            // èŽ·å–鼠标当前位置，并显示菜单
            POINT pt;
            GetCursorPos(&pt);
            SetForegroundWindow();
            menu.TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, pt.x, pt.y, this);
        }
    }
    return 0;
}

void CSGMeasurementDlg::OnTrayRestore()
{
    ShowWindow(SW_SHOW);      // æ¢å¤çª—口
    SetForegroundWindow();  // å°†çª—口置于前端
}

void CSGMeasurementDlg::OnTrayExit()
{
    // ä»Žæ‰˜ç›˜å›¾æ ‡èœå•é€‰æ‹©â€œé€€å‡ºç¨‹åºâ€
    if (AfxMessageBox(_T("确定要退出程序吗？"), MB_YESNO | MB_ICONQUESTION) == IDYES) {
        m_bExitingFromTray = TRUE;
        PostMessage(WM_CLOSE);
    }
}

void CSGMeasurementDlg::OnBnClickedButtonConnect()
{
    // TODO: åœ¨æ­¤æ·»åŠ æŽ§ä»¶é€šçŸ¥å¤„理程序代码
    ConnectToDevice();
}

void CSGMeasurementDlg::OnBnClickedButtonDisconnect()
{
    // TODO: åœ¨æ­¤æ·»åŠ æŽ§ä»¶é€šçŸ¥å¤„理程序代码
    DisconnectFromDevice();
}

void CSGMeasurementDlg::OnBnClickedButtonReceiveFromCtrl()
{
    // TODO: åœ¨æ­¤æ·»åŠ æŽ§ä»¶é€šçŸ¥å¤„理程序代码
    if (!m_bConnected) {
        AppendLogLineRichStyled(_T("设备未连接，请先连接设备。"), LOG_COLOR_WARNING);
        return;
    }
}

void CSGMeasurementDlg::OnBnClickedButtonSendToCtrl()
{
    // TODO: åœ¨æ­¤æ·»åŠ æŽ§ä»¶é€šçŸ¥å¤„理程序代码
    if (!m_bConnected) {
        AppendLogLineRichStyled(_T("设备未连接，请先连接设备。"), LOG_COLOR_WARNING);
        return;
    }
}

void CSGMeasurementDlg::OnBnClickedButtonClearStore()
{
    // TODO: åœ¨æ­¤æ·»åŠ æŽ§ä»¶é€šçŸ¥å¤„理程序代码
    if (!m_bConnected) {
        AppendLogLineRichStyled(_T("设备未连接，请先连接设备。"), LOG_COLOR_WARNING);
        return;
    }

    if (m_bSaving) {
        AppendLogLineRichStyled(_T("数据存储正在进行中，请先停止存储。"), LOG_COLOR_WARNING);
        return;
    }

    RC nRet = SGIF_DataStorageInit(DeviceID);
    if (nRet == RC_OK) {
        AppendLogLineRichStyled(_T("数据存储已清除。"), LOG_COLOR_SUCCESS);
    }
    else {
        CString strError;
        strError.Format(_T("清除数据存储失败，错误码：%#X"), nRet);
        AppendLogLineRichStyled(strError, LOG_COLOR_ERROR);
    }
}

void CSGMeasurementDlg::OnBnClickedButtonStartStore()
{
    // TODO: åœ¨æ­¤æ·»åŠ æŽ§ä»¶é€šçŸ¥å¤„理程序代码
    if (m_bSaving) {
        AppendLogLineRichStyled(_T("数据存储已在进行中，请先停止存储。"), LOG_COLOR_WARNING);
        return;
    }

    RC nRet = SGIF_DataStorageStart(DeviceID);
    if (nRet == RC_OK) {
        m_bSaving = TRUE;
        AppendLogLineRichStyled(_T("数据存储已开始。"), LOG_COLOR_SUCCESS);
    }
    else {
        CString strError;
        strError.Format(_T("开始数据存储失败，错误码：%#X"), nRet);
        AppendLogLineRichStyled(strError, LOG_COLOR_ERROR);
    }

    UpdateControlStatus(m_bConnected, m_bSaving);
}

void CSGMeasurementDlg::OnBnClickedButtonStopStore()
{
    // TODO: åœ¨æ­¤æ·»åŠ æŽ§ä»¶é€šçŸ¥å¤„理程序代码
    UpdateData(TRUE);

    if (!m_bSaving) {
        AppendLogLineRichStyled(_T("数据存储未在进行中，请先开始存储。"), LOG_COLOR_WARNING);
        return;
    }

    RC nRet = SGIF_DataStorageStop(DeviceID);
    if (nRet == RC_OK) {
        m_bSaving = FALSE;
        AppendLogLineRichStyled(_T("数据存储已停止。"), LOG_COLOR_SUCCESS);

        if (m_nUseTrigger) {
            UpdateControlStatus(m_bConnected, m_bSaving);
            AfxMessageBox(_T("当前是硬触发模式，请检查触发器状态。"), MB_ICONINFORMATION);
            return;
        }

        int nReceived = 0;
        std::vector<float> vecBuffer(m_nSavePointCount, 0.0f);

        int nSel = m_comboOutputPort.GetCurSel();
        if (CB_ERR == nSel) {
            AppendLogLineRichStyled(_T("请选择一个有效的输出端口。"), LOG_COLOR_WARNING);
            return;
        }

        int nOutNo = nSel + 1;
        nRet = SGIF_DataStorageGetData(DeviceID, nOutNo, m_nSavePointCount, vecBuffer.data(), &nReceived);

        CString strLog;
        if (nRet == RC_OK) {
            vecBuffer.resize(nReceived);
            CleanInvalidValuesInPlace(nOutNo, vecBuffer);

            std::vector<float> vecGlass1, vecGlass2;
            if (SplitGlassSegments(nOutNo, vecBuffer, vecGlass1, vecGlass2, m_fJumpThreshold, m_nJumpWindow, m_nValleyMargin, m_nMinGlass1Count)) {

                std::vector<float> vecStableGlass1, vecStableGlass2;
                bool bStable1 = ExtractStableRegionFixed(nOutNo, vecGlass1, vecStableGlass1, m_nFixedCount, m_fMaxDelta);
                bool bStable2 = ExtractStableRegionFixed(nOutNo, vecGlass2, vecStableGlass2, m_nFixedCount, m_fMaxDelta);

                float fAvg1 = 0.0f, fAvg2 = 0.0f, fOffset = 0.0f;
                if (bStable1 && bStable2) {
                    AppendLogLineRichStyled(_T("成功提取到两片玻璃的稳定区数据。"), LOG_COLOR_SUCCESS);
                    CalcGlassOffset(vecStableGlass1, vecStableGlass2, fAvg1, fAvg2, fOffset);
                }
                else {
                    AppendLogLineRichStyled(_T("未能提取到稳定区数据，无法正常计算偏移。"), LOG_COLOR_WARNING);
                    CalcGlassOffset(vecGlass1, vecGlass2, fAvg1, fAvg2, fOffset);
                }
            }
            else {
                AppendLogLineRichStyled(_T("未能识别出两片玻璃的数据。"), LOG_COLOR_WARNING);
            }
        }
        else {
            strLog.Format(_T("读取 OUT%d æ•°æ®å¤±è´¥ï¼Œé”™è¯¯ç ï¼š%#X"), nOutNo, nRet);
            AppendLogLineRichStyled(strLog, LOG_COLOR_ERROR);
        }
    }
    else {
        CString strError;
        strError.Format(_T("停止数据存储失败，错误码：%#X"), nRet);
        AppendLogLineRichStyled(strError, LOG_COLOR_ERROR);
    }

    UpdateControlStatus(m_bConnected, m_bSaving);
}

void CSGMeasurementDlg::OnBnClickedButtonClearLog()
{
    // TODO: åœ¨æ­¤æ·»åŠ æŽ§ä»¶é€šçŸ¥å¤„理程序代码
    if (::IsWindow(m_editLog.GetSafeHwnd())) {
        m_editLog.SetWindowText(_T(""));
    }
}

 SourceCode/Bond/SGMeasurement/SGMeasurementDlg.h

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,277 @@

// SGMeasurementDlg.h: å¤´æ–‡ä»¶
//

#pragma once
#include <vector>
#include <numeric>
#include <algorithm>

// CSGMeasurementDlg å¯¹è¯æ¡†
class CSGMeasurementDlg : public CDialogEx
{
// æž„造
public:
    CSGMeasurementDlg(CWnd* pParent = nullptr);    // æ ‡å‡†æž„造函数

// å¯¹è¯æ¡†æ•°æ®
#ifdef AFX_DESIGN_TIME
    enum { IDD = IDD_SGMEASUREMENT_DIALOG };
#endif

    protected:
    virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV æ”¯æŒ

// å®žçŽ°
protected:
    HICON m_hIcon;

    // ç”Ÿæˆçš„消息映射函数
    virtual BOOL OnInitDialog();
    afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
    afx_msg void OnPaint();
    afx_msg HCURSOR OnQueryDragIcon();
    afx_msg void OnTimer(UINT_PTR nIDEvent);
    afx_msg void OnMeasureItem(int nIDCtl, LPMEASUREITEMSTRUCT lpMeasureItemStruct);
    afx_msg void OnDrawItem(int nIDCtl, LPDRAWITEMSTRUCT lpDrawItemStruct);
    afx_msg void OnClose();
    afx_msg LRESULT OnTrayIconClick(WPARAM wParam, LPARAM lParam);
    afx_msg void OnTrayRestore();
    afx_msg void OnTrayExit();
    afx_msg void OnBnClickedButtonConnect();
    afx_msg void OnBnClickedButtonDisconnect();
    afx_msg void OnBnClickedButtonReceiveFromCtrl();
    afx_msg void OnBnClickedButtonSendToCtrl();
    afx_msg void OnBnClickedButtonClearStore();
    afx_msg void OnBnClickedButtonStartStore();
    afx_msg void OnBnClickedButtonStopStore();
    afx_msg void OnBnClickedButtonClearLog();
    DECLARE_MESSAGE_MAP()

private:
    void ExitApplication();

    /**
     * @brief æ›´æ–°ç•Œé¢æŽ§ä»¶çš„可用状态。
     *
     * æ ¹æ®è®¾å¤‡è¿žæŽ¥çŠ¶æ€ `bConnected` å’Œå­˜å‚¨çŠ¶æ€ `bStoring` åŠ¨æ€æŽ§åˆ¶ç•Œé¢ä¸ŠæŒ‰é’®ã€
     * ç¼–辑框、下拉框等控件的可用/禁用状态。
     *
     * @param bConnected è®¾å¤‡å½“前是否已连接，TRUE è¡¨ç¤ºå·²è¿žæŽ¥ï¼ŒFALSE è¡¨ç¤ºæœªè¿žæŽ¥ã€‚
     * @param bStoring å½“前是否正在进行数据存储，TRUE è¡¨ç¤ºæ­£åœ¨å­˜å‚¨ã€‚
     */
    void UpdateControlStatus(BOOL bConnected, BOOL bStoring = FALSE);

    /**
     * @brief å¯åŠ¨æ‰¹é‡æ—¥å¿—追加，暂停自动滚动，提高性能。
     */
    void AppendLogLineBatchBegin();

    /**
     * @brief ç»“束批量日志追加，恢复自动滚动并刷新显示。
     */
    void AppendLogLineBatchEnd();

    /**
     * @brief é™åˆ¶å¯Œæ–‡æœ¬æ¡†ä¸­çš„最大行数，避免日志过多导致性能问题。
     *
     * @param maxLines æœ€å¤§ä¿ç•™çš„行数，默认值为 100。
     */
    void TrimRichEditLineLimit(int maxLines = 100);

    /**
     * @brief å‘日志窗口追加一条带颜色样式的日志行。
     *
     * @param content æ—¥å¿—内容。
     * @param color å­—体颜色，默认为黑色。
     */
    void AppendLogLineRichStyled(const CString& content, COLORREF color = RGB(0, 0, 0));

    /**
     * @brief é«˜äº®æ—¥å¿—中所有匹配指定字符串的部分。
     *
     * @param strSearch è¦åŒ¹é…çš„字符串。
     * @param clrHighlight é«˜äº®é¢œè‰²ï¼Œé»˜è®¤ä¸ºæ©™è‰²ï¼ˆRGB(255, 165, 0)）。
     */
    void HighlightAllMatches(const CString& strSearch, COLORREF clrHighlight = RGB(255, 165, 0));

    /**
     * @brief ä»¥æ ¼å¼åŒ–方式输出指定通道的测量数据样本到日志。
     *
     * æ¯è¡Œè¾“出固定数量（如 7）个浮点数据，带时间戳、通道编号标识，便于调试查看。
     *
     * @param nOutNo è¾“出端口编号，用于标识日志来源，如 OUT1、OUT2 ç­‰ã€‚
     * @param vecBuffer æµ‹é‡æ•°æ®ç¼“存，将被逐行打印到日志中。
     */
    void PrintSampleData(int nOutNo, const std::vector<float>& vecBuffer);

    /**
     * @brief å°è¯•è¿žæŽ¥åˆ°æµ‹é‡è®¾å¤‡ã€‚
     *
     * @return true è¡¨ç¤ºè¿žæŽ¥æˆåŠŸï¼Œfalse è¡¨ç¤ºè¿žæŽ¥å¤±è´¥ã€‚
     */
    bool ConnectToDevice();

    /**
     * @brief æ–­å¼€ä¸Žæµ‹é‡è®¾å¤‡çš„连接。
     *
     * @return true è¡¨ç¤ºæ–­å¼€æˆåŠŸï¼Œfalse è¡¨ç¤ºæ–­å¼€å¤±è´¥ã€‚
     */
    bool DisconnectFromDevice();

    /**
     * @brief åŽŸåœ°æ¸…除无效值（如 -999.0f）并更新数据。
     *
     * @param nOutNo è¾“出通道编号，用于日志记录。
     * @param vecData è¾“入输出数据容器，内部将被就地裁剪。
     * @param fInvalid æ— æ•ˆå€¼çš„判断阈值，默认值为 -999.0f。
     */
    void CleanInvalidValuesInPlace(int nOutNo, std::vector<float>& vecData, float fInvalid = -999.0f);

    /**
     * @brief å°†æœ‰æ•ˆæ•°æ®åˆ‡å‰²æˆä¸¤æ®µçŽ»ç’ƒæ•°æ®ï¼ˆGlass1 ä¸Ž Glass2）。
     *
     * @param nOutNo è¾“出通道编号，用于日志记录。
     * @param validData è¾“入的有效数据（应已裁剪边界）。
     * @param vecGlass1 è¾“出第一段玻璃数据。
     * @param vecGlass2 è¾“出第二段玻璃数据。
     * @param fJumpThreshold è·³å˜é˜ˆå€¼ï¼Œç”¨äºŽæ£€æµ‹æ•°æ®çš„明显断点。
     * @param nWindow è·³å˜åˆ¤æ–­çš„前后窗口宽度。
     * @param nValleyMargin valley ç‚¹ä¹‹åŽå¤šå°‘个点作为实际切割点。
     * @param nMinGlass1Count ç¬¬ä¸€æ®µæœ€å°‘有效点数限制。
     *
     * @return true è¡¨ç¤ºåˆ‡å‰²æˆåŠŸï¼Œfalse è¡¨ç¤ºå¤±è´¥ï¼ˆä¾‹å¦‚数据不足或无明显跳变）。
     */
    bool SplitGlassSegments(int nOutNo, const std::vector<float>& validData,
        std::vector<float>& vecGlass1, std::vector<float>& vecGlass2,
        float fJumpThreshold = 1.0f, int nWindow = 3, int nValleyMargin = 0,
        int nMinGlass1Count = 10);

    /**
     * @brief ä»Žè¾“入数据中提取一个固定长度的稳定区间。
     *
     * @param nOutNo è¾“出通道编号，用于日志记录。
     * @param vecIn è¾“入原始数据。
     * @param vecOut è¾“出提取的稳定区域数据。
     * @param nFixedCount ç¨³å®šåŒºåŸŸçš„点数要求（必须固定数量）。
     * @param fMaxDelta å…è®¸çš„最大波动范围（最大值 - æœ€å°å€¼ï¼‰ã€‚
     *
     * @return true è¡¨ç¤ºæˆåŠŸæ‰¾åˆ°ç¨³å®šåŒºé—´ï¼Œfalse è¡¨ç¤ºæœªæ‰¾åˆ°ã€‚
     */
    bool ExtractStableRegionFixed(int nOutNo, 
        const std::vector<float>& vecIn,
        std::vector<float>& vecOut,
        int nFixedCount = 5, float fMaxDelta = 0.05f);

    /**
     * @brief è®¡ç®—两片玻璃稳定区域的平均值和偏移量。
     *
     * @param vecGlass1 ç¬¬ä¸€æ®µç¨³å®šæ•°æ®ã€‚
     * @param vecGlass2 ç¬¬äºŒæ®µç¨³å®šæ•°æ®ã€‚
     * @param fAvg1 è¿”回第一段的平均值。
     * @param fAvg2 è¿”回第二段的平均值。
     * @param fOffset è¿”回两段的偏移值（绝对值差）。
     *
     * @return true è¡¨ç¤ºè®¡ç®—成功，false è¡¨ç¤ºè¾“入无效（如空数据）。
     */
    bool CalcGlassOffset(const std::vector<float>& vecGlass1,
        const std::vector<float>& vecGlass2,
        float& fAvg1, float& fAvg2, float& fOffset);

    // === ç³»ç»ŸçŠ¶æ€ä¸Žè¿è¡Œæ•°æ® ===

    /**
     * @brief å½“前是否已连接到传感器控制器
     */
    bool m_bConnected;

    /**
     * @brief å½“前是否正在进行数据存储
     */
    bool m_bSaving;

    /**
     * @brief å››ä¸ªè¾“出端口的当前计算结果（如偏移量或厚度等）
     */
    double m_dOutValues[4];

    // === å­˜å‚¨è®¾ç½®ç›¸å…³ ===

    /**
     * @brief æ˜¯å¦ä½¿ç”¨ç¡¬ä»¶è§¦å‘信号（0=否，1=是）
     */
    int m_nUseTrigger;

    /**
     * @brief æ¯æ¬¡é‡‡é›†çš„数据点数量
     */
    int m_nSavePointCount;

    /**
     * @brief è¾“出端口选择下拉框控件（用于设置采集端口）
     */
    CComboBox m_comboOutputPort;

    // === è·³å˜æ£€æµ‹ä¸ŽçŽ»ç’ƒè¯†åˆ«å‚数（SplitGlassSegments ä½¿ç”¨ï¼‰ ===

    /**
     * @brief è·³å˜é˜ˆå€¼ï¼ˆä¾‹å¦‚ 0.2mm），用于检测两片玻璃之间的高度跳变
     */
    float m_fJumpThreshold;

    /**
     * @brief è·³å˜æ£€æµ‹çª—口半宽度（用于差分计算）
     */
    int m_nJumpWindow;

    /**
     * @brief valley ç‚¹å³ç§»çš„偏移量，用于最终确定分割点
     */
    int m_nValleyMargin;

    /**
     * @brief ç¬¬ä¸€ç‰‡çŽ»ç’ƒæœ€å°‘所需的数据点数
     */
    int m_nMinGlass1Count;

    // === ç¨³å®šåŒºåŸŸæå–参数（ExtractStableRegionFixed ä½¿ç”¨ï¼‰ ===

    /**
     * @brief æ¯æ®µç¨³å®šåŒºåŸŸè¦æå–的固定数据点数
     */
    int m_nFixedCount;

    /**
     * @brief æœ€å¤§å…è®¸æ³¢åŠ¨èŒƒå›´ï¼ˆä¾‹å¦‚ 0.05mm），判断是否为“稳定”区域
     */
    float m_fMaxDelta;

    // === æ—¥å¿—控件 ===

    /**
     * @brief å¯Œæ–‡æœ¬æŽ§ä»¶ï¼Œç”¨äºŽè¾“出带颜色的日志信息
     */
    CRichEditCtrl m_editLog;

    // === æ‰˜ç›˜å›¾æ ‡ç®¡ç† ===

    /**
     * @brief æ‰˜ç›˜å›¾æ ‡ç›¸å…³æ•°æ®ç»“构（NOTIFYICONDATA）
     */
    NOTIFYICONDATA m_trayIconData;

    /**
     * @brief æ‰˜ç›˜å›¾æ ‡çš„唯一 ID
     */
    UINT m_nTrayIconID;

    /**
     * @brief æ ‡è®°æ‰˜ç›˜å›¾æ ‡æ˜¯å¦å·²æˆåŠŸåˆ›å»º
     */
    BOOL m_bTrayIconCreated;

    /**
     * @brief æ ‡è®°ç¨‹åºæ˜¯å¦é€šè¿‡æ‰˜ç›˜å›¾æ ‡é€€å‡º
     */
    BOOL m_bExitingFromTray;
};

 SourceCode/Bond/SGMeasurement/framework.h

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,49 @@
#pragma once

#ifndef VC_EXTRALEAN
#define VC_EXTRALEAN            // ä»Ž Windows å¤´ä¸­æŽ’除极少使用的资料
#endif

#include "targetver.h"

#define _ATL_CSTRING_EXPLICIT_CONSTRUCTORS      // æŸäº› CString æž„造函数将是显式的

// å…³é—­ MFC çš„一些常见且经常可放心忽略的隐藏警告消息
#define _AFX_ALL_WARNINGS

#include <afxwin.h>         // MFC æ ¸å¿ƒç»„件和标准组件
#include <afxext.h>         // MFC æ‰©å±•


#include <afxdisp.h>        // MFC è‡ªåŠ¨åŒ–ç±»



#ifndef _AFX_NO_OLE_SUPPORT
#include <afxdtctl.h>           // MFC å¯¹ Internet Explorer 4 å…¬å…±æŽ§ä»¶çš„支持
#endif
#ifndef _AFX_NO_AFXCMN_SUPPORT
#include <afxcmn.h>             // MFC å¯¹ Windows å…¬å…±æŽ§ä»¶çš„支持
#endif // _AFX_NO_AFXCMN_SUPPORT

#include <afxcontrolbars.h>     // MFC æ”¯æŒåŠŸèƒ½åŒºå’ŒæŽ§åˆ¶æ¡









#ifdef _UNICODE
#if defined _M_IX86
#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='x86' publicKeyToken='6595b64144ccf1df' language='*'\"")
#elif defined _M_X64
#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='amd64' publicKeyToken='6595b64144ccf1df' language='*'\"")
#else
#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"")
#endif
#endif



 SourceCode/Bond/SGMeasurement/pch.cpp

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,5 @@
// pch.cpp: ä¸Žé¢„编译标头对应的源文件

#include "pch.h"

// å½“使用预编译的头时，需要使用此源文件，编译才能成功。

 SourceCode/Bond/SGMeasurement/pch.h

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,13 @@
// pch.h: è¿™æ˜¯é¢„编译标头文件。
// ä¸‹æ–¹åˆ—出的文件仅编译一次，提高了将来生成的生成性能。
// è¿™è¿˜å°†å½±å“ IntelliSense æ€§èƒ½ï¼ŒåŒ…括代码完成和许多代码浏览功能。
// ä½†æ˜¯ï¼Œå¦‚果此处列出的文件中的任何一个在生成之间有更新，它们全部都将被重新编译。
// è¯·å‹¿åœ¨æ­¤å¤„添加要频繁更新的文件，这将使得性能优势无效。

#ifndef PCH_H
#define PCH_H

// æ·»åŠ è¦åœ¨æ­¤å¤„预编译的标头
#include "framework.h"

#endif //PCH_H

 SourceCode/Bond/SGMeasurement/res/SGMeasurement.ico

 SourceCode/Bond/SGMeasurement/res/SGMeasurement.rc2

Binary files differ

 SourceCode/Bond/SGMeasurement/res/menu_close.ico

 SourceCode/Bond/SGMeasurement/res/menu_restore.ico

 SourceCode/Bond/SGMeasurement/resource.h

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,45 @@
//{{NO_DEPENDENCIES}}
// Microsoft Visual C++ ç”Ÿæˆçš„包含文件。
// ä¾› SGMeasurement.rc ä½¿ç”¨
//
#define IDM_ABOUTBOX                    0x0010
#define IDD_ABOUTBOX                    100
#define IDS_ABOUTBOX                    101
#define IDD_SGMEASUREMENT_DIALOG        102
#define IDR_MAINFRAME                   128
#define IDI_ICON_RESTORE                130
#define IDI_ICON_EXIT                   131
#define IDC_IPADDRESS                   1000
#define IDC_BUTTON_CONNECT              1001
#define IDC_BUTTON_DISCONNECT           1002
#define IDC_EDIT_OUT1                   1003
#define IDC_EDIT_OUT2                   1004
#define IDC_EDIT_OUT3                   1005
#define IDC_EDIT_OUT4                   1006
#define IDC_CHECK_USE_TRIGGER           1007
#define IDC_EDIT_STORE_COUNT            1008
#define IDC_COMBO_OUTPUT_PORT           1009
#define IDC_BUTTON_START_STORE          1010
#define IDC_BUTTON_STOP_STORE           1011
#define IDC_BUTTON_CLEAR_STORE          1012
#define IDC_BUTTON_RECEIVE_FROM_CTRL    1013
#define IDC_BUTTON_SEND_TO_CTRL         1014
#define IDC_RICHEDIT_LOG                1015
#define IDC_BUTTON_CLEAR_LOG            1016
#define IDC_EDIT_JUMP_THRESHOLD         1017
#define IDC_EDIT_JUMP_WINDOW            1018
#define IDC_EDIT_VALLEY_MARGIN          1019
#define IDC_EDIT_MIN_GLASS_COUNT        1020
#define IDC_EDIT_FIXED_COUNT            1021
#define IDC_EDIT_MAX_DELTA              1022

// Next default values for new objects
// 
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE        132
#define _APS_NEXT_COMMAND_VALUE         32771
#define _APS_NEXT_CONTROL_VALUE         1023
#define _APS_NEXT_SYMED_VALUE           101
#endif
#endif

 SourceCode/Bond/SGMeasurement/targetver.h

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,8 @@
#pragma once

// åŒ…括 SDKDDKVer.h å°†å®šä¹‰å¯ç”¨çš„最高版本的 Windows å¹³å°ã€‚

//如果要为以前的 Windows å¹³å°ç”Ÿæˆåº”用程序，请包括 WinSDKVer.h，并
// å°† _WIN32_WINNT å®è®¾ç½®ä¸ºè¦æ”¯æŒçš„平台，然后再包括 SDKDDKVer.h。

#include <SDKDDKVer.h>