SECS/GEM 产品开发和介绍[通俗易懂]

大家好，欢迎来到IT知识分享网。

官网网址 www.secsgem.cn​​​​​​​

金南瓜SECS/GEM为你快速搭建设备与工厂之间的交互。 

 我们为你提供专业的SECS/GEM设备设计方案，使得设备更加稳定而高效，进而比同行更有优势。

SECS/GEM仅需数周，设备就能得到客户的验收与认可，SECS/GEM 7*24 稳定运行于现场。

我们完整的SECS/GEM核心功能让你专注于设备优化和销售，无需顾虑设备与工厂之间的SECS/GEM交互。

最新的SEMI 标准 ：
金南瓜 SECS/GEM强调遵循最新 的SEMI 标准。让你的产品时俱进，引领时代新潮流
不同工厂会实现出不同的MES系统 ，我们的SECS/GEM产品会智能兼容
SECS/GEM不存在繁体字、英文SDK的乱码及未知BUG

规格 ：
1 .符合SEMI E5、E30、E37 的 SECS/GEM通讯规范
2. 完善SECS/GEM  Log 档案可查询历史通讯记录 
3 .支持C、C++、C#、Labview、PLC等

软件特点：
1. 拥有完善的方案 ，SECS/GEM 软件开发时间可缩短80％ 。
2. SECS/GEM 已经集成大量的逻辑和各类的应用场景，稳定运行于几十个工厂
3. 以 DLL 模块提供API接口使用，简单方便

硬件： 
1. 低至入门级别CPU ，例如赛扬、奔腾

优势： 
1. SECS/GEM全中、英文说明书，无需为英语而烦心   
2. 中文 SECS/GEM SDK 以及完善的使用资料
3. SECS/GEM 自主开发，拥有软件的全部知识产权，SECS/GEM 能够改善和优化系统
4. 优秀的模块化设计及交互API，毫秒级交互

金南瓜SECS/GEM通讯软件工具包提供设备端SDK和连接工具。

功能清单

事件报告、警报通知、数据上报、远程控制、Recipe上传下载等等 SECS/GEM

额外的功能

由于功能实现困难，SECS/GEM 国内基本没供应商有能力实现该功能，而金南瓜已经实现并且在提供给数十家工厂终端使用。
Wafer Map 和Strip Map上传下载，在固晶机器和点测设备属于重要的功能。SECS/GEM 点测设备将测量结果通过Map报告测量结果，固晶机器通过Wafer Map获知需要提取的颗粒。

Wafer Map

Strip Map

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;

namespace EquipViewAppNet
{
    static class Program
    {
        /// <summary>
        /// 应用程序的主入口点。
        /// </summary>
        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new SecsAppView());
        }
    }
}

示例代码

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using SecsEquip;
using SecsBase;

namespace EquipViewAppNet
{
    public partial class CSecsParament : Form
    {
        public CSecsEquip m_pSecs = null;


        public CSecsParament()
        {
            InitializeComponent();
            InitData();
        }

        // 初始化
        void InitData()
        {            
            textBoxMDLN.Text = "JNG";
            textBoxDeviceID.Text = "0";

            textBoxIP.Text = "127.0.0.1";
            textBoxPort.Text = "5555";
            checkBoxPassive.Checked = true;
            checkBoxEnableLog.Checked = false;
            checkBoxComunication.Checked = true;
            
            textBoxT1.Text = "10000";
            textBoxT2.Text = "10000";
            textBoxT3.Text = "45000";
            textBoxT4.Text = "10000";
            textBoxT5.Text = "10000";
            textBoxT6.Text = "5000";
            textBoxT7.Text = "10000";
            
            comboBoxControl.Items.Add("OFF-LINE");
            comboBoxControl.Items.Add("ON-LINE LOCAL");
            comboBoxControl.Items.Add("ON-LINE REMOTE");
            comboBoxControl.Text = "OFF-LINE";
        }


