HighWayAssemble/Highway.Assemble.EquipClient/EquipClient.cs

using Highway.Assemble.common;
using log4net;
using Mesnac.DeviceAdapter;
using Mesnac.DeviceAdapterNet;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Reflection;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Highway.Assemble.EquipClient
{
    public class EquipClient : IEquipClient
    {
        public static readonly ILog LogInfo = LogManager.GetLogger("RollingLogFileAppender");

        public Action<List<DeviceInfo>> EquipStateAction;

        public Action<int, List<TagInfo>> ReadDataAction;

        public Action<int, List<TagInfo>> RecSendDataAction;

        public Action<int, int, int> RecGetDataAction;

        public Action<int, byte[]> RecAutoDataAction;

        public List<Equip> equipList;

        public List<Equip> listGroup;

        public List<Sensor> m_SensorInfoList;

        public List<Sensor> m_AntInfoInfoList;

        public List<DeviceInfo> m_DeviceInfoList;

        private BackgroundWorker m_bgwDeviceDetect = new BackgroundWorker();

        private ManualResetEvent StartDetectEvent = new ManualResetEvent(initialState: false);

        private ManualResetEvent ExitEvent = new ManualResetEvent(initialState: false);

        private ManualResetEvent DetectEvent = new ManualResetEvent(initialState: false);

        public List<CombineData> CombineDataList = new List<CombineData>();

        public static AntInfo[] AntList;

        public CombineData CombineData;

        public bool TagInventory;

        /// <summary>
        /// 初始化设备天线信息
        /// </summary>
        private void InitAnt()
        {
            AntList = new AntInfo[m_SensorInfoList.Count];
            for (int i = 0; i < m_SensorInfoList.Count; i++)
            {
                AntInfo a = new AntInfo();
                a.m_iCombineId = Convert.ToInt32(m_SensorInfoList[i].combineid);
                AntList[i] = a;
            }
        }

        /// <summary>
        /// 初始化创建设备实例
        /// </summary>
        public void Init()
        {
            CombineData = new CombineData();
            DeviceInfo pDeviceInfo = null;
            m_DeviceInfoList = new List<DeviceInfo>();
            if (equipList == null)
            {
                LogInfo.Info("设备信息表为空！");
                return;
            }
            for (int i = 0; i < equipList.Count; i++)
            {
                pDeviceInfo = new DeviceInfo();
                pDeviceInfo.m_iDeviceId = Convert.ToUInt16(equipList[i].deviceId);
                pDeviceInfo.m_iConnectMode = Convert.ToByte(equipList[i].connectmode);
                pDeviceInfo.m_strConnectStr = equipList[i].connectstr;
                pDeviceInfo.m_strDeviceType = equipList[i].deviceType;
                pDeviceInfo.m_IDeviceAdapter = CreateDeviceAdapter(pDeviceInfo);
                if (pDeviceInfo.m_IDeviceAdapter == null)
                {
                    LogInfo.Info("创建编号为" + pDeviceInfo.m_iDeviceId + "的设备实例失败");
                }
                m_DeviceInfoList.Add(pDeviceInfo);
            }
            InitAnt();
        }

        /// <summary>
        /// 创建设备动态链接库
        /// </summary>
        /// <param name="pDeviceInfo"></param>
        /// <returns></returns>
        public IDeviceAdapter CreateDeviceAdapter(DeviceInfo pDeviceInfo)
        {
            IDeviceAdapter IAdapter = null;
            try
            {
                string strDllName = "Mesnac.DeviceAdapter." + pDeviceInfo.m_strDeviceType;
                Assembly assembly = Assembly.Load(strDllName);
                string fullName = strDllName + "." + pDeviceInfo.m_strDeviceType + "Adapter";
                return (IDeviceAdapter)assembly.CreateInstance(fullName);
            }
            catch (Exception ex)
            {
                LogInfo.Info("CreateDeviceAdapter异常:" + ex.ToString());
                return null;
            }
        }

        /// <summary>
        /// 设备数据处理函数
        /// </summary>
        public void CreatEquipClient()
        {
            if (equipList == null)
            {
                LogInfo.Info("设备信息表为空！");
                return;
            }
            m_bgwDeviceDetect.DoWork += bgwDeviceDetect_DoWork;
            m_bgwDeviceDetect.RunWorkerAsync(this);
        }
        /// <summary>
        /// 监听设备数据事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void bgwDeviceDetect_DoWork(object sender, DoWorkEventArgs e)
        {
            BackgroundWorker backgroundworker = sender as BackgroundWorker;
            while (true)
            {
                try
                {
                    if (ExitEvent.WaitOne(0, exitContext: false))
                    {
                        e.Cancel = true;
                        LogInfo.Info("设备检测线程正常退出");
                        ExitEvent.Reset();
                        break;
                    }
                    for (int i = 0; i < m_DeviceInfoList.Count; i++)
                    {
                        DeviceInfo item = m_DeviceInfoList[i];
                        IDeviceAdapter pDeviceAdapter = item.m_IDeviceAdapter;
                        Task t = Task.Run(async delegate
                        {
                            if (pDeviceAdapter == null)
                            {
                                item.m_ConnectState = 0;
                            }
        
                            if (item.m_ConnectState == 0)
                            {
                                if (pDeviceAdapter.Device_Init_Id((CommType)item.m_iConnectMode, item.m_strConnectStr, item.m_iDeviceId))
                                {
                                    if (pDeviceAdapter.Device_Connect())
                                    {
                                        pDeviceAdapter.RecvIdentifyDataEvent -= RecvIdentifyData_Instance;
                                        pDeviceAdapter.RecvIdentifyDataEvent += RecvIdentifyData_Instance;
                                        //pDeviceAdapter.RecvIdentifyData_ToMES_Event -= RecvIdentifyDataToMES_Instance;
                                        //pDeviceAdapter.RecvIdentifyData_ToMES_Event += RecvIdentifyDataToMES_Instance;
                                        switch (pDeviceAdapter.Device_SendHeartPack())
                                        {
                                            case 1:
                                                item.m_ConnectState = 1;
                                                break;
                                            case 2:
                                                item.m_ConnectState = 2;
                                                break;
                                            default:
                                                item.m_ConnectState = 0;
                                                break;
                                        }
                                    }
                                }
                                else
                                {
                                    item.m_ConnectState = 0;
                                }
                            }
                            else if (item.m_ConnectState == 1)
                            {
                                switch (pDeviceAdapter.Device_SendHeartPack())
                                {
                                    case 1:
                                        item.m_ConnectState = 1;
                                        break;
                                    case 2:
                                        item.m_ConnectState = 2;
                                        break;
                                    default:
                                        item.m_ConnectState = 0;
                                        break;
                                }
                            }
                            else if (item.m_ConnectState == 2)
                            {
                                switch (pDeviceAdapter.Device_SendHeartPack())
                                {
                                    case 1:
                                        item.m_ConnectState = 1;
                                        break;
                                    case 2:
                                        item.m_ConnectState = 2;
                                        item.m_IDeviceAdapter.Device_Destroy();
                                        break;
                                    default:
                                        item.m_ConnectState = 0;
                                        item.m_IDeviceAdapter.Device_Destroy();
                                        break;
                                }

                            }
                            EquipStateAction?.Invoke(m_DeviceInfoList);
                            await Task.Delay(100);
                        });
                    }
                    DetectEvent.Reset();
                    DetectEvent.WaitOne(120000, exitContext: false);
                }
                catch (Exception ex)
                {
                    LogInfo.Info("设备检测线程异常：" + ex.Message);
                    DetectEvent.Reset();
                    DetectEvent.WaitOne(30000, exitContext: false);
                }
            }
        }
        /// <summary>
        /// 监听MES主动读取后数据返回事件
        /// </summary>
        /// <param name="iLen"></param>
        /// <param name="pData"></param>
        /// <param name="Antenna"></param>
        /// <param name="iDeviceId"></param>
        /// <param name="strId"></param>
        /// <param name="sensorType"></param>
        private void RecvIdentifyDataToMES_Instance(ushort iLen, byte[] pData, byte Antenna, ushort iDeviceId, string strId, string sensorType)
        {
            uint iCombineId = 0u;
            try
            {
                iCombineId = GetCombineIdByDeviceIdAndSer(Antenna, iDeviceId, sensorType);
                if (iCombineId != 0)
                {
                    if (iLen > 0)
                    {
                        LogInfo.Info("------------------------------------------------------------------------------------------------------");
                        LogInfo.Info("MES主动读取合并编号[" + iCombineId + "]的第[" + Antenna + "]号传感器，自报数据：" + Encoding.ASCII.GetString(pData, 0, pData.Length) + "，原始数据：" + bytesToHexStr(pData, pData.Length));
                        LogInfo.Info("------------------------------------------------------------------------------------------------------");
                        //ReadDataAction?.Invoke(Convert.ToInt32(iCombineId), pData);
                    }
                    else
                    {
                        LogInfo.Info("------------------------------------------------------------------------------------------------------");
                        LogInfo.Info("MES主动读取合并编号[" + iCombineId + "]的第[" + Antenna + "]号传感器自报数据：NoData");
                        LogInfo.Info("------------------------------------------------------------------------------------------------------");
                        ReadDataAction?.Invoke(Convert.ToInt32(iCombineId), null);
                    }
                }
            }
            catch (Exception ex)
            {
                LogInfo.Info("RecvIdentifyDataToMES_Instance:" + ex.ToString());
                ReadDataAction?.Invoke(Convert.ToInt32(iCombineId), null);
            }
        }

        /// <summary>
        /// 根据设备编号获取传感器合并编号
        /// </summary>
        /// <param name="iSensorSer">传感器编号</param>
        /// <param name="iDeviceId">设备编号</param>
        /// <param name="sensorType">传感器类型</param>
        /// <returns></returns>
        private uint GetCombineIdByDeviceIdAndSer(byte iSensorSer, ushort iDeviceId, string sensorType)
        {
            uint iCombineId = 0u;
            for (int i = 0; i < m_SensorInfoList.Count; i++)
            {
                if (iSensorSer == Convert.ToUInt16(m_SensorInfoList[i].sensorser) && iDeviceId == Convert.ToUInt16(m_SensorInfoList[i].deviceId) && sensorType == m_SensorInfoList[i].sensortypeid)
                {
                    iCombineId = Convert.ToUInt32(m_SensorInfoList[i].combineid);
                    break;
                }
            }
            return iCombineId;
        }

        /// <summary>
        /// 监听自动上报后数据返回事件
        /// </summary>
        /// <param name="iLen">数据长度</param>
        /// <param name="pData">数据</param>
        /// <param name="Antenna">天线</param>
        /// <param name="iDeviceId">设备编号</param>
        /// <param name="strId">传感器编号</param>
        /// <param name="sensorType">传感器类型</param>
        public void RecvIdentifyData_Instance(ushort iLen, List<TagInfo> tagInfos, byte Antenna, ushort iDeviceId, string strId, string sensorType)
        {
            uint iCombineId = 0u;
            try
            {
                iCombineId = GetCombineIdByDeviceIdAndSer(Antenna, iDeviceId, sensorType);
                if (iCombineId == 0)
                {
                    return;
                }
                if (iLen > 0)
                {
                    //if (iLen == 1)
                    //{
                    //    LogInfo.Info("------------------------------------------------------------------------------------------------------");
                    //    LogInfo.Info("光电自报合并编号[" + iCombineId + "]的第[" + Antenna + "]号传感器，原始数据：" + bytesToHexStr(pData, pData.Length));
                    //    LogInfo.Info("------------------------------------------------------------------------------------------------------");
                    //    RecAutoDataAction?.Invoke(Convert.ToInt32(iCombineId), pData);
                    //    return;
                    //}
                    LogInfo.Info("------------------------------------------------------------------------------------------------------");
                    //LogInfo.Info("读写器自报合并编号[" + iCombineId + "]的第[" + Antenna + "]号传感器，自报数据：" + Encoding.ASCII.GetString(pData, 0, pData.Length) + "，原始数据：" + bytesToHexStr(pData, pData.Length));
                    LogInfo.Info("------------------------------------------------------------------------------------------------------");
                    AntInfo[] antList = AntList;
                    foreach (AntInfo item in antList)
                    {
                        if (item.m_iCombineId == iCombineId)
                        {
                            item.IsReading = false;
                            item.ReadData = new byte[tagInfos[0].EPC.Length];
                            Array.Copy(tagInfos[0].EPC, 0, item.ReadData, 0, tagInfos[0].EPC.Length);
                            RecSendDataAction?.Invoke(Convert.ToInt32(iCombineId), tagInfos);
                        }
                    }
                }
                else
                {
                    LogInfo.Info("------------------------------------------------------------------------------------------------------");
                    LogInfo.Info("自报合并编号[" + iCombineId + "]的第[" + Antenna + "]号传感器自报数据：NoData");
                    LogInfo.Info("------------------------------------------------------------------------------------------------------");
                    RecSendDataAction?.Invoke(Convert.ToInt32(iCombineId), null);
                }
            }
            catch (Exception ex)
            {
                LogInfo.Info("空间名：" + ex.Source + "；\n方法名：" + ex.TargetSite?.ToString() + "\n故障点：" + ex.StackTrace.Substring(ex.StackTrace.LastIndexOf("\\") + 1, ex.StackTrace.Length - ex.StackTrace.LastIndexOf("\\") - 1) + "\n错误提示：" + ex.Message);
                if (iLen == 0)
                {
                    RecAutoDataAction?.Invoke(Convert.ToInt32(iCombineId), null);
                }
            }
        }

        public static string bytesToHexStr(byte[] bytes, int iLen)
        {
            StringBuilder sb = new StringBuilder();
            if (bytes != null)
            {
                for (int i = 0; i < iLen; i++)
                {
                    sb.Append(bytes[i].ToString("X2"));
                }
            }
            return sb.ToString();
        }

        /// <summary>
        /// 主动读取设备数据函数
        /// </summary>
        /// <param name="num">传感器合并编号</param>
        /// <param name="filterMembank">过滤区</param>
        /// <param name="filterWordPtr">过滤偏移量</param>
        /// <param name="filterWordCnt">过滤数据长度</param>
        /// <param name="filterData">过滤数据</param>
        /// <param name="Membank">数据区</param>
        /// <param name="WordPtr">数据地址偏移量</param>
        /// <param name="WordCnt">数据长度</param>
        public void ReadData(int num, byte filterMembank, ushort filterWordPtr, ushort filterWordCnt, byte[] filterData, byte Membank, ushort WordPtr, ushort WordCnt)
        {
            ushort iReadLen = 0;
            byte[] pReadData = null;
            DeviceInfo pDeviceInfo = null;
            Sensor pSensorInfo = null;
            try
            {
                LogInfo.Info("接收到MES主动读取数据命令，合并编号：" + num);
                pDeviceInfo = GetIDeviceInfoByCombineId(Convert.ToUInt32(num));
                pSensorInfo = GetSensorInfoByCombineId(Convert.ToUInt32(num));
                if (pDeviceInfo.m_IDeviceAdapter != null)
                {
                    if (pDeviceInfo.m_IDeviceAdapter.Device_Read((G2MemBank)filterMembank, filterWordPtr, filterWordCnt, filterData, (G2MemBank)Membank, WordPtr, WordCnt, ref pReadData, Convert.ToByte(pSensorInfo.sensorser), pSensorInfo.ReadCounts) != 0)
                    {
                        LogInfo.Info("------------------------------------------------------------------------------------------------------");
                        LogInfo.Info("MES主动读取数据成功，合并编号：[" + num + "]，读取标签数据：" + Encoding.ASCII.GetString(pReadData, 0, pReadData.Length) + ",原始数据：" + bytesToHexStr(pReadData, pReadData.Length));
                        LogInfo.Info("------------------------------------------------------------------------------------------------------");
                        //ReadDataAction?.Invoke(num, pReadData);
                    }
                    else
                    {
                        LogInfo.Info("------------------------------------------------------------------------------------------------------");
                        LogInfo.Info("MES主动读取数据成功，合并编号：[" + num + "]，读取数据:NoData");
                        LogInfo.Info("------------------------------------------------------------------------------------------------------");
                        ReadDataAction?.Invoke(num, null);
                    }
                }
                else
                {
                    LogInfo.Info("MES主动读取失败，合并编号：" + num);
                    ReadDataAction?.Invoke(num, null);
                }
            }
            catch (Exception ex)
            {
                LogInfo.Info("MES主动读取异常:" + ex.ToString());
                ReadDataAction?.Invoke(num, null);
            }
        }

        /// <summary>
        /// 根据设备编号返回设备信息
        /// </summary>
        /// <param name="iDeviceId">设备编号</param>
        /// <returns>设备信息</returns>
        private DeviceInfo GetDeviceInfoByDeviceId(ushort iDeviceId)
        {
            DeviceInfo pDeviceInfo = null;
            for (int i = 0; i < m_DeviceInfoList.Count; i++)
            {
                if (iDeviceId == m_DeviceInfoList[i].m_iDeviceId)
                {
                    return m_DeviceInfoList[i];
                }
            }
            return pDeviceInfo;
        }
        /// <summary>
        /// 根据传感器合并编号获取设备信息
        /// </summary>
        /// <param name="iCombineId">传感器编号</param>
        /// <returns>设备信息</returns>
        private DeviceInfo GetIDeviceInfoByCombineId(uint iCombineId)
        {
            DeviceInfo pDeviceInfo = null;
            for (int i = 0; i < m_SensorInfoList.Count; i++)
            {
                if (iCombineId == Convert.ToUInt32(m_SensorInfoList[i].combineid))
                {
                    pDeviceInfo = GetDeviceInfoByDeviceId(Convert.ToUInt16(m_SensorInfoList[i].deviceId));
                    if (pDeviceInfo != null)
                    {
                        break;
                    }
                }
            }
            return pDeviceInfo;
        }
        /// <summary>
        /// 根据传感器编号返回传感器信息
        /// </summary>
        /// <param name="iCombineId">传感器编号</param>
        /// <returns>传感器信息</returns>
        private Sensor GetSensorInfoByCombineId(uint iCombineId)
        {
            Sensor pSensorInfo = null;
            for (int i = 0; i < m_SensorInfoList.Count; i++)
            {
                if (iCombineId == Convert.ToUInt32(m_SensorInfoList[i].combineid))
                {
                    pSensorInfo = m_SensorInfoList[i];
                    break;
                }
            }
            return pSensorInfo;
        }

        /// <summary>
        /// 写入数据
        /// </summary>
        /// <param name="num">传感器合并编号</param>
        /// <param name="filterMembank">过滤区</param>
        /// <param name="filterWordPtr">过滤偏移量</param>
        /// <param name="filterWordCnt">过滤数据长度</param>
        /// <param name="filterData">过滤数据</param>
        /// <param name="Membank">数据区</param>
        /// <param name="WordPtr">数据地址偏移量</param>
        /// <param name="WordCnt">数据长度</param>
        /// <param name="pWriteData">写入数据</param>
        /// <param name="Antenna">天线号</param>
        public void WriteData(int num, byte filterMembank, ushort filterWordPtr, ushort filterWordCnt, byte[] filterData, byte Membank, ushort WordPtr, ushort WordCnt, byte[] pWriteData, byte Antenna)
        {
            int iState = 0;
            ushort iWriteLen = 0;
            DeviceInfo pDeviceInfo = null;
            Sensor pSensorInfo = null;
            switch (Membank)
            {
                case 1:
                    if (pWriteData[0] == byte.MaxValue)
                    {
                        iState = 3;
                        LogInfo.Info("方法：WriteData，接收合并编号[" + num + "]的第[" + Antenna + "]路IO，打开报警灯命令");
                    }
                    else
                    {
                        iState = 4;
                        LogInfo.Info("方法：WriteData，接收合并编号[" + num + "]的第[" + Antenna + "]路IO，关闭报警灯命令");
                    }
                    break;
                case 2:
                    iState = 5;
                    LogInfo.Info("方法：WriteData，接收合并编号[" + num + "]的第[" + Antenna + "]路IO，持续打开报警灯后关闭命令");
                    break;
                case 3:
                    iState = 6;
                    LogInfo.Info("方法：WriteData，接收合并编号[" + num + "]的第[" + Antenna + "]路IO，打开报警灯闪亮命令");
                    break;
            }
            pDeviceInfo = GetIDeviceInfoByCombineId(Convert.ToUInt32(num));
            pSensorInfo = GetSensorInfoByCombineId(Convert.ToUInt32(num));
            try
            {
                if (pDeviceInfo.m_IDeviceAdapter != null)
                {
                    iWriteLen = pDeviceInfo.m_IDeviceAdapter.Device_Write((G2MemBank)filterMembank, filterWordPtr, filterWordCnt, filterData, (G2MemBank)Membank, WordPtr, WordCnt, pWriteData, Convert.ToByte(pSensorInfo.sensorser));
                    RecGetDataAction?.Invoke(num, 1, iState);
                    Thread.Sleep(50);
                }
                else
                {
                    LogInfo.Info("写入失败，合并编号：" + num);
                    RecGetDataAction?.Invoke(num, 0, iState);
                }
            }
            catch (Exception ex)
            {
                LogInfo.Info("写入异常:" + ex.ToString());
            }
        }

        /// <summary>
        /// 主动读取EPC发送给客户端
        /// </summary>
        /// <param name="id">传感器合并编号</param>
        public async Task ReadEPC(int id)
        {
            await Task.Run(delegate
            {
                byte[] array = null;
                try
                {
                    LogInfo.Info("合并编号：" + id + ",识别单次标签命令自报");
                    //array = GetOneEpcByCombineId(Convert.ToUInt32(id));
                    if (array != null)
                    {
                        LogInfo.Info("-------------------------------------------------------------------------------------------------------------");
                        LogInfo.Info("识别单次标签成功，合并编号[" + id + "]，读取标签数据：" + Encoding.ASCII.GetString(array, 0, array.Length) + "，原始数据：" + bytesToHexStr(array, array.Length));
                        LogInfo.Info("-------------------------------------------------------------------------------------------------------------");
                        //ReadDataAction?.Invoke(id, array);
                    }
                    else
                    {
                        LogInfo.Info("------------------------------------------------------------------------------------------------------");
                        LogInfo.Info("识别单次标签成功，合并编号[" + id + "]，读取标签数据：NoData");
                        LogInfo.Info("------------------------------------------------------------------------------------------------------");
                        ReadDataAction?.Invoke(id, null);
                    }
                }
                catch (Exception ex)
                {
                    LogInfo.Info("Deal_IdentifyOneEpc异常:" + ex.ToString());
                    ReadDataAction?.Invoke(id, null);
                }
            });
        }


        public void ReadRFID(int id,out List<TagInfo> rfiddata)
        {
            List<TagInfo> tags = new List<TagInfo>();
            byte[] array = null;
            rfiddata = null;
            try
            {
                LogInfo.Info("合并编号：" + id + ",识别单次标签命令自报");
                tags = GetOneEpcByCombineId(Convert.ToUInt32(id));
                if (tags != null)
                {
                    //LogInfo.Info("-------------------------------------------------------------------------------------------------------------");
                    //LogInfo.Info("识别单次标签成功，合并编号[" + id + "]，读取标签数据：" + Encoding.ASCII.GetString(array, 0, array.Length) + "，原始数据：" + bytesToHexStr(array, array.Length));
                    //LogInfo.Info("-------------------------------------------------------------------------------------------------------------");
                    //rfiddata = Encoding.ASCII.GetString(array, 0, array.Length);
                    rfiddata = tags;
                    ReadDataAction?.Invoke(id, tags);

                }
                else
                {
                    LogInfo.Info("------------------------------------------------------------------------------------------------------");
                    LogInfo.Info("识别单次标签成功，合并编号[" + id + "]，读取标签数据：NoData");
                    LogInfo.Info("------------------------------------------------------------------------------------------------------");
                    ReadDataAction?.Invoke(id, null);
                }
            }
            catch (Exception ex)
            {
                LogInfo.Info("Deal_IdentifyOneEpc异常:" + ex.ToString());
                ReadDataAction?.Invoke(id, null);
            }
        }


        /// <summary>
        /// 根据合并编号主动读取EPC返回原始数据
        /// </summary>
        /// <param name="iCombineId">传感器编号</param>
        /// <returns>原始数据</returns>
        private List<TagInfo> GetOneEpcByCombineId(uint iCombineId)
        {
            List<TagInfo> tagInfos = null;
            byte[] pReturnResult = null;
            IDeviceAdapter pDeviceAdapter = null;
            byte iEpcLen = 0;
            for (int i = 0; i < m_SensorInfoList.Count; i++)
            {
                if (iCombineId != Convert.ToUInt32(m_SensorInfoList[i].combineid))
                {
                    continue;
                }
                pDeviceAdapter = GetDeviceAdapterByDeviceId(Convert.ToUInt16(m_SensorInfoList[i].deviceId));
                if (pDeviceAdapter != null)
                {
                    tagInfos = pDeviceAdapter.Device_GetAllIdentifyData(Convert.ToByte(m_SensorInfoList[i].sensorser), Convert.ToUInt16(m_SensorInfoList[i].DelayTime), 1);
                    if (tagInfos.Count > 0)
                    {
                        return tagInfos;
                    }
                    return null;
                }
            }
            return tagInfos;
        }

        /// <summary>
        /// 根据设备编号返回设备动态类
        /// </summary>
        /// <param name="iDeviceId"></param>
        /// <returns>设备动态类</returns>
        private IDeviceAdapter GetDeviceAdapterByDeviceId(ushort iDeviceId)
        {
            IDeviceAdapter pDeviceAdapter = null;
            for (int i = 0; i < m_DeviceInfoList.Count; i++)
            {
                if (iDeviceId == m_DeviceInfoList[i].m_iDeviceId)
                {
                    return m_DeviceInfoList[i].m_IDeviceAdapter;
                }
            }
            return pDeviceAdapter;
        }

        public void RecAutoData(Action<int, byte[]> action)
        {
            RecAutoDataAction = action;
        }

        public void RecEquipState(Action<List<DeviceInfo>> action)
        {
            EquipStateAction = action;
        }

        public void RecGetData(Action<int, int, int> action)
        {
            RecGetDataAction = action;
        }

        public void RecSendData(Action<int, List<TagInfo>> action)
        {
            RecSendDataAction = action;
        }

        public void RetReadData(Action<int, List<TagInfo>> action)
        {
            ReadDataAction = action;
        }

        public void SensorInfo(List<Sensor> sensorList)
        {
            m_SensorInfoList = sensorList;
        }

        public void EquipInfo(List<Equip> equipList)
        {
            this.equipList = equipList;
        }
        /// <summary>
        /// 根据传感器合并编号处理数据
        /// </summary>
        /// <param name="num">传感器合并编号</param>
        private void Deal_Data(int num)
        {
            AntInfo[] antList = AntList;
            foreach (AntInfo item in antList)
            {
                item.ReadData = null;
                if (item.m_iCombineId != num)
                {
                    continue;
                }
                while (item.IsReading)
                {
                    if (item.ReadData != null)
                    {
                        Array.Clear(item.ReadData, 0, item.ReadData.Length);
                        item.ReadData = null;
                        item.IsReading = false;
                        item.readType = 0;
                    }
                    else
                    {
                        Thread.Sleep(10);
                    }
                }
            }
        }

        /// <summary>
        /// 开始连续盘点
        /// </summary>
        /// <param name="num">传感器合并编号</param>
        public void Device_BeginIdentify(int num)
        {
            bool bResult = false;
            DeviceInfo pDeviceInfo = null;
            Sensor pSensorInfo = null;
            pDeviceInfo = GetIDeviceInfoByCombineId(Convert.ToUInt32(num));
            pSensorInfo = GetSensorInfoByCombineId(Convert.ToUInt32(num));
            AntInfo[] antList = AntList;
            foreach (AntInfo item in antList)
            {
                if (item.m_iCombineId == num)
                {
                    if (item.IsReading)
                    {
                        return;
                    }
                    item.IsReading = true;
                    item.readType = 1;
                }
            }
            LogInfo.Info("合并编号：" + num + ",发送连续读取标签命令自报");
            try
            {
                if (pDeviceInfo.m_IDeviceAdapter != null)
                {
                    bResult = pDeviceInfo.m_IDeviceAdapter.Device_BeginIdentify(Convert.ToByte(pSensorInfo.sensorser), Convert.ToInt32(pSensorInfo.timeout), AutoRead: true, num);
                    if (!bResult)
                    {
                        bResult = pDeviceInfo.m_IDeviceAdapter.Device_BeginIdentify(Convert.ToByte(pSensorInfo.sensorser), Convert.ToInt32(pSensorInfo.timeout), AutoRead: true, num);
                        if (!bResult)
                        {
                            bResult = pDeviceInfo.m_IDeviceAdapter.Device_BeginIdentify(Convert.ToByte(pSensorInfo.sensorser), Convert.ToInt32(pSensorInfo.timeout), AutoRead: true, num);
                        }
                    }
                    Thread.Sleep(1);
                    AntInfo[] antList2 = AntList;
                    foreach (AntInfo item2 in antList2)
                    {
                        if (item2.m_iCombineId == num && !Task.Factory.StartNew(delegate
                        {
                            Deal_Data(item2.m_iCombineId);
                        }).Wait(Convert.ToInt32(pSensorInfo.timeout)))
                        {
                            item2.IsReading = false;
                            item2.readType = 0;
                            DealNoData(num, v: true);
                            item2.ReadData = null;
                        }
                    }
                    if (bResult)
                    {
                        LogInfo.Info("发送连续读取指令成功，合并编号：" + num);
                    }
                    else
                    {
                        LogInfo.Info("发送连续读取指令失败，合并编号：" + num);
                    }
                }
                else
                {
                    LogInfo.Info("发送连续读取指令失败，合并编号：" + num);
                }
            }
            catch (Exception ex)
            {
                LogInfo.Info("发送连续读取指令异常:" + ex.ToString());
            }
        }
        /// <summary>
        /// 连续盘点超时处理
        /// </summary>
        /// <param name="num">传感合并编号</param>
        /// <param name="v">触发方式</param>
        private void DealNoData(int num, bool v)
        {
            if (v)
            {
                LogInfo.Info("》》》触发读取时间超时，返回Nodata，合并编号：" + num);
                RecSendDataAction?.Invoke(Convert.ToInt32(num), null);
            }
            else
            {
                LogInfo.Info("》》》MES主动读取时间超时，返回Nodata，合并编号：" + num);
                ReadDataAction?.Invoke(Convert.ToInt32(num), null);
            }
            Device_StopIdentify(num);
            if (!Device_StopIdentify(num))
            {
                Device_StopIdentify(num);
            }
            if (!Device_StopIdentify(num))
            {
                Device_StopIdentify(num);
            }
        }
        /// <summary>
        /// 停止连续盘点
        /// </summary>
        /// <param name="num">传感器合并编号</param>
        /// <returns></returns>
        public bool Device_StopIdentify(int num)
        {
            bool bResult = false;
            DeviceInfo pDeviceInfo = null;
            Sensor pSensorInfo = null;
            pDeviceInfo = GetIDeviceInfoByCombineId(Convert.ToUInt32(num));
            pSensorInfo = GetSensorInfoByCombineId(Convert.ToUInt32(num));
            LogInfo.Info("合并编号：" + num + ",发送停止连续读取标签命令自报");
            try
            {
                if (pDeviceInfo.m_IDeviceAdapter != null)
                {
                    if (pDeviceInfo.m_IDeviceAdapter.Device_StopIdentify(Convert.ToByte(pSensorInfo.sensorser)))
                    {
                        LogInfo.Info("发送停止连续读取指令成功，合并编号：" + num);
                        return true;
                    }
                    LogInfo.Info("发送停止连续读取指令失败，合并编号：" + num);
                    return false;
                }
                LogInfo.Info("发送停止连续读取指令失败，合并编号：" + num);
                return false;
            }
            catch (Exception ex)
            {
                LogInfo.Info("发送停止连续读取指令异常:" + ex.ToString());
                return false;
            }
        }
        /// <summary>
        /// 客户端连续盘点
        /// </summary>
        /// <param name="num">传感器合并编号</param>
        /// <returns></returns>
        public async Task Device_MESBeginIdentify(int num)
        {
            await Task.Run(delegate
            {
                bool flag = false;
                DeviceInfo deviceInfo = null;
                Sensor sensor = null;
                deviceInfo = GetIDeviceInfoByCombineId(Convert.ToUInt32(num));
                sensor = GetSensorInfoByCombineId(Convert.ToUInt32(num));
                LogInfo.Info("合并编号：" + num + ",MES主动发送连续读取标签命令");
                AntInfo[] antList = AntList;
                foreach (AntInfo antInfo in antList)
                {
                    if (antInfo.m_iCombineId == num)
                    {
                        if (antInfo.IsReading)
                        {
                            LogInfo.Info("合并编号：" + num + ",当前正在读取，请等待上一次读取返回！");
                            return;
                        }
                        antInfo.IsReading = true;
                        antInfo.readType = 2;
                    }
                }
                try
                {
                    if (deviceInfo.m_IDeviceAdapter != null)
                    {
                        flag = deviceInfo.m_IDeviceAdapter.Device_BeginIdentify(Convert.ToByte(sensor.sensorser), Convert.ToInt32(sensor.timeout), AutoRead: false, num);
                        AntInfo[] antList2 = AntList;
                        foreach (AntInfo item in antList2)
                        {
                            if (item.m_iCombineId == num && !Task.Factory.StartNew(delegate
                            {
                                Deal_Data(item.m_iCombineId);
                            }).Wait(Convert.ToInt32(sensor.timeout)))
                            {
                                item.IsReading = false;
                                DealNoData(num, v: false);
                                item.ReadData = null;
                            }
                        }
                    }
                    else
                    {
                        LogInfo.Info("MES主动发送连续读取指令失败，合并编号：" + num);
                    }
                }
                catch (Exception ex)
                {
                    LogInfo.Info("MES主动发送连续读取指令异常:" + ex.ToString());
                }
            });
        }
        /// <summary>
        /// 读取单条EPC
        /// </summary>
        /// <param name="id">传感器合并编号</param>
        /// <returns></returns>
        public string ReadEPCData(int id)
        {
            byte[] pEpc = null;
            string m_data = "";
            try
            {
                LogInfo.Info("合并编号：" + id + ",识别单次标签命令");
                //pEpc = GetOneEpcByCombineId(Convert.ToUInt32(id));
                if (pEpc != null)
                {
                    LogInfo.Info("-------------------------------------------------------------------------------------------------------------");
                    LogInfo.Info("识别单次标签成功，合并编号[" + id + "]，读取标签数据：" + Encoding.ASCII.GetString(pEpc, 0, pEpc.Length) + "，原始数据：" + bytesToHexStr(pEpc, pEpc.Length));
                    LogInfo.Info("-------------------------------------------------------------------------------------------------------------");
                    m_data = Encoding.ASCII.GetString(pEpc, 0, pEpc.Length);
                    //ReadDataAction?.Invoke(id, pEpc);
                }
                else
                {
                    LogInfo.Info("------------------------------------------------------------------------------------------------------");
                    LogInfo.Info("识别单次标签成功，合并编号[" + id + "]，读取标签数据：NoData");
                    LogInfo.Info("------------------------------------------------------------------------------------------------------");
                    ReadDataAction?.Invoke(id, null);
                }
            }
            catch (Exception ex)
            {
                LogInfo.Info("Deal_IdentifyOneEpc异常:" + ex.ToString());
                ReadDataAction?.Invoke(id, null);
            }
            return m_data;
        }

        public void WriteAlarmLight(int num,string code)
        {
            bool flag = false;
            try
            {
                DeviceInfo deviceInfo = null;
                //Sensor sensor = null;
                deviceInfo = GetIDeviceInfoByCombineId(Convert.ToUInt32(num));
                //sensor = GetSensorInfoByCombineId(Convert.ToUInt32(num));
                if (deviceInfo.m_IDeviceAdapter != null)
                {
                    flag = deviceInfo.m_IDeviceAdapter.Device_WriteAlarmLight(int.Parse(code), 10000);

                    //Thread.Sleep(3000);
                    //flag = deviceInfo.m_IDeviceAdapter.Device_WriteAlarmLight(2,2000);
                    //Thread.Sleep(3000);
                    //flag = deviceInfo.m_IDeviceAdapter.Device_WriteAlarmLight(3,2000);
                }
            }
            catch (Exception ex)
            {

            }
        }
    }

}