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

金南瓜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
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值