        private void buttonSet_Click(object sender, EventArgs e)
        {
            
            m_pSecs.SetIP(textBoxIP.Text);

            int nTmp = StringToNum.atoi(textBoxPort.Text.ToString());
            m_pSecs.SetPort(nTmp);

            m_pSecs.SetMDLN(textBoxMDLN.Text);

            nTmp = StringToNum.atoi(textBoxDeviceID.Text.ToString());
            m_pSecs.SetDeviceID(nTmp);

            m_pSecs.SetPassive(checkBoxPassive.Checked);

            m_pSecs.SetEnableLog(checkBoxEnableLog.Checked);
            
            nTmp = StringToNum.atoi(textBoxT1.Text.ToString());
            m_pSecs.SetT1(nTmp);

            nTmp = StringToNum.atoi(textBoxT2.Text.ToString());
            m_pSecs.SetT2(nTmp);

            nTmp = StringToNum.atoi(textBoxT3.Text.ToString());
            m_pSecs.SetT3(nTmp);

            nTmp = StringToNum.atoi(textBoxT4.Text.ToString());
            m_pSecs.SetT4(nTmp);

            nTmp = StringToNum.atoi(textBoxT5.Text.ToString());
            m_pSecs.SetT5(nTmp);

            nTmp = StringToNum.atoi(textBoxT6.Text.ToString());
            m_pSecs.SetT6(nTmp);

            nTmp = StringToNum.atoi(textBoxT7.Text.ToString());
            m_pSecs.SetT7(nTmp);


            // checkBoxComunication, comboBoxControl 这俩个开软件时候设置
        }
    }
}

Driver代码

“`cpp

// 新方法发送
void CSecsExampleJngDlg::OnBnClickedButtonS5f1New()
{

    CSecsList pList;
    CSecsBinary pALCD(1);
    CSecsAscii pALID(“1000”);
    CSecsAscii pALTX(“Fire Alarm”);

    pList.AddItem(pALCD);
    pList.AddItem(pALID);
    pList.AddItem(pALTX);

    // 发送数据
    long nTransaction = 0;
    m_JngSecs.AsyncSend(5, 1, true, nTransaction, pList);

}
“`
显示当前的状态代码
“`cpp

void CSecsExampleJngDlg::OnStateChangeHandle(int nState)
{

    if(!IsWindow(m_hWnd))
    {

        return;
    }

    string pAllInfo;
    switch (nState)
    {

    case eSecsStateDisconnect:    pAllInfo = ” 断开连接”;        break;
    case eSecsStateListen:        pAllInfo = ” 倾听”;            break;
    case eSecsStateConnect:        pAllInfo = ” 建立连接”;        break;
    case eSecsStateEnsureComm:    pAllInfo = ” 通讯”;            break;
    }
    pAllInfo += “\r\n”;

    CString pText;
    m_editMsg.GetWindowText(pText);
    pText += pAllInfo.c_str();
    m_editMsg.SetWindowText(pText);

}
“`

S2F25示例代码

“`cpp
void CSecsExampleJngDlg::OnBnClickedButtonS2f25()
{

    // S2F25 R
    int nStream = 0;
    int nFunc = 0;
    CJsData pData, pReply;
    
    // 封装数据
    char pBList[5] = {0x10, 0x22, 0x33, 0x44, 0x55};

     pData.AddList(3);
     pData.AddBinary(5, pBList);
     pData.AddAscii(“1023456a”);
     pData.AddList(6);
     pData.AddAscii(“10qwq6a”);
     pData.AddAscii(“102wq 3456a”);
     pData.AddDouble(5.22);
    pData.AddInt(512);
    pData.AddInt((__int16)512);
    pData.AddUint((unsigned __int16)512);

    ShowData(2, 25, &pData);    

    long nCode = m_JngSecs.SyncSend(2, 25, true, pData, nStream, nFunc, pReply);

    // 提取数据
    if(nCode == 0)
    {

        int nType;
        int nSize;
        char* pTmp = NULL;
        nCode = pReply.GetNextData(nType, nSize, (void**)&pTmp);
        nCode = pReply.GetNextData(nType, nSize, (void**)&pTmp);
        nCode = pReply.GetNextData(nType, nSize, (void**)&pTmp);
        nCode = pReply.GetNextData(nType, nSize, (void**)&pTmp);
        nCode = pReply.GetNextData(nType, nSize, (void**)&pTmp);
        nCode = pReply.GetNextData(nType, nSize, (void**)&pTmp);

        // 没有更多的数据了
        nCode = pReply.GetNextData(nType, nSize, (void**)&pTmp);
        nCode = pReply.GetNextData(nType, nSize, (void**)&pTmp);
        nCode = pReply.GetNextData(nType, nSize, (void**)&pTmp);

         ShowData(nStream, nFunc, &pReply);
    }

    nFunc = 0;
    return;

    // 方法2
    MESSGE_PARAM pParam;
    pParam.nStream = 2;
    pParam.nFunction = 25;
    pParam.nNeedReply = 1;
    MESSGE_PARAM pReplyParam;

    nCode = m_JngSecs.SyncSend(pParam, pData, pReplyParam, pReply);

}
“`
通讯的示例

