C#源码 SECS协议 SECS Driver案例大全 集成S5F1设置和清除 SECS资料明细实战例子

最新推荐文章于 2024-04-01 12:41:25 发布
最新推荐文章于 2024-04-01 12:41:25 发布
阅读量653 收藏 11
点赞数 11
文章标签： c# 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/secsgem300/article/details/135662476
版权

金南瓜SECS Driver是最适合应用于模板行业，已经被京东方、华星光电、天马等大厂大量应用

年初出机量数千套，价格非常的优惠实在

更多中文资料 www.secsgem.cn

发送S1F1消息

private void button1_Click(object sender, EventArgs e)
{
    int nTransaction = 0;

    // 数据对象
    JngDataEx pData = new JngDataEx();
    string x = "122323这是中文";
    pData.AddAscii(x);
    
    // 发送数据
    m_pSecs.SendAsyncData(1, 1, true, ref nTransaction, pData);

    // 记录LOG
    ShowMsg("\r\n异步消息ID:" + nTransaction.ToString() + "发送完成");
    ShowSML(1, 1, pData, true);
}

发送S1F13

private void button2_Click(object sender, EventArgs e)
{
    int nTransaction = 0;

    // 数据内容
    JngDataEx pData = new JngDataEx();
    pData.AddList(0);
    ShowSML(1, 13, pData, true);

    // 发送数据
    m_pSecs.SendAsyncData(1, 13, true, ref nTransaction, pData);
               
}

