//public void setChannelHandle(IntPtr channel_handle)
        //{
        //    lock (locker)
        //    {
        //        channel_handle = channel_handle;
        //    }
        //}
        /// <summary>
        /// 接收CAN总线上的数据
        /// </summary>
        private void ReceiveDataFromCAN()
        {
            //ZCAN_Receive_Data[] can_data = new ZCAN_Receive_Data[100];
            ZCAN_ReceiveFD_Data[] canfd_data = new ZCAN_ReceiveFD_Data[100];
            uint len;

            while (m_bStart)
            {
                lock (locker)
                {
                    //len = ZCAN_GetReceiveNum(channel_handle, TYPE_CAN);
                    //if (len > 0)
                    //{
                    //    int size = Marshal.SizeOf(typeof(ZCAN_Receive_Data));
                    //    IntPtr ptr = Marshal.AllocHGlobal((int)len * size);
                    //    len = ZCAN_Receive(channel_handle, ptr, len, 50);
                    //    for (int i = 0; i < len; ++i)
                    //    {
                    //        can_data[i] = (ZCAN_Receive_Data)Marshal.PtrToStructure(
                    //            (IntPtr)((UInt32)ptr + i * size), typeof(ZCAN_Receive_Data));
                    //    }
                    //    OnRecvCANDataEvent(can_data, len);
                    //    Marshal.FreeHGlobal(ptr);
                    //}

                    len = ZCAN_GetReceiveNum(channel_handle, TYPE_CANFD);
                    int    nRecvIndex = 0;
                    byte[] byRecvData = new byte[len * 8];
                    if (len > 0)
                    {
                        int    size = Marshal.SizeOf(typeof(ZCAN_ReceiveFD_Data));
                        IntPtr ptr  = Marshal.AllocHGlobal((int)len * size);
                        len = ZCAN_ReceiveFD(channel_handle, ptr, len, 50);
                        for (int i = 0; i < len; ++i)
                        {
                            canfd_data[i] = (ZCAN_ReceiveFD_Data)Marshal.PtrToStructure(
                                (IntPtr)((UInt32)ptr + i * size), typeof(ZCAN_ReceiveFD_Data));
                            Buffer.BlockCopy(canfd_data[i].frame.data, 0, byRecvData, nRecvIndex, 8);
                            nRecvIndex += 8;
                        }
                        //OnRecvFDDataEvent(canfd_data, len);
                        if (RaiseZLGRecvDataEvent != null)
                        {
                            OnRaiseZLGRecvDataEvent(this, new CANEvent()
                            {
                                eventType = CANEventType.ReceEvent,
                                DataLen   = byRecvData[2],
                                listData  = new List <byte>(byRecvData)
                            });
                            Marshal.FreeHGlobal(ptr);
                        }
                    }
                }

                Thread.Sleep(10);
            }
        }
        //数据接收函数
        protected void RecvDataFunc()
        {
            ZCAN_Receive_Data[]   can_data   = new ZCAN_Receive_Data[100];
            ZCAN_ReceiveFD_Data[] canfd_data = new ZCAN_ReceiveFD_Data[100];
            uint len;

            while (m_bStart)
            {
                lock (locker)
                {
                    len = Method.ZCAN_GetReceiveNum(channel_handle_, TYPE_CAN);
                    if (len > 0)
                    {
                        int    size = Marshal.SizeOf(typeof(ZCAN_Receive_Data));
                        IntPtr ptr  = Marshal.AllocHGlobal((int)len * size);
                        len = Method.ZCAN_Receive(channel_handle_, ptr, len, 50);
                        for (int i = 0; i < len; ++i)
                        {
                            can_data[i] = (ZCAN_Receive_Data)Marshal.PtrToStructure(
                                (IntPtr)((UInt32)ptr + i * size), typeof(ZCAN_Receive_Data));
                        }
                        OnRecvCANDataEvent(can_data, len);
                        Marshal.FreeHGlobal(ptr);
                    }

                    len = Method.ZCAN_GetReceiveNum(channel_handle_, TYPE_CANFD);
                    if (len > 0)
                    {
                        int    size = Marshal.SizeOf(typeof(ZCAN_ReceiveFD_Data));
                        IntPtr ptr  = Marshal.AllocHGlobal((int)len * size);
                        len = Method.ZCAN_ReceiveFD(channel_handle_, ptr, len, 50);
                        for (int i = 0; i < len; ++i)
                        {
                            canfd_data[i] = (ZCAN_ReceiveFD_Data)Marshal.PtrToStructure(
                                (IntPtr)((UInt32)ptr + i * size), typeof(ZCAN_ReceiveFD_Data));
                        }
                        OnRecvFDDataEvent(canfd_data, len);
                        Marshal.FreeHGlobal(ptr);
                    }
                }

                Thread.Sleep(10);
            }
        }
        private void AddData(ZCAN_ReceiveFD_Data[] data, uint len)
        {
            list_box_data_ = "";
            for (uint i = 0; i < len; ++i)
            {
                ZCAN_ReceiveFD_Data canfd = data[i];
                uint   id  = data[i].frame.can_id;
                string eff = IsEFF(id) ? "扩展帧" : "标准帧";
                string rtr = IsRTR(id) ? "远程帧" : "数据帧";
                list_box_data_ = String.Format("接收到CANFD ID:0x{0:X8} {1:G} {2:G} 长度:{3:D1} 数据:", GetId(id), eff, rtr, canfd.frame.len);
                for (uint j = 0; j < canfd.frame.len; ++j)
                {
                    list_box_data_ = String.Format("{0:G}{1:X2} ", list_box_data_, canfd.frame.data[j]);
                }
            }

            Object[] list = { this, System.EventArgs.Empty };
            this.listBox.BeginInvoke(new EventHandler(SetListBox), list);
        }