“`cpp

void CSecsExampleJngDlg::OnCommS1F13(int nTransaction)
{

    CJsData pData;

    // S1F13 R
    // <L[2]        
    //   <A[] “jin nan gua ke ji”>
    //   <A[] “1.0.4”>
    // >
    pData.AddList(2);
    pData.AddBinary(0);
    pData.AddList(2);
    pData.AddAscii(“jin nan gua ke ji”);
    pData.AddAscii(“1.0.4”);
    ShowData(1, 14, &pData);

    m_JngSecs.ReplySend(1, 14, nTransaction, pData);

}
“`

SECS Driver使用说明书
金南瓜科技有限公司
 
1 简介
1. Secs Driver 由金南瓜科技提供，适用于半导体、光伏、面板、PCB等行业
支持C、C++、C#等编程语言（C#对应C#DLL库）

2. SECS Driver集成E5,E37的功能。支持主动或者被动模式通讯，实时接收数据和反馈通讯状态给上层应用。

3. 用户可以按照客户的要求(Space)或自己的需求，进行设计SECS编码。SECS Driver提供编辑SECS编码的接口。

4. 接口使用简单，支持多线异步调用，无需用户考虑多线程问题。SECS Driver支持用户多线程交互使用。

5. 金南瓜已经集成HSMS的功能处理，超时处理、Message等待接收超时、重试连接等。

2 使用
2.1 C/C++版本
2.1.1 导入资料
将以下文件添加到项目当中
–> JngHightSpeedSecsExport.h
–> JngSecsEx.h 
–> JngSecsEx.cpp 

 
代码文件

 
依赖库DLL

 
依赖Lib
 
2.1.2 添加依赖项
依赖性如下图
JngHightSpeedSecs.lib
 

2.1.3 添加文件到项目
将.h和.cpp添加到项目中
 

2.2 C#版本
2.2.1 生成CNetInteface
1. 用户将C#编译CNetInteface成自己所用的.net平台，例如net4.5，net4.6
 

CNetInteface项目
 

2.2.2 添加CNetInteface.Dll
1. 将生成的CNetInteface.Dll添加到项目当中
 

3 SECS、HSMS 简介
3.1 SECS 超时定义
Timeout    Value Range    Resolution    Typical Value     Description 
T3     1-120 seconds    1 seconds    45 seconds    Reply timeout. Specifies maximum amount of time an entity expecting a reply message shall wait for that reply.
消息答复超时。
T5     1-240 seconds    1 seconds    10 seconds    Connection Separation Timeout. Specifies the amount of time which must elapse between successive attempts to connect to a given remote entity.
连接失败重试时间。
T6     1-240 seconds    1 seconds    5 seconds    Control Transaction Timeout. Specifies the time which a control transaction may remain open before it is considered a communications failure.
控制交换超时。
T7    1-240 seconds    1 seconds    10 seconds    Time which a TCP/IP connection can remain in NOT SELECTED state (i.e., no HSMS activity) before it is considered a communications failure.
No Select选择超时
T8    1-120 seconds    1 seconds    5 seconds    Maximum time between successive bytes of a single HSMS message which may expire before it is considered a communications failure. 

3.2 连接模式
HSMS通讯有俩种通讯模式

1. Active主动模式：
    主动连接到对方

2. Passive被动模式：
    被动等待对方连接过来。

3.3 TCP/IP参数
参数分别是TCP/IP地址和TCP/IP端口号。

3.4 DeviceID设备ID
DeviceID也称为Session ID（会话ID）。
需要双方的DeviceID一致才能进行会话。

 
4. C# API接口简介
4.1 C# JngSecsEx通讯接口类
该类为SECS通讯对象
4.1.1 StartSecs 开始通讯
    int StartSecs(JS_SETTING setting)