简单易懂的数据操作对象


    // SECS 数据类
    public class JngDataEx
    {
        IntPtr m_pJsData;
        int m_nPos;
        bool m_bDataEnd;

        public JngDataEx()
        {
            m_nPos = 0;
            m_pJsData = JngHightSpeedSecsExport.JS_CreateDataObject();
        }

        ~JngDataEx()
        {
            JngHightSpeedSecsExport.JS_DelereDataObject(m_pJsData);
        }
        
        // 添加单个指定数据
        public void AddList(int nSize)
        {
            JngHightSpeedSecsExport.JS_DataItemAddList(m_pJsData, nSize);
        }
        
        // ASCII字符串
        public void AddAscii(string pData)
        {
            IntPtr pAddr = Marshal.AllocHGlobal(pData.Length);
            try
            {
                byte[] pASCII = Encoding.ASCII.GetBytes(pData);
                Marshal.Copy(pASCII, 0, pAddr, pASCII.Length);
                JngHightSpeedSecsExport.JS_DataItemAdd(m_pJsData, (Int32)pData.Length, SECS_TYPE._ASCII, pAddr);
            }
            catch
            {
            }
            Marshal.FreeHGlobal(pAddr);
        }

        // ASCII字符串
        public void AddAscii(char[] pData)
        {
            IntPtr pAddr = Marshal.AllocHGlobal(pData.Length);
            try
            {                
                byte[] pASCII = Encoding.ASCII.GetBytes(pData);
                Marshal.Copy(pASCII, 0, pAddr, pASCII.Length);
                JngHightSpeedSecsExport.JS_DataItemAdd(m_pJsData, (Int32)pData.Length, SECS_TYPE._ASCII, pAddr);
            }
            catch
            {
            }
            Marshal.FreeHGlobal(pAddr);
        }

        // ASCII字符串，支持中文
        public void AddAscii(string pData)
        {           
            try
            {                
                JngHightSpeedSecsExport.JS_DataItemAddAscii(m_pJsData, (Int32)pData.Length, pData);
            }
            catch
            {
            }           
        }
        

        // 二进制
        public void AddBinary(byte[] pData)
        {
            IntPtr pAddr = Marshal.AllocHGlobal(pData.Length);
            try
            {
                Marshal.Copy(pData, 0, pAddr, pData.Length);
                JngHightSpeedSecsExport.JS_DataItemAdd(m_pJsData, (Int32)pData.Length, SECS_TYPE._BINARY, pAddr);
            }
            catch
            {
            }
            Marshal.FreeHGlobal(pAddr);
        }

        // 布尔类型
        public void AddBool(bool pData)
        {
            bool[] pTmp = new bool[1];
            pTmp[0] = pData;
            AddBool(pTmp);
        }

        // 布尔类型
        public void AddBool(bool[] pData)
        {
            IntPtr pAddr = Marshal.AllocHGlobal(pData.Length);
            try
            {
                byte[] pTmp = new byte[pData.Length];
                for (int i = 0; i < pData.Length; i++)
                {
                    pTmp[i] = (Byte)(pData[i] ? 1 : 0);
                }
                Marshal.Copy(pTmp, 0, pAddr, pTmp.Length);
                JngHightSpeedSecsExport.JS_DataItemAdd(m_pJsData, (Int32)pData.Length, SECS_TYPE._BOOLEAN, pAddr);
            }
            catch
            {
            }
            Marshal.FreeHGlobal(pAddr);
        }

        // 2字节整形
        public void AddInt(Int16 pData)
        {
            Int16[] pList = new Int16[1];
            pList[0] = pData;

            AddInt(pList);
        }

        public void AddInt(Int16[] pData)
        {
            JngHightSpeedSecsExport.JS_DataItemAddI2(m_pJsData, pData.Length, pData);
        }

      // 4字节整形
        public void AddInt(Int32 pData)
        {
            Int32[] pList = new Int32[1];
            pList[0] = pData;

            AddInt(pList);
        }
          
        public void AddInt(Int32[] pData)
        {
            JngHightSpeedSecsExport.JS_DataItemAddI4(m_pJsData, pData.Length, pData);
        }

        // 1字节无符号整形
        public void AddUInt(byte pData)
        {
            byte[] pList = new byte[1];
            pList[0] = pData;

            AddUInt(pList);
        }

        public void AddUInt(byte[] pData)
        {
            JngHightSpeedSecsExport.JS_DataItemAddU1(m_pJsData, pData.Length, pData);
        }

        // 2字节无符号整形
        public void AddUInt(UInt16 pData)
        {
            UInt16[] pList = new UInt16[1];
            pList[0] = pData;

            AddUInt(pList);
        }

        public void AddUInt(UInt16[] pData)
        {
            JngHightSpeedSecsExport.JS_DataItemAddU2(m_pJsData, pData.Length, pData);
        }
        
        // 4字节无符号整形
        public void AddUInt(UInt32 pData)
        {
            UInt32[] pList = new UInt32[1];
            pList[0] = pData;

            AddUInt(pList);
        }

        public void AddUInt(UInt32[] pData)
        {
            JngHightSpeedSecsExport.JS_DataItemAddU4(m_pJsData, pData.Length, pData);
        }

        // 浮点型
        public void AddFloat(float pData)
        {
            float[] pList = new float[1];
            pList[0] = pData;

            AddFloat(pList);
        }

        public void AddFloat(float[] pData)
        {
            int nSize = pData.Length * 4;
            IntPtr pAddr = Marshal.AllocHGlobal(nSize);
            try
            {
                Marshal.Copy(pData, 0, pAddr, pData.Length);
                JngHightSpeedSecsExport.JS_DataItemAdd(m_pJsData, (Int32)pData.Length, SECS_TYPE._F4, pAddr);
            }
            catch
            {
            }
            Marshal.FreeHGlobal(pAddr);
        }

        // 添加浮点型
        public void AddDouble(double pData)
        {
            double[] pList = new double[1];
            pList[0] = pData;

            AddDouble(pList);
        }

        public void AddDouble(double[] pData)
        {
            int nSize = pData.Length * 8;
            IntPtr pAddr = Marshal.AllocHGlobal(nSize);
            try
            {
                Marshal.Copy(pData, 0, pAddr, pData.Length);
                JngHightSpeedSecsExport.JS_DataItemAdd(m_pJsData, (Int32)pData.Length, SECS_TYPE._F8, pAddr);
            }
            catch
            {
            }
            Marshal.FreeHGlobal(pAddr);
        }

        //
        // 提取数据

        // 移动到数据开始
        public void MoveHead()
        {
            m_nPos = 0;
            m_bDataEnd = false;
        }

        // 数据是否已经读取完
        public bool DataIsEnd()
        {
            return m_bDataEnd;
        }

        // 下一个数据的长度、类型
        Int32 GetNextDataType(ref SECS_TYPE nType, ref Int32 nSize)
        {
            nSize = 0;
            nType = SECS_TYPE._ERR_TYPE;
            IntPtr pData = IntPtr.Zero;
            Int32 nPos = m_nPos;

            return JngHightSpeedSecsExport.JS_DataItemGetNext(m_pJsData, ref nType, ref nSize,
                ref pData, ref nPos);
        }

        // 值
        public Int32 GetNextData(ref SECS_TYPE nType, ref Int32 nSize, ref object pData)
        {
            Int32 nCode = 0;
            nSize = 0;
            nType = SECS_TYPE._ERR_TYPE;

            // 非托管
            IntPtr pBuffer = IntPtr.Zero;
            pData = null;
            try
            {
                // 获取数据
                int nPrePos = m_nPos;
                nCode = JngHightSpeedSecsExport.JS_DataItemGetNext(m_pJsData, ref nType, ref nSize, ref pBuffer, ref m_nPos);
                if (nCode == 0 ||
                    nCode == (int)SECS_MODULE_CODE.CODE_SECS_NO_MORE_DATA)
                {
                    if (nPrePos == m_nPos)
                    {
                        m_bDataEnd = true;
                        nCode = 0;
                    }
                    if (pBuffer != IntPtr.Zero)
                    {
                        pData = GetData(nType, ref nSize, pBuffer);
                    }
                }
            }
            catch (System.Exception)
            {
            }
            return nCode;
        }
       


        //
        // 内部使用接口

        // 内部使用接口
        public object GetData(SECS_TYPE nType, ref Int32 nSize, IntPtr pBuffer)
        {
            object pObject = null;

            switch (nType)
            {
                case SECS_TYPE._LIST: break;

                case SECS_TYPE._ASCII:
                    {
                        char[] pData = new char[nSize];
                        for (int i = 0; i < nSize; i++)
                        {
                            pData[i] = (char)Marshal.ReadByte(pBuffer, i);
                        }
                        pObject = pData;
                    }
                    break;

                case SECS_TYPE._BINARY:
                    {
                        byte[] pData = new byte[nSize];
                        Marshal.Copy(pBuffer, pData, 0, nSize);
                        pObject = pData;
                    }
                    break;

                case SECS_TYPE._BOOLEAN:
                    {
                        bool[] pData = new bool[nSize];
                        for (int i = 0; i < nSize; i++)
                        {
                            pData[i] = (Marshal.ReadByte(pBuffer, i) != 0);
                        }
                        pObject = pData;
                    }
                    break;

                case SECS_TYPE._I1:
                    {
                        Int32[] pData = new Int32[nSize];
                        byte[] pTmpData = new byte[nSize];
                        Marshal.Copy(pBuffer, pTmpData, 0, nSize);
                        for (int i = 0; i < nSize; i++)
                        {
                            UInt32 nTmpUx = (UInt32)pTmpData[i];
                            if ((nTmpUx & 0x80) == 0x80)
                            {
                                nTmpUx |= 0xFFFFFF00;
                            }
                            pData[i] = (Int32)nTmpUx;
                        }

                        pObject = pData;
                    }
                    break;

                case SECS_TYPE._I2:
                    {
                        Int16[] pData = new Int16[nSize];
                        Marshal.Copy(pBuffer, pData, 0, nSize);
                        pObject = pData;
                    }
                    break;

                case SECS_TYPE._I4:
                    {
                        Int32[] pData = new Int32[nSize];
                        Marshal.Copy(pBuffer, pData, 0, nSize);
                        pObject = pData;
                    }
                    break;

                case SECS_TYPE._U1:
                    {
                        byte[] pData = new byte[nSize];
                        Marshal.Copy(pBuffer, pData, 0, nSize);
                        pObject = pData;
                    }
                    break;

                case SECS_TYPE._U2:
                    {
                        UInt16[] pData = new UInt16[nSize];
                        for (int i = 0; i < nSize; i++)
                        {
                            pData[i] = (UInt16)Marshal.ReadInt16(pBuffer, i * 2);
                        }
                        pObject = pData;
                    }
                    break;

                case SECS_TYPE._U4:
                    {
                        UInt32[] pData = new UInt32[nSize];
                        for (int i = 0; i < nSize; i++)
                        {
                            pData[i] = (UInt32)Marshal.ReadInt32(pBuffer, i * 4);
                        }
                        pObject = pData;
                    }
                    break;

                case SECS_TYPE._F4:
                    {
                        float[] pData = new float[nSize];
                        Marshal.Copy(pBuffer, pData, 0, nSize);
                        pObject = pData;
                    }
                    break;

                case SECS_TYPE._F8:
                    {
                        double[] pData = new double[nSize];
                        Marshal.Copy(pBuffer, pData, 0, nSize);
                        pObject = pData;
                    }
                    break;
            }


            return pObject;
        }


        // 内部使用接口
        public JngDataEx(IntPtr pData)
        {
            m_nPos = 0;
            m_pJsData = pData;
        }

        // 获取数据，内部函数
        public IntPtr GetData()
        {
            return m_pJsData;
        }

        // 设置数据，内部函数
        public void SetData(IntPtr pJsData)
        {
            if (m_pJsData != IntPtr.Zero)
            {
                JngHightSpeedSecsExport.JS_DelereDataObject(m_pJsData);
            }
            m_pJsData = pJsData;
        }

        public void AddItem(int nSize, SECS_TYPE nType, object pData)
        {
            //           JngHightSpeedSecsExport.JS_DataItemAdd(m_pJsData, nSize, nType, ref pData);
        }

    }