1. 通知Driver开始通讯
2. 附带参数JS_SETTING包含超时、IP、端口号等

4.1.2 StopSecs停止通讯
public void StopSecs()
1.    通知Driver停止通讯

4.1.3 SendAsyncData 发送异步数据
该函数发送消息成功后，函数立马返回。

int SendAsyncData(int nStream, int nFunction, bool bNeedReply, ref int nTransaction, JngDataEx pData = null)
    
1.    接收答复的消息需要通过注册OnMsgHandle pMsgHandle响应函数。
2.    nTransaction是消息唯一ID。通过该ID可以与接收的数据关联。
3.    bNeedReply设置是否需要对方答复该消息。
4.    pData是发送给对方的数据

4.1.4 SendSyncData 发送同步数据
该函数发送消息成功后，函数会等待对方答复消息或者等待超时后才返回。

int SendSyncData(int nStream, int nFunction, bool bNeedReply, JngDataEx pData,             ref int nReplyStream, ref int nReplyFunction, ref JngDataEx pReplyData)

1.    bNeedReply设置是否需要对方答复该消息。
2.    nReplyStream是对方答复的Stream
3.    nReplyFunction是对方答复的Function
4.    pReplyData是对方答复的数据

4.1.5 SendReplyMessage 答复函数
该函数用于答复对方主动发送过来的数据。
int SendReplyMessage(int nStream, int nFunction, int nTransaction, ref JngDataEx pData)

1.    nTransaction该参数在OnMsgHandle的消息通知里面含有。
2.    pData是答复对方的数据

4.2 C# JngDataEx数据处理类
JngDataEx用于构建和解析SECS消息

4.2.1 创建一个数据对象
JngDataEx pObject = new JngDataEx();
该对象管理SECS格式的消息数据。

4.2.2 AddList 添加SECS list数据
void AddList(int nSize)
如下边SECS消息的L类型
L,2
1. <MDLN>
2. <SOFTREV>

1.    nSize参数为list的个数。如：上边的个数为2。

4.2.3 AddAscii添加ASCII字符串
public void AddAscii(string pData)
void AddAscii(char[] pData)
添加字符串到数据当中

1.    pData为ASCII字符串。ASCII字符可参考相关标准。

4.2.4 AddBinary添加二进制数据
void AddBinary(byte[] pData)
    添加二进制数据到数据当中

1.    pData为二进制数据。

4.2.5 AddBool添加布尔数据
void AddBool(bool pData)
void AddBool(bool[] pData)
布尔数据未true和false

1.    pData为布尔数据。
2.    [] pData为多个布尔数据，基本用不到该函数。

4.2.6 AddInt添加整数数据
void AddInt(Int16 pData)
void AddInt(Int16[] pData)
void AddInt(Int32 pData)
void AddInt(Int32[] pData)

1.    添加整形数据
2.    [] pData为多个整形数据，基本用不到该函数。

4.2.7 AddUInt添加无符号整数数据
void AddUInt (byte pData)
void AddUInt (byte[] pData)
void AddUInt (Int16 pData)
void AddUInt (Int16[] pData)
void AddUInt (Int32 pData)
void AddUInt (Int32[] pData)

1.    添加整形数据
2.    [] pData为多个整形数据，基本用不到该函数。

4.2.8 AddFloat添加浮点型数据
void AddFloat (float pData)
void AddFloat (float[] pData)

1.    添加浮点数据
2.    [] pData为多个数据，基本用不到该函数。

4.2.9 AddDouble添加浮点型数据
void AddDouble (double pData)
void AddDouble (double[] pData)

3.    添加浮点数据
4.    [] pData为多个数据，基本用不到该函数。

4.2.10 MoveHead数据移动到开始位置
    void MoveHead()
    用于读取数据，从头开始读取SECS数据。

4.2.11 DataIsEnd判断数据是否读完全部
bool DataIsEnd()
用于读取数据，判断是否读取完

1.    返回值为true代表以及读取（提取）完SECS数据

4.2.12 GetNextDataType获取下一个数据的信息
Int32 GetNextDataType(ref SECS_TYPE nType, ref Int32 nSize)
用于读取数据，获取下一个数据的长度、类型

1.    

4.2.13 GetNextData获取下一个数据的值
Int32 GetNextData(ref SECS_TYPE nType, ref Int32 nSize, ref object pData)
用于读取数据，获取数据类型、长度、值

1.    nType为数据的类型
2.    nSize为数据的个数
3.    pData为数据对象，需要转换成对象数据个数

4.3相关参数资料
4.3.1 SECS数据类型清单
    public enum SECS_TYPE
    { 
        _ERR_TYPE       = 0x00,
        _LIST            = 0x01,
        _BINARY            = 0x02,
        _BOOLEAN        = 0x03,
        _ASCII            = 0x04,
        _I1                = 0x10,         
        _I2                = 0x11,
        _I4                = 0x12,
        _I8                = 0x13,
        _F8                = 0x20,
        _F4                = 0x21,
        _U1                = 0x30,
        _U2                = 0x31,
        _U4                = 0x32,
        _U8                = 0x33,
    }
4.3.2 错误代码
  public enum SECS_MODULE_CODE
  {

      SUCC,                       
      CODE_POINT_IS_NULL,            
      CODE_SECS_DATA_ERROR,        
      CODE_SECS_DATA_SIZE_ERROR,    
      CODE_SECS_NO_MORE_DATA,   
  }

4.3.3 通讯状态
  public enum SECS_STATE
  {

      eSecsStateDisconnect,
      eSecsStateListen,        
      eSecsStateConnect,        
      eSecsStateEnsureComm,    
  };

4.3.4 SECS通讯参数
[StructLayout(LayoutKind.Sequential, Pack = 1)]
    public struct JS_SETTING      
    {

        public Int32 nT3;                        // Reply timeout
        public Int32 nT5;                        // Connect separation timeout
        public Int32 nT6;                        // Control transaction timeout
        public Int32 nT7;                        // Not selected timeout
        public Int32 nT8;                        // Network intercharacter timeout
        public Int32 nConnectMode;                // 1=Passive, 0=Active    
        public Int32 nPort;
        public Int32 nDeviceID;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 24)]
        public string pIP;                        // a string IP “103.214.16.101”     
    };

4.3.4 数据信息
[StructLayout(LayoutKind.Sequential, Pack = 1)]
    public struct MESSGE_PARAM        
    {

        public Int32 nStream;
        public Int32 nFunction;
        public Int32 nNeedReply;        // 0：不需要答复， 1：需要答复
        public Int32 nTransaction;        // 主动发送时候为空 
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 10)]
        public Byte[] pHeader;          
    };

4.4 接口使用和顺序
1. 创建JngSecsEx对象
2. 添加处理回调函数
    pMsgHandle
pStateChangeHandle
3. 开始通讯：StartSecs
4. 等待pStateChangeHandle反馈SECS_STATE.eSecsStateEnsureComm通讯建立成功
5. 开始SECS的消息交互

5 使用SECS库
使用顺序
1. 创建通讯对象
2. 初始化参数
3. 开始通讯
4. 收发数据
5.1 创建SECS对象
CJngSecsEx m_JngSecs;        // 金南瓜的SECS
5.2 设置通讯参数及建立通讯
1. 设置处理回调函数
m_JngSecs.SetCallback(::MsgCallback, ::OnStateChange, this);    

    2. 设置参数并且开始通讯
    JS_SETTING setting;
    setting.nConnectMode = m_bPassive?1:0;
    setting.nDeviceID = 0;
    setting.nPort = m_nPort;
    strncpy_s(setting.pIP, m_pIP, 24);

    setting.nT3 = 5000;
    setting.nT5 = 5000;
    setting.nT6 = 5000;
    setting.nT7 = 5000;

    m_JngSecs.StartSecs(setting);

5.3 构建SECS数据
1. 创建数据对象
CJsData pData;

2. 添加SECS数据
pData.AddList(4);
    pData.AddAscii(“jin nan gua ke ji”);
    pData.AddAscii(“1.0.4”);
pData.AddDouble(5.22);
    pData.AddInt(512);

5.4 发送SECS数据
返回值为发送结果
long nCode = m_JngSecs.AsyncSend(2, 25, true, nTransaction, pData);

或者
long nCode = m_JngSecs.SyncSend(2, 25, true, nTransaction, pData, nStream, nFunc, nReplyTransaction, pReply);
    