时代漏网之鱼
关注
  • 11
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java源码 SECS协议，里面包含各种进制转换，用于半导体行业
RDbBCeBW的博客
10-31 210
在半导体行业中，Java源码SECS协议能够被应用于很多领域，例如在半导体工艺生产线上，各种工艺设备需要进行数据的传输与通信；总体来看，Java源码SECS协议在半导体行业的应用十分广泛，它能够有效地保障半导体生产过程中的数据传输和通信需求。在这篇文章中，我们将讨论Java源码SECS协议对于半导体行业的应用及其在数据传输方面所具有的优势。未来，随着半导体技术的不断发展和半导体行业的不断壮大，Java源码SECS协议也将不断得到完善和优化，这将为半导体行业的数据传输和通信提供更加高效、稳定、可靠的保障。
C# SECS 通信实例源代码
08-21
SECS HSMS, socket create by csharp , easy to use or reference resources
c# SECS SECS-II HSMS 源码及资料全集
01-03
c# SECS SECS-II HSMS 源码及资料全集,你想要的都在里面。采用SEMI E37的协议规格编程，来完成和半导体生产设备的通讯
全源码分享：C#上位机SECS协议，包含进制转换，助力半导体行业
最新发布
AIKzHcj的博客
04-01 335
C#源码上位机程序还支持多线程编程，可以同时处理多个设备的通信请求，提高了系统的并发性能。总之，C#源码上位机程序是半导体行业中重要的技术工具，通过SECS协议实现与半导体设备的通信和控制。在半导体行业的应用实践中，C#源码上位机程序为设备控制和数据交换提供了可靠的支持，有效提高了生产效率和产品质量。同时，C#作为一种面向对象的编程语言，具有良好的可维护性和可扩展性，使得程序的开发和维护变得更加高效。SECS协议的应用使得设备之间可以进行可靠、高效的数据交换，为半导体行业的生产过程提供了强大的支持。
HSMS/SECS/GEM Driver设计使用，可用于光伏、半导体、面板等行业应用
热门推荐
semisecs
12-22 16万+
SECS Driver使用目录 1 简介 1 2 使用 1 2.1 导入资料 1 2.2 添加依赖项 3 2.3 添加文件到项目 3 3 使用SECS库 4 3.1 创建SECS对象 4 3.2 设置通讯参数及建立通讯 4 3.3 构建SECS数据 4 3.4 发送SECS数据 5 1 简介 JNG Secs Driver 适用于半导体、光伏、面板、PCB等行业 支持C、C++、C#等编程语言（C#对应C#DLL库） 2 使用 2.1 导入资料 将以下文件添加到项目当中 –> JngHightSpee
SECS/GEM之SECS Driver开发源代码
semisecs
10-07 6127
规格 ： 1 .符合SEMI E5、E30、E37 的 SECS 通讯规范 2. 完善 Log 档案可查询历史通讯记录 3 .支持C、C++、C#、Labview、PLC等 软件特点： 1. 拥有完善的方案 ，软件开发时间可缩短80％ 。 2. 已经集成大量的逻辑和各类的应用场景，稳定运行于几十个工厂 3. 以 DLL 模块提供API接口使用，简单方便 硬件： 1. 低至入门级别CPU ，例如赛扬、奔腾
JngHightSpeedSecs_SECSGEM_SECS_SECS源代码_SECS,GEM源代码_GEM
09-11
SECS/GEM开发的源代码，运行稳定7*24小时，代码风格非常好，简单易懂
HSMS SECS Driver设计使用，可用于光伏、半导体、面板等行业应用，半导体通讯软件
12-27
半导体通讯软件SECS Driver设计使用，可用于光伏、半导体、面板等行业应用
C# winform 基于HSMS通信的SECS协议窗体程序及类库源码
10-13
HSMS通信的SECS协议窗体程序及类库源码；详情请看我的文章展示 ： https://blog.csdn.net/m0_65636467/article/details/133805643 半导体通讯协议SECSII/HSMS程序源码；附连接使用文档，有中文注释等等
secs4j-master_SECS/GEM源码_
10-03
secs/gem java实现。亲测有效
SECS（HSMS）模拟器
11-08
SECS模拟器用于调试SECS类型通讯的设备，用于调试产线控制系统，用于调试EAP等所有涉及到SECS通讯的系统和设备
SecsGem协议使用完整版 -SecsGemDriver（无需授权）
01-10
半导体Secs/Gem通用协议，大公司内部流出版
GEM,SECS1,SECS2,HSMS 协议实现源代码 C++版本
08-26
GEM,SECS1,SECS2,HSMS 协议实现源代码 C++版本
ispSecsToTool.Net SDK
08-02
SecsToTool.Net is a connectivity solution for the semiconductor equipment that support SECS/GEM communication interface. The SecsToTool.Netdriver SDK is designed to provide a high level method call/reply and event driven environment for your host application to communicate with equipment. By using SecsToTool.Net, you can concentrate on developing a solid application rather than sidetracked by the lower level SECS/GEM message protocols and formats which are very tedious. The SDK comes with the .NET-based SecsToTool.Net Library and SecsToTool Model Builder for configuring equipment specific secs/gem interface.
secsgem-master_secs协议实现_SECS_
09-29
secs gem协议的python实现
c# SECS HSMS编程
08-21
关于半导体SEMI SECS SECS-I SECS-II GEM HSMS的一个程序，采用SEMI E37的协议规格编程，来完成和半导体生产设备的通讯
C#源码 上位机 SECS协议，里面包含各种进制转换，用于半导体行业，程序全源码
2201_75293109的博客
11-18 943
C#源码 上位机 SECS协议，里面包含各种进制转换，用于半导体行业，程序全源码。
C# secs gem源码及测试方法
05-20
它主要定义了设备和主机之间的通信协议和消息格式。SECS被广泛应用于半导体制造设备的控制和数据传输。 在C#中，可以使用SECS gem库来实现SECS协议的通信。SECS gem是一个开源库，用于SECS协议的通信实现，它提供了...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值