头文件依赖库

“`cpp
#pragma once
#include “JngHightSpeedSecsExport.h”

#pragma comment (lib, “JngHightSpeedSecs”)

///
// 广州金南瓜科技 SECS库
// 网站 http://www.semisecs.com
///

class CJsData;

// 回调函数
typedef void (OnMsgProcEx) (MESSGE_PARAM pPaeam, CJsData* pData, void* pClient);        // 消息到来    
typedef void (OnStateChangeProcEx) (SECS_STATE nState, void *pClientData);                // 通讯状态改变
// OnMsgProcEx 回调函数属于线程安全对象，可以阻塞处理事务
// OnStateChangeProcEx 回调函数不可阻塞处理事务

// 数据处理对象
class CJsData
{

public:
    CJsData();
    CJsData(const CJsData& pJsData);
    virtual ~CJsData();

    CJsData& operator = (const CJsData& dst);

    void AddItem(int nType, int nSize, void* pData);
    
// 数据提取
    void MoveHead();
    int GetNextData(int& nType, int& nSize, void** pData);
    bool DataIsEnd();
    

// 添加单个指定数据
    void AddList(int nSize);    
    void AddAscii(char* pData);
    void AddAscii(int nSize, char* pData);
    void AddBinary(char pData);
    void AddBinary(int nSize, char* pData);

    void AddBool(bool pData);

    void AddInt(char pData);
    void AddInt(short pData);
    void AddInt(__int32 pData);
    void AddInt(__int64 pData);

    void AddUint(unsigned char pData);
    void AddUint(unsigned short pData);
    void AddUint(unsigned __int32 pData);
    void AddUint(unsigned __int64 pData);

    void AddFolat(float pData);
    void AddDouble(double pData);

public:
    // 内部函数
    // 请勿使用以下函数
    JS_MSG_DATA GetData();                    // 获取数据
    void SetData(JS_MSG_DATA pData);        // 设置数据

private:
    JS_MSG_DATA m_pJsData;
    int m_nPos;
    bool m_bDataEnd;

};

// 通讯对象
// 支持多线程调用
class CJngSecsEx
{

public:
    CJngSecsEx();
    virtual ~CJngSecsEx();

    int StartSecs(JS_SETTING setting);        // 开始运行SECS，启用通讯
    void StopSecs();                        // 停止运行SECS
    
    // 数据发送
    int AsyncSend(MESSGE_PARAM& pParam, CJsData& pData);        // 异步发送数据

    int AsyncSend(int nStream, int nFunction, bool bNeedReply, long& nTransaction, CJsData& pData);        // 异步发送数据
    
    int SyncSend(MESSGE_PARAM& pParam, CJsData& pData, MESSGE_PARAM& pReplyParam, CJsData& pReplyData);    // 同步发送数据
    
    int SyncSend(int nStream, int nFunction, bool bNeedReply, CJsData& pData, 
        int& nRelpyStream, int& nRelpyFunction, CJsData& pReplyData);            // 同步发送数据

    int SyncSend(int nStream, int nFunction, bool bNeedReply, long& nTransaction, CJsData& pData, 
        int& nRelpyStream, int& nRelpyFunction, long& nRelpyTransaction, CJsData& pReplyData);            // 同步发送数据
    
    int ReplySend(int nStream, int nFunction, int nTransaction, CJsData& pData);        // 发送答复数据

    // 回调设置
    void SetCallback(OnMsgProcEx pProc, OnStateChangeProcEx pState, void* pClient);        // 设置回调函数
    

private:
    // 内部函数
    // 响应回调处理
    void OnMsgProcHandle(MESSGE_PARAM pPaeam, JS_MSG_DATA pData);
    void OnStateChangeHandle(int nState);

    // 消息到来
    static void __stdcall OnMsgProcImp (JS_COMM_OBJECT pComm, MESSGE_PARAM pPaeam, JS_MSG_DATA pData, void *pClientData);
    static void __stdcall OnStateChangeImp (__int32 nState, void *pClientData);

private:
    // 内部数据
    JS_COMM_OBJECT m_pSecsComm;

    OnMsgProcEx* m_pMsgProc;
    OnStateChangeProcEx* m_pStateChangeProc;
    void* m_pClient;

};