using ControllerClient.Bean;
using ControllerClient.cmdinfo;
using ControllerClient.datainfo;

using ICCardHelper;
using Newtonsoft.Json.Linq;
using PCSC.Monitoring;
using Pg.Rfid;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Drawing;
using System.IO;
using System.Media;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Windows.Forms;
using Newtonsoft.Json;
using HandheldHelper;
using System.Net;
using Newtonsoft.Json.Serialization;
using ControllerClient.Tools;
using Ini.Net;
using System.Text.RegularExpressions;
using System.IO.Ports;
using System.Collections.Specialized;
//using Ini.Net;
using CMBFingerPrint.Enums;
using CMBFingerPrint;
using System.Drawing.Imaging;
using System.Linq;

namespace ControllerClient
{
    public partial class Form1 : Form
    {
        string cmdFilePath = "cmdfile";
        string comName = "COM1";
        FileSystemWatcher fileSystemWatcher;
        SoundPlayer sound = null;

        public delegate void mFileChangeEventHandler(String cmdfilename);
        mFileChangeEventHandler fileChangeEventHandler;
        bool mjflag = false;
        //待办标识
        bool toDealFlag = false;
        PCSCReader readerPCSC = null;
        PCSCReader readerIC = null;
        private static IniFile ini;
        socketClient socketClientMJ = null;

        Reader readerMJ = null;
        //入库
        EnterScanData esd = null;
        List<enterScanPackInfo> epcReal = null;
        EnterScanCMD esc = null;
        //扫描
        SuperScanData ssd = null;
        List<superScanPackinfo> ssdList = null;
        //出库
        OutScanData osd = null;
        List<transferData> epcOut = null;
        OutScanCMD osc = null;
        //实物交接
        TransferTransferData ttd = null;
        List<transferPackInfo> epcHandover = null;
        //电子签封入库核对
        CheckInData cidd = null;
        List<packInfoCheck> packInfoCheckList = null;
        //空电子签封入库
        EmptyPackCheckInData epcid = null;
        List<emptyPackInfo> emptyPackInfoList = null;
        BaseCommand bc = null;

        FtpHelper ftp = null;
        delegate void ChangeInvoke(string num);
        //public delegate void AutoCommit();
        //public event AutoCommit PDACommitEvent;
        //数据交换
        public delegate void APDUHandler(string APDUData);
        public delegate void HardwareInitializeHandler(string data);
        //电源管理8001
        public delegate void PowerManagerHandler(string data);
        //错误反馈1002
        public delegate void ErrorFeedbackHandler(string data);

        //检查环境1004
        public delegate void CheckEnvironmentHandler(string data);
        //接入1005
        public delegate void JoinUpHandler(string data);
        //下发2002
        public delegate void DownCommondHandler(string data);
        //命令2001
        public delegate void CommondHandler(string data);
        //执行2003
        public delegate void ExecuteHandler(string data);
        //确认2004
        public delegate void ConfirmHandler(string data);
        //元数据同步2005
        public delegate void UserDataSyncHandler(string data);
        //授权进出安全区域4003
        public delegate void AuthorizedAccessHandler(byte[] data);

        //static TXTHelper ltMJSequence = new TXTHelper("MJSequence");
        static TXTHelper ltUserInfo = new TXTHelper("UserInfo");
        static TXTHelper ltTaskCmd = new TXTHelper("TaskCmd");
        static TXTHelper ltTaskData = new TXTHelper("TaskData");
        static TXTHelper ltMetamark = new TXTHelper("Metamark");
        //static TXTHelper ltPKC = new TXTHelper("TaskCmdInfo.json", 1);
        //static TXTHelper ltScreen = new TXTHelper("1");
        //static TXTHelper ltScreenInfo = new TXTHelper("2");
        //static TXTHelper ltTaskInfo = new TXTHelper("3");
        static TXTHelper ltRFID = new TXTHelper("rfid.ini", 1);
        TXTHelper ltScreen = null;
        TXTHelper ltScreenInfo = null;
        TXTHelper ltTaskInfo = null;

        SerialPortComImplement spc = null;

        string greenOff = "0105000100009C0A ";
        string greenOn = "01050001FF00DDFA ";
        //on  0105000200006C0A
        string yellowOff = "01050002FF002DFA";
        //off 01050002FF002DFA
        string yellowOn = "0105000200006C0A";
        string redOff = "010500000000CDCA";
        string redOn = "01050000FF008C3A";
        //四号口
        string gateOn = "01050003FF007C3A";
        string gateOff = "0105000300003DCA";

        static string operatorUser = "";
        static string auditorUser = "";
        string PSAMReaderName = "";
        string ICReaderName = "";
        string userGate = "";
        string userInfo = "";
        string userLogin = "";
        int userGateCount = 0;
        string mustSackNo = "";
        string stackCode = "";
        string stackName = "";
        //日志保留天数
        int logDays = 15;
        string controlId = "1001";
        string sequence = "";
        string dataToPDAFinal = "";
        //收到2002任务开启门架标识
        bool flagMJ = false;
        bool heartStatu = false;
        //栅栏门已开启标识，未开启则出入库业务不提交
        bool flagUser = false;
        //用户已登陆标识，未登陆则不启动门架
        bool flagLoginUser = false;
        //刷卡开启栅栏门标识
        bool flagGate = false;
        //用户刷完三张卡标识
        bool flagCard = false;
        //收到2005后提示用户登陆标识
        bool flagPrompt = false;
        bool flagEncry = false;
        bool debugButton = false;
        //人脸有效标识
        bool flagFace = false;
        //包号过滤
        string packFilter = "";
        //默认用户是否自动登陆
        bool loginUser = false;
        //用户刷卡解除经警报
        bool flagAlarm = false;
        //判断是否是必出箱
        bool mustOutSack = false;
        HashSet<string> epcList = new HashSet<string>();
        //锁状态异常
        HashSet<string> errorList = new HashSet<string>();
        //不在任务列表
        HashSet<string> notTaskList = new HashSet<string>();
        List<string> userList = new List<string>();
        //实际已扫描款包
        string epcDataResult = "";
        string ServerIP = "";
        int port = 50003;
        string gateComName = "";
        //是否启用人脸设备
        bool faceUseing = false;
        //是否启用栅栏门加密
        bool gateEncrypt = false;
        //用户刷卡卡号
        string cardAll = "";
        string fingerBind = "";
        NameValueCollection myCol = new NameValueCollection();
        private Int32 m_lUserID = -1;
        private Int32[] m_lAlarmHandle = new Int32[200];

        private int iDeviceNumber = 0; //添加设备个数
        private int iFileNumber = 0; //保存的文件个数
        private uint iLastErr = 0;
        private string strErr;
        int gateTime = 0;
        HashSet<string> cardHash = new HashSet<string>();
        HashSet<string> cardUserHash = new HashSet<string>();
        HashSet<string> cardLoginHash = new HashSet<string>();
        public CHCNetSDK.LOGINRESULTCALLBACK LoginCallBack = null;
        private CHCNetSDK.EXCEPYIONCALLBACK m_fExceptionCB = null;
        private CHCNetSDK.MSGCallBack_V31 m_falarmData_V31 = null;
        public delegate void UpdateTextStatusCallback(string strLogStatus, IntPtr lpDeviceInfo);
        public delegate void UpdateListBoxCallback(string strAlarmTime, string strDevIP, string strAlarmMsg);
        public delegate void UpdateListBoxCallbackException(string strAlarmTime, int lUserID, string strAlarmMsg);
        CHCNetSDK.NET_VCA_TRAVERSE_PLANE m_struTraversePlane = new CHCNetSDK.NET_VCA_TRAVERSE_PLANE();
        CHCNetSDK.NET_VCA_AREA m_struVcaArea = new CHCNetSDK.NET_VCA_AREA();
        CHCNetSDK.NET_VCA_INTRUSION m_struIntrusion = new CHCNetSDK.NET_VCA_INTRUSION();
        CHCNetSDK.UNION_STATFRAME m_struStatFrame = new CHCNetSDK.UNION_STATFRAME();
        CHCNetSDK.UNION_STATTIME m_struStatTime = new CHCNetSDK.UNION_STATTIME();
        [DllImport("kernel32.dll")]
        public static extern bool Beep(int frequency, int duration);
        private static CMBDeviceManager cmbDeviceManager = CMBDeviceManager.Instance;
        static private ushort totalTemplateCapacity = 0;
        static private bool saveImageWhenEnroll = false;
        HashSet<string> fingerList = new HashSet<string>();
        string[] fingerArr;
        string fingerAll = "";
        CMBDeviceErrorCode error;
        bool fingerUseing = false;
        string logicVersion = "1.2.0";
        bool socketSatau = false;
        string ipAll = "";
        int readerTime = 0;
        public Form1()
        {
            InitializeComponent();
            CMBDeviceErrorCode code = CMBDeviceErrorCode.CMBDEV_ERR_SUCCESS;
            CheckForIllegalCrossThreadCalls = false;
            try
            {
                cmdFilePath = ConfigurationManager.AppSettings["FtpServerRoot"].ToString();
                comName = ConfigurationManager.AppSettings["ComName"].ToString();
                ServerIP = ConfigHelper.GetAppConfig("ServerIP");
                port = int.Parse(ConfigHelper.GetAppConfig("Port"));
                controlId = ConfigHelper.GetAppConfig("ControlId");
                heartStatu = bool.Parse(ConfigHelper.GetAppConfig("HeartStatu"));
                logDays = int.Parse(ConfigHelper.GetAppConfig("LogDays"));
                PSAMReaderName = ConfigHelper.GetAppConfig("PSAMReaderName");
                ICReaderName = ConfigHelper.GetAppConfig("ICReaderName");
               
                ipAll = ConfigHelper.GetAppConfig("MjIP");
                userGateCount = int.Parse(ConfigHelper.GetAppConfig("UserGateCount"));
                //stackCode = ConfigHelper.GetAppConfig("StackCode");
                //stackName = ConfigHelper.GetAppConfig("StackName");
                faceUseing = bool.Parse(ConfigHelper.GetAppConfig("FaceUseing"));
                gateEncrypt = bool.Parse(ConfigHelper.GetAppConfig("GateEncrypt"));
                loginUser = bool.Parse(ConfigHelper.GetAppConfig("LoginUser"));
                gateComName = ConfigHelper.GetAppConfig("GateComName");
                ltScreen = new TXTHelper(cmdFilePath, "1.txt");
                ltScreenInfo = new TXTHelper(cmdFilePath, "2.txt");
                ltTaskInfo = new TXTHelper(cmdFilePath, "3.txt");
                gateTime = int.Parse(ConfigHelper.GetAppConfig("GateTime"));
                packFilter = ConfigHelper.GetAppConfig("PackFilter");
                debugButton = bool.Parse(ConfigHelper.GetAppConfig("DebugButton"));
                fingerBind = ConfigHelper.GetAppConfig("FingerBind");
                fingerUseing = bool.Parse(ConfigHelper.GetAppConfig("FingerUseing"));
                LogHelper.Debug("配置文件加载成功:ServerIP=" + ServerIP + "port" + port + " ComName=" + comName + "版本号" + logicVersion);
               
                LogHelper.Debug("配置文件加载成功:FtpServerRoot=" + cmdFilePath + " 日志保留时间" + logDays + "栅栏门中断时间" + gateTime);
                LogHelper.Debug("配置文件加载成功:IC读卡器名称=" + ICReaderName + " PSAM读卡器名称" + PSAMReaderName + "包装袋过滤" + packFilter);
                LogHelper.Debug("配置文件加载成功:栅栏门刷卡开启人数=" + userGateCount + "用户免刷卡登陆" + loginUser + " 操作员和复核员" + auditorUser + ":" + operatorUser);
                LogHelper.Debug("配置文件加载成功:人脸设备是否启用" + faceUseing + "栅栏门加密串口" + gateComName + "栅栏门加密是否启用" + gateEncrypt + "指纹设备是否启用" + fingerUseing);
                if (!debugButton)
                {
                    this.button6.Visible = false;
                    this.button7.Visible = false;
                }
                //用户免刷卡登陆
                if (loginUser)
                {
                    flagLoginUser = true;
                }
                //启动指纹
                if (fingerUseing)
                {
                    fingerArr = fingerBind.Split(';');
                    code = cmbDeviceManager.OpenDevice(CMBFpDevType.DEVICE_AFM288, CMBFpDevConnType.FPDEV_CONN_USB, "COM4", Baudrate.BR_115200);
                    if (code == CMBDeviceErrorCode.CMBDEV_ERR_SUCCESS)
                    {


                        LogHelper.Debug("指纹设备打开成功");
                        cmbDeviceManager.GetTemplateCapacity(out totalTemplateCapacity);

                        error = CMBDeviceErrorCode.CMBDEV_ERR_SUCCESS;

                        //cmbDeviceManager.CloseDevice();
                    }
                    else
                    {
                        LogHelper.Debug("指纹设备打开失败");
                    }
                }
                if (faceUseing == true)
                {
                    string deviceIp = ConfigHelper.GetAppConfig("DeviceIp");
                    string devicePort = ConfigHelper.GetAppConfig("DevicePort");
                    string deviceUserName = ConfigHelper.GetAppConfig("DeviceUserName");
                    string devicePassword = ConfigHelper.GetAppConfig("DevicePassword");
                    LogHelper.Debug("deviceIp=" + deviceIp + "devicePort" + devicePort + "deviceUserName" + deviceUserName + "devicePassword" + devicePassword);
                    bool m_bInitSDK = CHCNetSDK.NET_DVR_Init();
                    if (m_bInitSDK == false)
                    {
                        MessageBox.Show("NET_DVR_Init error!");
                        return;
                    }
                    else
                    {
                        byte[] strIP = new byte[16 * 16];
                        uint dwValidNum = 0;
                        Boolean bEnableBind = false;



                        //保存SDK日志 To save the SDK log
                        CHCNetSDK.NET_DVR_SetLogToFile(3, "C:\\SdkLog\\", true);

                        //设置透传报警信息类型
                        CHCNetSDK.NET_DVR_LOCAL_GENERAL_CFG struLocalCfg = new CHCNetSDK.NET_DVR_LOCAL_GENERAL_CFG();
                        struLocalCfg.byAlarmJsonPictureSeparate = 1;//控制JSON透传报警数据和图片是否分离，0-不分离(COMM_VCA_ALARM返回)，1-分离（分离后走COMM_ISAPI_ALARM回调返回）

                        Int32 nSize = Marshal.SizeOf(struLocalCfg);
                        IntPtr ptrLocalCfg = Marshal.AllocHGlobal(nSize);
                        Marshal.StructureToPtr(struLocalCfg, ptrLocalCfg, false);

                        if (!CHCNetSDK.NET_DVR_SetSDKLocalCfg(17, ptrLocalCfg))  //NET_DVR_LOCAL_CFG_TYPE_GENERAL
                        {
                            iLastErr = CHCNetSDK.NET_DVR_GetLastError();
                            strErr = "NET_DVR_SetSDKLocalCfg failed, error code= " + iLastErr;
                            MessageBox.Show(strErr);
                        }
                        Marshal.FreeHGlobal(ptrLocalCfg);

                        for (int i = 0; i < 200; i++)
                        {
                            m_lAlarmHandle[i] = -1;
                        }

                        //设置异常消息回调函数
                        if (m_fExceptionCB == null)
                        {
                            m_fExceptionCB = new CHCNetSDK.EXCEPYIONCALLBACK(cbExceptionCB);
                        }
                        CHCNetSDK.NET_DVR_SetExceptionCallBack_V30(0, IntPtr.Zero, m_fExceptionCB, IntPtr.Zero);


                        //设置报警回调函数
                        if (m_falarmData_V31 == null)
                        {
                            m_falarmData_V31 = new CHCNetSDK.MSGCallBack_V31(MsgCallback_V31);
                        }
                        CHCNetSDK.NET_DVR_SetDVRMessageCallBack_V31(m_falarmData_V31, IntPtr.Zero);
                    }
                    //string[] deviceIpArr = deviceIp.Split(':');
                    //foreach (string deviceIps in deviceIpArr)
                    //{
                    //    if (deviceIps.Length > 5)
                    //    {

                    //    }
                    //}
                    CHCNetSDK.NET_DVR_USER_LOGIN_INFO struLogInfo = new CHCNetSDK.NET_DVR_USER_LOGIN_INFO();

                    byte[] byIP = System.Text.Encoding.Default.GetBytes(deviceIp);
                    struLogInfo.sDeviceAddress = new byte[129];
                    byIP.CopyTo(struLogInfo.sDeviceAddress, 0);
                    //设备用户名
                    byte[] byUserName = System.Text.Encoding.Default.GetBytes(deviceUserName);
                    struLogInfo.sUserName = new byte[64];
                    byUserName.CopyTo(struLogInfo.sUserName, 0);

                    //设备密码
                    byte[] byPassword = System.Text.Encoding.Default.GetBytes(devicePassword);
                    struLogInfo.sPassword = new byte[64];
                    byPassword.CopyTo(struLogInfo.sPassword, 0);

                    struLogInfo.wPort = ushort.Parse(devicePort);//设备服务端口号

                    struLogInfo.cbLoginResult = LoginCallBack;
                    struLogInfo.bUseAsynLogin = false; //是否异步登录：0- 否，1- 是 

                    if ((struLogInfo.bUseAsynLogin == true) && (LoginCallBack == null))
                    {
                        LoginCallBack = new CHCNetSDK.LOGINRESULTCALLBACK(cbLoginCallBack);//注册回调函数                    
                    }
                    struLogInfo.byLoginMode = 0; //0-Private, 1-ISAPI, 2-自适应
                    struLogInfo.byHttps = 0; //0-不适用tls，1-使用tls 2-自适应
                    CHCNetSDK.NET_DVR_DEVICEINFO_V40 DeviceInfo = new CHCNetSDK.NET_DVR_DEVICEINFO_V40();

                    //登录设备 Login the device
                    m_lUserID = CHCNetSDK.NET_DVR_Login_V40(ref struLogInfo, ref DeviceInfo);
                    if (m_lUserID < 0)
                    {
                        iLastErr = CHCNetSDK.NET_DVR_GetLastError();
                        strErr = "NET_DVR_Login_V30 failed, error code= " + iLastErr; //登录失败，输出错误号 Failed to login and output the error code
                        LogHelper.Debug(strErr);
                    }
                    else
                    {
                        //登录成功
                        iDeviceNumber++;
                        string str1 = "" + m_lUserID;
                        LogHelper.Debug("str1" + str1);
                        //设备布防
                        CHCNetSDK.NET_DVR_SETUPALARM_PARAM struAlarmParam = new CHCNetSDK.NET_DVR_SETUPALARM_PARAM();
                        struAlarmParam.dwSize = (uint)Marshal.SizeOf(struAlarmParam);
                        struAlarmParam.byLevel = 1; //0- 一级布防,1- 二级布防
                        struAlarmParam.byAlarmInfoType = 1;//智能交通设备有效，新报警信息类型
                        struAlarmParam.byDeployType = 1; //0客户端布防，1实时布防
                        struAlarmParam.byFaceAlarmDetection = 1;//1-人脸侦测


                        m_lAlarmHandle[m_lUserID] = CHCNetSDK.NET_DVR_SetupAlarmChan_V41(m_lUserID, ref struAlarmParam);
                    }
                }
            }
            catch (Exception e)
            {
                LogHelper.Debug("配置文件加载失败!" + e);
                this.Close();
            }
            try
            {
                ClearCMDFile();
                TXTHelper.deleteTxt(logDays);
                LogHelper.Debug("清除任务文件!");
                //加载蜂鸣声音
                sound = new SoundPlayer(AppDomain.CurrentDomain.BaseDirectory + "9779.wav");
                //ftp = new FtpHelper("127.0.0.1", "kcrx", "kcrx8888");
                //门架
                socketClientMJ = new socketClient(IPAddress.Parse(ServerIP), port, "2");


               
                //Form1.ini = new IniFile("rfid.ini");
                //string[] array = Form1.ini.ReadString("reader", "ip").Split(',');
                //List<int> powerList = new List<int>();

                //foreach (string arr in array)
                //{
                //    string text = arr;
                //    power1 = Form1.ini.ReadInteger(text, "power1");
                //    power2 = Form1.ini.ReadInteger(text, "power2");
                //    Console.WriteLine("power1" + power1 + "power2" + power2);
                //    powerList.Add(power1);
                //    powerList.Add(power2);
                //}

            }
            catch (Exception e)
            {
                LogHelper.Debug("删除日志及连接ftp失败!" + e);
                this.Close();
            }




        }

        private void Form1_Load(object sender, EventArgs e)
        {
            try
            {
                LogHelper.InitLogConfig("log4netConfig.xml");
                LogHelper.Debug("程序启动成功!");


                //    //启动文件检查
                if (!Directory.Exists(cmdFilePath))
                {
                    try
                    {
                        Directory.CreateDirectory(cmdFilePath);
                        LogHelper.Debug("命令文件目录不存在，新建目录:" + cmdFilePath);
                    }
                    catch (Exception ex)
                    {
                        LogHelper.Debug("命令文件目录不存在，新建目录:失败", ex);
                    }
                }
                FileServer.FileChangEvent += new FileServer.FileChangeEventHandler(this.FileServer_FileChangEvent);
                FileServer.StartListener(cmdFilePath);
                readerIC = new PCSCReader(ICReaderName);
                //监听IC卡插入插出事件
                readerIC.startMonitor();
                PCSCReader.CardInsertEvent += PCSCReader_ICCardInsertEvent;
                PCSCReader.CardRemoveEvent += PCSCReader_ICCardRemoveEvent;
                if (gateEncrypt)
                {
                    //启动栅栏门串口
                    spc = new SerialPortComImplement(gateComName, 115200, 8);
                    flagEncry = spc.Open();

                    LogHelper.Debug("加密栅栏门串口状态" + flagEncry);
                }

                readerPCSC = new PCSCReader(PSAMReaderName);
                readerPCSC.startMonitor();
                bool glag = readerPCSC.upPower();
              

                if (glag == false)
                {


                    ltScreenInfo.WriteMessage("程序启动失败!检测PSAM失败，请重启电脑");
                    //ShowInfo(informTb, "程序启动失败!检测PSAM失败，请重启电脑");

                }
                else
                {
                    ltScreenInfo.WriteMessage("程序启动成功，但未接入通讯组件!版本号"+ logicVersion);
                    //ShowInfo(informTb, "程序启动成功，但未接入通讯组件!版本号" + logicVersion);
                }
                //Thread.Sleep(readerTime);
                //加载门架
               // readerMJ = new Reader();

            }
            catch (Exception ex)
            {
                LogHelper.Debug("load加载报错" + ex);
            }
            try
            {


                socketClient.HardwareInitializeEvent += new socketClient.HardwareInitializeHandler(this.HardwareInitialize);
                socketClient.APDUHandlerEvent += new socketClient.APDUHandler(this.DataExchange);
                socketClient.DownCommondEvent += new socketClient.DownCommondHandler(this.DownCommond);
                socketClient.CheckEnvironmentEvent += new socketClient.CheckEnvironmentHandler(this.CheckEnvironment);
                socketClient.JoinUpEvent += new socketClient.JoinUpHandler(this.JoinUp);
                socketClient.ErrorFeedbackEvent += new socketClient.ErrorFeedbackHandler(this.ErrorFeedback);
                socketClient.PowerManagerEvent += new socketClient.PowerManagerHandler(this.PowerManager);
                socketClient.ConfirmEvent += new socketClient.ConfirmHandler(this.DataConfirm);
                socketClient.ExecuteEvent += new socketClient.ExecuteHandler(this.DataExecute);
                socketClient.UserDataSyncEvent += new socketClient.UserDataSyncHandler(this.UserDataSync);
                socketClient.AuthorizedAccessEvent += new socketClient.AuthorizedAccessHandler(this.AuthorizedAccess);
               
                socketSatau=socketClientMJ.conn();
                comCom(yellowOn);
                comCom(greenOff);
                comCom(redOff);
            }
            catch (Exception ex)
            {
                LogHelper.Debug("事件委托出错" + ex);
            }

        }

        public void FileServer_FileChangEvent(String cmdfilename)
        {
            try
            {
                if (cmdfilename.EndsWith(".txt"))//如果是命令文件
                {
                    LogHelper.Debug("发现任务文件:" + cmdfilename, this.GetType());

                    if (cmdfilename.EndsWith("1.txt"))//这是进度数据文件
                    {
                        fileChangeEventHandler = new mFileChangeEventHandler(this.scheduleShow);
                        this.BeginInvoke(fileChangeEventHandler, cmdfilename);
                    }
                    if (cmdfilename.EndsWith("2.txt"))//这是信息提示文件
                    {
                        fileChangeEventHandler = new mFileChangeEventHandler(this.informShow);
                        this.BeginInvoke(fileChangeEventHandler, cmdfilename);
                    }
                    if (cmdfilename.EndsWith("3.txt"))//这是任务显示命令
                    {
                        fileChangeEventHandler = new mFileChangeEventHandler(this.taskShow);
                        this.BeginInvoke(fileChangeEventHandler, cmdfilename);
                    }

                    //if (cmdfilename.EndsWith("5.txt"))//这是面向识别数据
                    //{
                    //    fileChangeEventHandler = new mFileChangeEventHandler(this.ifaceShow);
                    //    this.BeginInvoke(fileChangeEventHandler, cmdfilename);
                    //}
                }
            }
            catch (Exception e)
            {
                LogHelper.Debug("file" + e);
            }


        }
        #region  这是进度数据文件处理
        public void scheduleShow(String cmdfilename)
        {

            LogHelper.Debug("start***************************************************");
            try
            {
                Schedule nowSchedule = ScheduleTools.getSchedule(cmdfilename);
                if (nowSchedule == null)//空文件
                {
                    LogHelper.Debug("任务结束消息,清空进度与明细显示");
                    this.CommadLb.Text = "0";
                    this.isScanLb.Text = "0";
                    this.notScanLB.Text = "0";
                    this.ScanEpc.Text = "0";
                    this.dataGridView1.Rows.Clear();
                    return;
                }

                this.CommadLb.Text = nowSchedule.Cmdnum.ToString();
                this.isScanLb.Text = nowSchedule.IsScannum.ToString();
                this.notScanLB.Text = nowSchedule.NotScannum.ToString();
                this.ScanEpc.Text = nowSchedule.ScanEpc.ToString();
                string[] epcs = nowSchedule.EpcList;
                if (epcs == null)
                {
                    LogHelper.Debug("不存在明细数据,无需更新列表");
                    LogHelper.Debug("任务处理完成:" + cmdfilename, this.GetType());
                    this.dataGridView1.Rows.Clear();
                    File.Delete(cmdfilename);
                    return;
                }
                else
                {
                    for (int i = 0; i < epcs.Length; i++)
                    {
                        TagEpcData ted = EpcReader.readEpc(StringAndBytesHelper.strToToHexByte(epcs[i]));
                        string mess = ted.Lockstuts ==false ? "开锁" : "关锁";
                        string mess1 = "";
                        if (ted.LockeEx)
                        {
                            mess1 = "异常";
                        }
                        else
                        {
                            mess1 = "正常";
                        }
                       
                        string messAll = mess + ":" + mess1;
                        
                        //if (ted.LockeEx|| !ted.Lockstuts)
                        //{
                        //    sound.Play();
                        //}
                        if (this.dataGridView1.Rows.Count == 1)//如果只有一行
                        {
                           
                            this.dataGridView1.Rows.Add(ted.Tagid.ToString().PadLeft(10, '0'), messAll, PervalueHelper.getPervalue(ted.Pervalueid));
                        }
                        else
                        {
                            if (chekRepeat(ted.Tagid.ToString().PadLeft(10, '0')))
                            {
                                this.dataGridView1.Rows.Add(ted.Tagid.ToString().PadLeft(10, '0'), messAll, PervalueHelper.getPervalue(ted.Pervalueid));
                            }
                        }
                        if (ted.Lockstuts&& !ted.LockeEx)
                        {
                            this.dataGridView1.Rows[this.dataGridView1.RowCount - 2].DefaultCellStyle.BackColor = Color.GreenYellow;
                        }
                        else
                        {
                            this.dataGridView1.Rows[this.dataGridView1.RowCount - 2].DefaultCellStyle.BackColor = Color.Red;
                        }


                        this.dataGridView1.FirstDisplayedScrollingRowIndex = this.dataGridView1.RowCount - 2;
                    }

                    LogHelper.Debug("任务处理完成:" + cmdfilename, this.GetType());
                    File.Delete(cmdfilename);
                }
                //scheduleTimer.Start();


                LogHelper.Debug("end*****************************************************");
            }
            catch (Exception ex)
            {
                LogHelper.Debug("屏幕显示" + ex);
                LogHelper.Debug("任务处理失败:" + cmdfilename, this.GetType());
            }


        }
        private bool chekRepeat(string sackNo)
        {
            for (int i = 0; i < this.dataGridView1.Rows.Count - 1; i++)
            {
                if (this.dataGridView1.Rows[i].Cells[0].Value.Equals(sackNo))
                {
                    return false;
                }
            }
            return true;
        }
        //自动编号
        private void dataGridView1_RowPostPaint_1(object sender, DataGridViewRowPostPaintEventArgs e)
        {
            try
            {
                //自动编号，与数据无关
                Rectangle rectangle = new Rectangle(e.RowBounds.Location.X,
                   e.RowBounds.Location.Y,
                   dataGridView1.RowHeadersWidth - 4,
                   e.RowBounds.Height);
                TextRenderer.DrawText(e.Graphics,
                      (e.RowIndex + 1).ToString(),
                       dataGridView1.RowHeadersDefaultCellStyle.Font,
                       rectangle,
                       dataGridView1.RowHeadersDefaultCellStyle.ForeColor,
                       TextFormatFlags.VerticalCenter | TextFormatFlags.Right);
            }
            catch (Exception ex)
            {
                LogHelper.Debug("ex" + ex);
            }
        }

        int stime = 0;
        private void scheduleTimer_Tick(object sender, EventArgs e)
        {
            try
            {
                //System.Drawing.SystemColors.Control
                if (this.tableLayoutPanel2.BackColor != Color.GreenYellow)
                {
                    this.tableLayoutPanel2.BackColor = Color.GreenYellow;
                }
                else
                {
                    this.tableLayoutPanel2.BackColor = System.Drawing.SystemColors.Control;
                }
                stime++;
                // Console.Out.WriteLine("闪烁第" + stime+"次");
                if (stime > 11)
                {
                    scheduleTimer.Stop();
                    stime = 0;
                }
            }
            catch (Exception ex)
            {
                LogHelper.Debug("scheduleTimer_Tick" + ex);
            }

        }
        public void taskShow(string cmdfilename)
        {
            try
            {
                TxtReader tr = new TxtReader(cmdfilename);
                string[] cmdstrs = tr.readUTF8();

                this.informLb.Text = "";//清空原有提示
                foreach (string s in cmdstrs)
                {
                    LogHelper.Debug("收到信息提示信息:" + s);


                    if (s.Split(':').Length > 0)
                    {
                        mess = s;
                        this.informLb.Text += s + "\r\n";

                    }

                }
                File.Delete(cmdfilename);
            }
            catch (Exception e)
            {
                LogHelper.Debug("收到信息提示信息错误", e);
            }

        }
        #endregion
        #region  这是信息提示文件处理infoLines
        int infoLines = 0;
        string mess = "";
        public void informShow(string cmdfilename)
        {
            LogHelper.Debug("start***************************************************");
            try
            {
                TxtReader tr = new TxtReader(cmdfilename);
                string[] cmdstrs = tr.readUTF8();

                this.informTb.Text = "";//清空原有提示
                if (cmdstrs != null)
                {
                    foreach (string s in cmdstrs)
                    {
                        LogHelper.Debug("收到信息提示信息:" + s);


                        if (s.Split(':').Length > 0)
                        {
                            mess = s;
                            this.informTb.Text += s + "\r\n";

                        }
                        else
                        {
                            this.informTb.Text += s + "\r\n";
                        }


                    }
                    infoLines = cmdstrs.Length;
                    informTimer.Start();
                    LogHelper.Debug("任务处理完成" + cmdfilename, this.GetType());
                    File.Delete(cmdfilename);
                }
               
            }
            catch (Exception e)
            {
                LogHelper.Debug("收到信息提示信息错误", e);

                // LogHelper.Debug("任务处理完成" + cmdfilename, this.GetType());
            }

            LogHelper.Debug("end*****************************************************");
        }
        int informStime = 0;

        private void informTimer_Tick(object sender, EventArgs e)
        {
            try
            {
                if (this.informTb.BackColor != Color.Red)
                {
                    this.informTb.BackColor = Color.Red;
                }
                else
                {
                    this.informTb.BackColor = Color.Blue;
                }
                informStime++;
                //this.informTb.Focus();//获取焦点
                //this.informTb.Select(selectLine, 0);//光标定位到文本最后
                //this.informTb.ScrollToCaret();//滚动到光标处

                //    selectLine++;


                if (informStime > 21)
                {
                    informTimer.Stop();
                    informStime = 0;
                }
            }
            catch (Exception ex)
            {
                LogHelper.Debug("informTimer_Tick" + ex);
            }

        }
        #endregion
        #region 面向识别身份信息处理
        //public void ifaceShow(string cmdfilename)
        //{
        //    LogHelper.Debug("start***************************************************");
        //    try
        //    {
        //        LogHelper.Debug("收到面向识别身份信息，开始解析");
        //        TxtReader tr = new TxtReader(cmdfilename);
        //        string[] cmdstrs = tr.readUTF8();
        //        JObject JObject = JObject.Parse(cmdstrs[0]);
        //        string faceImageJson = JObject["regImage"].ToString();
        //        byte[] arr2 = Convert.FromBase64String(faceImageJson);

        //        using (MemoryStream ms2 = new MemoryStream(arr2))
        //        {
        //            System.Drawing.Bitmap bmp2 = new System.Drawing.Bitmap(ms2);
        //            this.ifacePb.Image = bmp2;
        //        }
        //        LogHelper.Debug("收到面向识别身份信息，解析完成");
        //        Thread.Sleep(1000);

        //        LogHelper.Debug("任务处理完成" + cmdfilename, this.GetType());
        //    }
        //    catch (Exception e)
        //    {
        //        LogHelper.Debug("收到面向识别身份信息处理失败" + e);
        //    }
        //    LogHelper.Debug("end*****************************************************");
        //}
        #endregion
        #region 串口控制命令处理
        private void comCom(string cmdfilename)
        {
            LogHelper.Debug("start***************************************************");
            try
            {
                //TxtReader tr = new TxtReader(cmdfilename);
                //string[] cmdstrs = tr.readUTF8();
                string comStr = cmdfilename;
                this.serialPort1.PortName = comName;
                this.serialPort1.Open();
                byte[] ComBytes = StringAndBytesHelper.strToToHexByte(comStr);
                LogHelper.Debug("打开串口" + comName + "成功");
                this.serialPort1.Write(ComBytes, 0, ComBytes.Length);
                LogHelper.Debug("发送控制命令" + comStr + "成功");
                this.serialPort1.Close();
                LogHelper.Debug("关闭串口" + comName + "成功");


                LogHelper.Debug("任务处理完成" + cmdfilename, this.GetType());
                File.Delete(cmdfilename);
                LogHelper.Debug("删除串口命令文件完成:" + cmdfilename, this.GetType());
            }
            catch (Exception e)
            {
                LogHelper.Debug("发送串口控制命令失败", e);
            }
            LogHelper.Debug("end*****************************************************");
        }
        public void gateCom(string cmdfilename)
        {
            LogHelper.Debug("start***************************************************");
            try
            {
                //TxtReader tr = new TxtReader(cmdfilename);
                //string[] cmdstrs = tr.readUTF8();
                string comStr = cmdfilename;
                this.serialPort2.PortName = comName;
                this.serialPort2.Open();
                byte[] ComBytes = StringAndBytesHelper.strToToHexByte(comStr);
                LogHelper.Debug("打开串口" + comName + "成功");
                this.serialPort2.Write(ComBytes, 0, ComBytes.Length);
                LogHelper.Debug("发送控制命令" + comStr + "成功");
                this.serialPort2.Close();
                LogHelper.Debug("关闭串口" + comName + "成功");


                LogHelper.Debug("任务处理完成" + cmdfilename, this.GetType());
                File.Delete(cmdfilename);
                LogHelper.Debug("删除串口命令文件完成:" + cmdfilename, this.GetType());
            }
            catch (Exception e)
            {
                LogHelper.Debug("发送串口控制命令失败", e);
            }
            LogHelper.Debug("end*****************************************************");
        }
        #endregion
      
        private void label1_DoubleClick(object sender, EventArgs e)
        {
            //if (debugButton)
            //{
                Application.Exit();
            //}
            
        }
        private void ClearCMDFile()
        {

            try
            {
                String[] cmdfiles = Directory.GetFiles(cmdFilePath);
                if (cmdfiles.Length > 0)
                {
                    for (int i = 0; i < cmdfiles.Length; i++)
                    {
                        // Debug.WriteLine(cmdfiles[i]);
                        if (cmdfiles[i].EndsWith(".txt"))
                        {
                            File.Delete(cmdfiles[i]);
                        }
                    }
                }

            }
            catch (Exception e1)
            {
                Console.WriteLine(e1.StackTrace);
            }
        }


        //开栅栏门
        private void AuthorizedAccess(byte[] data)
        {
            try
            {

                if (HexUtils.byteToHexStr(data).Equals("00000000"))
                {
                    LogHelper.Debug("开启栅栏门");

                    ltScreenInfo.WriteMessage("验证通过，开启栅栏门");
                   
                    //人脸设备不启动，刷完卡则直接开启栅栏门
                    if (!faceUseing&&!fingerUseing)
                    {
                        if (gateEncrypt)
                        {
                            spc.readEpc();
                        }
                        else
                        {
                            comCom(gateOn);
                            Thread.Sleep(gateTime);
                            comCom(gateOff);
                        }
                       
                    }
                    //如果指纹设备，则比对指纹后开启栅栏门
                    if (fingerUseing)
                    {
                        LogHelper.Debug("指定刷卡指纹数据为" + fingerAll);
                        ltScreenInfo.WriteMessage("刷卡验证通过，请录入您的指纹");
                        TestIdentifyWithFinger();
                    }

                    bool turnOnFlag = true;
                    string[] ipArr = ipAll.Split(':');
                    for (int i = 0; i < ipArr.Length; i++)
                    {
                        string ip = ipArr[i];
                        List<String> list = readerMJ.mjEpcData(ip);
                        LogHelper.Debug("门架缓存"+list.Count);
                        Thread.Sleep(1500);
                        bool flag = readerMJ.mjTurnOn(ip);
                        if (!flag)
                        {
                            turnOnFlag = false;
                        }
                        LogHelper.Debug("门架" + ip + "启动状态" + flag);
                    }
                    flagUser = true;
                    flagFace = true;
                    if (turnOnFlag)
                    {
                        ltScreenInfo.WriteMessage("门架启动成功");
                    }
                    
                }
                else
                {
                    string error = Encoding.UTF8.GetString(data);
                    LogHelper.Debug("授权开启栅栏门失败" + error);
                    ltScreenInfo.WriteMessage("授权开启栅栏门失败" + error);
                }
            }
            catch (Exception e)
            {
                LogHelper.Debug("授权开启栅栏门失败" + e);
            }

        }
        private static void ProgressCB(object user, int percent)
        {
            CMBDeviceManager mng = (CMBDeviceManager)user;
            ClearCurrentConsoleLine();
            Console.Write("Progress " + percent + "% percent on " + mng.ToString());
        }
        public static void ClearCurrentConsoleLine()
        {
            int currentLineCursor = Console.CursorTop;
            Console.SetCursorPosition(0, Console.CursorTop);
            for (int i = 0; i < Console.WindowWidth; i++)
                Console.Write(" ");
            Console.SetCursorPosition(0, currentLineCursor);
        }
        private static void SaveAsBitmap(string fileName, int width, int height, byte[] imageData)
        {
            ByteToGrayBitmap(imageData, width, height).Save(Path.ChangeExtension(fileName, ".bmp"));
        }
        public static Bitmap ByteToGrayBitmap(byte[] rawBytes, int width, int height)
        {
            Bitmap bitmap = new Bitmap(width, height, PixelFormat.Format8bppIndexed);
            BitmapData bmpData = bitmap.LockBits(new Rectangle(0, 0, width, height),
                 ImageLockMode.WriteOnly, PixelFormat.Format8bppIndexed);

            int offset = bmpData.Stride - bmpData.Width;
            IntPtr ptr = bmpData.Scan0;
            int scanBytes = bmpData.Stride * bmpData.Height;
            byte[] grayValues = new byte[scanBytes];

            int posSrc = 0, posScan = 0;
            for (int i = 0; i < height; i++)
            {
                for (int j = 0; j < width; j++)
                {
                    grayValues[posScan++] = rawBytes[posSrc++];
                }
                posScan += offset;
            }

            Marshal.Copy(grayValues, 0, ptr, scanBytes);
            bitmap.UnlockBits(bmpData);

            ColorPalette palette;
            using (Bitmap bmp = new Bitmap(1, 1, PixelFormat.Format8bppIndexed))
            {
                palette = bmp.Palette;
            }
            for (int i = 0; i < 256; i++)
            {
                palette.Entries[i] = Color.FromArgb(i, i, i);
            }
            bitmap.Palette = palette;

            return bitmap;
        }
        public void TestIdentifyWithFinger()
        {

            try
            {
                bool fingeFlag = true;

                while (fingeFlag)
                {

                    Application.DoEvents();
                    // LogHelper.Debug("比对通过次数" + fingerList.Count);
                    if (fingerList.Count == 3)
                    {
                        //ltScreenInfo.WriteMessage("指纹比对通过，开启栅栏门");
                        ShowInfo(informTb, "指纹比对通过，开启栅栏门");
                        if (gateEncrypt)
                        {
                            spc.readEpc();
                        }
                        else
                        {
                            comCom(gateOn);
                            Thread.Sleep(gateTime);
                            comCom(gateOff);
                        }
                        fingerList.Clear();
                        break;
                    }
                    ushort EnrolledTotal = 0;
                    error = cmbDeviceManager.GetEnrolledCount(out EnrolledTotal);
                    if (error != CMBDeviceErrorCode.CMBDEV_ERR_SUCCESS)
                    {
                        LogHelper.Debug($"GetEnrolledCount failed because of {error}");
                        //return;
                    }

                    if (EnrolledTotal == 0)
                    {
                        LogHelper.Debug("All templates are empty");
                        ///return;
                    }

                    // turn LED on before capture image
                    error = cmbDeviceManager.SLEDControl(1);
                    if (error != CMBDeviceErrorCode.CMBDEV_ERR_SUCCESS)
                    {
                        LogHelper.Debug($"SLEDControl failed because of {error}");
                        // return;
                    }

                    uint status = 0;
                    // ltScreenInfo.WriteMessage("请按上您的手指");
                    //do
                    //{
                    error = cmbDeviceManager.DetectFinger(out status);

                    if (error != CMBDeviceErrorCode.CMBDEV_ERR_SUCCESS)
                    {
                        LogHelper.Debug($"DetectFinger failed because of {error}");
                        //return;
                    }
                    //if (status == 0)
                    //{
                    //    Thread.Sleep(40);
                    //    continue;
                    //}
                    // } while (status == 0);
                    if (status != 0)
                    {
                        error = cmbDeviceManager.GetImage();
                        if (error != CMBDeviceErrorCode.CMBDEV_ERR_SUCCESS)
                        {
                            LogHelper.Debug($"GetImage failed because of {error}");
                            //return;
                        }

                        // turn LED off after capture image
                        error = cmbDeviceManager.SLEDControl(0);
                        if (error != CMBDeviceErrorCode.CMBDEV_ERR_SUCCESS)
                        {
                            LogHelper.Debug($"SLEDControl failed because of {error}");
                            //return;
                        }

                        // need to save image when get image
                        if (saveImageWhenEnroll)
                        {
                            byte[] image = null;
                            int width = 0, height = 0;

                            error = cmbDeviceManager.UpImage(out image, out width, out height, CMBDevImageType.CMBDEV_IMG_TYPE_FULL, ProgressCB, cmbDeviceManager);
                            if (error == CMBDeviceErrorCode.CMBDEV_ERR_SUCCESS)
                            {
                                string bmpName = DateTime.Now.ToString("yyyyMMddHHmmss") + "-Identify" + ".bmp";
                                LogHelper.Debug($"\nDownload Finished, Save Image as {bmpName}.");
                                SaveAsBitmap(bmpName, width, height, image);
                            }
                            else
                            {
                                LogHelper.Debug($"UpImage failed because of {error}");
                                //return;
                            }
                        }


                        error = cmbDeviceManager.GenerateTemplate(0);
                        if (error != CMBDeviceErrorCode.CMBDEV_ERR_SUCCESS)
                        {
                            if (error == CMBDeviceErrorCode.CMBDEV_ERR_BAD_QUALITY)
                            {
                                LogHelper.Debug("Bad quality");
                                //return;
                            }
                            LogHelper.Debug($"GenerateTemplate failed because of {error}");
                            //return;
                        }

                        //ltScreenInfo.WriteMessage("请松开您的手指");
                        //do
                        //{
                        error = cmbDeviceManager.DetectFinger(out status);
                        if (error != CMBDeviceErrorCode.CMBDEV_ERR_SUCCESS)
                        {
                            Console.WriteLine($"DetectFinger failed because of {error}");
                            // return;
                        }
                        //} while (status == 1);
                        ushort TemplateIndex = ushort.MaxValue, Result = ushort.MaxValue;
                        error = cmbDeviceManager.SearchTemplate(1, totalTemplateCapacity, ref TemplateIndex, ref Result);
                        if (error != CMBDeviceErrorCode.CMBDEV_ERR_SUCCESS)
                        {
                            //ltTaskInfo.WriteMessage("系统中未录入该指纹");
                            ShowInfo(informTb, "系统中未录入该指纹");
                            // return;
                        }
                        else
                        {
                            string fingerID = $"{TemplateIndex}";

                            if (fingerAll.Split(':').Contains(fingerID.Trim()))
                            {
                                fingerList.Add(fingerID);
                                ShowInfo(informTb, fingerID + "指纹比对通过，请录入下一个指纹");
                            }
                            else
                            {
                                ShowInfo(informTb, "指纹比对有误，非刷卡人员指纹");
                            }

                            //ltTaskInfo.WriteMessage("指纹比对通过，请录入下一个指纹");

                            LogHelper.Debug($"Template {TemplateIndex} matches with finger.");
                        }
                    }

                }

            }
            catch (Exception e)
            {
                LogHelper.Debug("指纹模块" + e);
            }
        }
        public static void ShowInfo(System.Windows.Forms.TextBox txtInfo, string Info)
        {
            txtInfo.Text = "";
            txtInfo.AppendText(Info);
            txtInfo.AppendText(Environment.NewLine);
            txtInfo.ScrollToCaret();
           

        }
        private void ErrorFeedback(string data)
        {
            try
            {
                string logicType = data.Split(':')[2];
                string payloads = data.Split(':')[1];
                sequence = data.Split(':')[0];
                string level = payloads.Substring(0, 2);
                string content = "";
                switch (level)
                {
                    case "FF":
                        content = "灾难信息";
                        break;
                    case "00":
                        content = "一般";
                        break;
                    case "01":
                        content = "警告";
                        break;
                    case "02":
                        content = "错误";
                        break;
                }

                int messLen = Convert.ToInt32(payloads.Substring(2, 8), 16) * 2;

                string mess = Encoding.UTF8.GetString(HexUtils.strToHexByte(payloads.Substring(10, messLen)));
                LogHelper.Debug(content + ":" + mess);
                if (mess.Equals("该设备已经下发过任务"))
                {

                    string cmd = ltTaskCmd.ReadMessage();
                    //获取结果
                    string result = ltTaskData.ReadMessage();

                    if (result != null && !result.Contains("手持机数据上传失败,手持机任务未完成"))
                    {

                        //sequence = ltMJSequence.ReadMessage();

                        byte[] commond = CommondHelper.DataCommit(sequence, "4002", "11", result, operatorUser, auditorUser);
                        socketClientMJ.sendAsynchronous(commond);
                    }

                }

                ltScreenInfo.WriteMessage(content + ":" + mess);
                //ShowInfo(informTb, content + ":" + mess);
            }
            catch (Exception e)
            {
                LogHelper.Debug("==" + e);
            }

        }

        private void UserDataSync(string data)
        {
            try
            {
                //string logicType = data.Split(':')[2];
                string payloads = data.Split(':')[1];
                sequence = data.Split(':')[0];
                byte[] commond = null;

                int metadataLen = Convert.ToInt32(payloads.Substring(0, 8), 16) * 2;
                string call = payloads.Substring(8, metadataLen);
                LogHelper.Debug("call" + Encoding.UTF8.GetString(HexUtils.strToHexByte(call)));
                string metamark = payloads.Substring(payloads.Length - 2);
                //string dataSouce = ltMetamark.ReadMessage();
                //if (!metamark.Equals(dataSouce))
                //{
                ltMetamark.WriteMessage(metamark);
                string mess = "";
                int i = 0;
                DataSync ds = JsonConvert.DeserializeObject<DataSync>(Encoding.UTF8.GetString(HexUtils.strToHexByte(call)));
                foreach (userInfo ui in ds.UserInfoList)
                {
                    i++;
                    string uid = ui.Uid;
                    string cid = ui.Cid;
                    string name = ui.Name;
                    string[] privileges = ui.Privileges;
                    string str = uid + ":" + cid + ":" + name + ":";
                    foreach (string pri in privileges)
                    {
                        str = str + pri + ":";
                    }
                    mess = mess + str + ";";

                    userList.Add(str);
                    if (loginUser)
                    {
                        if (i == 1)
                        {
                            auditorUser = uid;
                        }
                        else if (i == 2)
                        {
                            operatorUser = uid;
                        }
                    }
                    

                }
               
                    LogHelper.Debug("mess" + mess);
                    userInfo = mess;
                    ltUserInfo.WriteMessage(mess);
                //}
                //else
                //{

                //    userInfo = ltUserInfo.ReadMessage();
                //    string[] userArr = userInfo.Split(';');
                //    foreach (string item in userArr)
                //    {
                //        if (item != null && item != "")
                //        {
                //            userList.Add(item);
                //        }

                //    }
                //}

                commond = CommondHelper.DownCommond("", "2005", sequence, "00");
              
                        socketClientMJ.send(commond);
                    
                flagPrompt = true;
                //开启待办标识
                toDealFlag = true;
            }
            catch (Exception e)
            {
                LogHelper.Debug("==" + e);
            }
        }
        private void PCSCReader_ICCardRemoveEvent(CardStatusEventArgs e)
        {
            try
            {


                LogHelper.Debug("收到卡拔出感应事件 ART=" + StringAndBytesHelper.ToHexString(e.Atr, e.Atr.Length));

                string atr = StringAndBytesHelper.ToHexString(e.Atr, e.Atr.Length);

            }
            catch (Exception ex)
            {
                LogHelper.Debug("卡拔出感应事件出错" + ex);
            }

        }

        private void PCSCReader_ICCardInsertEvent(CardStatusEventArgs e)
        {
            try
            {


                LogHelper.Debug("收到卡插入感应事件 ART=" + StringAndBytesHelper.ToHexString(e.Atr, e.Atr.Length));
                string atr = StringAndBytesHelper.ToHexString(e.Atr, e.Atr.Length);
                readerIC.upPower();
                string sw = readerIC.sendAPDU("802007000849434643434B4633");

                sw = readerIC.sendAPDU("80200600083132333435363738");

                sw = readerIC.sendAPDU("80200200084346434341433032");

                sw = readerIC.sendAPDU("80A4000002AA01");

                sw = readerIC.sendAPDU("80B200000A");

                string cardnum = sw.Substring(0, sw.Length - 4);
                string cmp = sw.Substring(sw.Length - 4, 4);
                byte[] cardByte = HexUtils.strToHexByte(cardnum);
                cardnum = Encoding.Default.GetString(cardByte);
                LogHelper.Debug("flagGate" + flagGate + "cardnum" + cardnum);
                LogHelper.Debug("userInfo" + userInfo);
                if (cmp.Equals("9000"))
                {
                    if (userInfo.Contains(cardnum))
                    {


                        foreach (string item in userList)
                        {
                            //开启栅栏门刷卡用户且 收到入库指令
                            if (item.Contains(cardnum) && item.Contains("isolate") && flagGate)
                            {
                                
                                cardAll = cardAll + cardnum + ",";
                                //userGateCheck++;
                                cardUserHash.Add(item.Split(':')[0]);
                                ltScreenInfo.WriteMessage("用户" + cardnum + "已刷卡通过");
                                LogHelper.Debug("已刷卡用户数" + cardUserHash.Count);
                                if (fingerUseing)
                                {
                                    foreach (string fingerId in fingerArr)
                                    {
                                        if (fingerId.Contains(cardnum))
                                        {
                                            fingerAll = fingerAll + fingerId + ":";
                                        }
                                    }
                                }
                                

                            }
                            if (flagAlarm)
                            {
                                ltScreenInfo.WriteMessage("用户" + cardnum + "已刷卡解除警报");
                                flagAlarm = false;
                                sound.Stop();
                                comCom(redOff);
                                comCom(greenOn);
                            }
                            //用户登陆刷卡
                            if (!flagLoginUser && item.Contains(cardnum))
                            {
                                //userLoginCheck++;
                                cardLoginHash.Add(cardnum);
                                userLogin = userLogin + item.Split(':')[0] + ",";
                            }
                        }

                    }
                    else
                    {
                        ltScreenInfo.WriteMessage("该卡号" + cardnum + "无效");
                        // ftp.Upload(twoFile, "2.txt");

                    }

                }
                else
                {
                    LogHelper.Debug("读取IC卡ID失败：失败原因[" + sw + "]");
                }
                if (cardLoginHash.Count == 2)
                {
                    flagLoginUser = true;

                    auditorUser = userLogin.Split(',')[0];
                    operatorUser = userLogin.Split(',')[1];
                    cardLoginHash.Clear();
                    ltScreenInfo.WriteMessage("用户登陆成功");
                    //ftp.Upload(twoFile, "2.txt");
                    LogHelper.Debug("操作人" + auditorUser + "复核人" + operatorUser);
                }
                if (userGateCount == cardUserHash.Count)
                {
                    LogHelper.Debug("提交用户数据");
                    flagGate = false;
                    foreach (string res in cardUserHash)
                    {
                        userGate = userGate + res + ",";
                    }
                    LogHelper.Debug("符合的用户" + userGate);
                    byte[] commond = CommondHelper.UserEmpower(stackCode, "4003", "11", userGate, sequence);

                    socketClientMJ.send(commond);

                    cardUserHash.Clear();
                    userGate = "";
                }

            }
            catch (Exception ex)
            {
                LogHelper.Debug("卡插入感应事件出错" + ex);
            }
        }

        //当前版本号
        string version = "1.0.3";

        //逻辑硬件初始化1001
        private void HardwareInitialize(string data)
        {
            try
            {

                version = data.Split(':')[0];
                //string logicType = data.Split(':')[1];
                byte[] commond = null;
                

               
                commond = CommondHelper.HardwareInitialize(controlId, version, heartStatu, "1001", "00", "2");
                socketClientMJ.send(commond);
                //加载门架
                readerMJ = new Reader();

            }
            catch (Exception e)
            {
                LogHelper.Debug("初始化出错" + e);
            }

        }
        //检查环境1004
        private void CheckEnvironment(string data)
        {
            try
            {


                sequence = data.Split(':')[0];
                string content = data.Split(':')[1];
                if (!content.Equals("00000000"))
                {
                    content = content.Substring(8);
                    string contentCH = Encoding.UTF8.GetString(HexUtils.strToHexByte(content));
                    LogHelper.Debug("contentCH" + contentCH);
                    ltScreenInfo.WriteMessage(contentCH + "请重启软件");
                }
                else
                {
                    byte[] commond = CommondHelper.DownCommond("", "1004", sequence, "00");                    
                    socketClientMJ.send(commond);
                }
               
               
               
                

            }
            catch (Exception e)
            {
                LogHelper.Debug("检查环境出错" + e);
            }

        }
        //接入1005
        private void JoinUp(string data)
        {
            try
            {


                sequence = data.Split(':')[0];
                //string logicType = data.Split(':')[3];
                byte[] commond = CommondHelper.DownCommond("", "1005", sequence, "00");
               

                socketClientMJ.send(commond);
                ltScreenInfo.WriteMessage("门架接入成功");
             
            }
            catch (Exception e)
            {
                LogHelper.Debug("接入出错" + e);
            }
        }
        //电源管理8001上电和下电
        private void PowerManager(string data)
        {
            try
            {

                sequence = data.Split(':')[0];
                string payloads = data.Split(':')[1];
                string encryIndicate = data.Split(':')[2];
               // string logicType = data.Split(':')[4];
                string tag = payloads.Substring(0, 2);
                LogHelper.Debug("tag上下电标识" + tag);
                byte[] commond = null;
                switch (tag)
                {
                    case "01":
                        LogHelper.Debug("上电");
                        commond = CommondHelper.PowerManager("", sequence, "8001", encryIndicate);
                        break;
                    case "02":
                        LogHelper.Debug("下电");
                        commond = CommondHelper.PowerOff("", sequence, "8001", encryIndicate);
                        break;
                }


              
                 socketClientMJ.send(commond);
              
            }
            catch (Exception e)
            {
                LogHelper.Debug("8001电源管理出错" + e);
            }

        }
        //数据交换
        private void DataExchange(string data)
        {
            try
            {

                sequence = data.Split(':')[0];
                string mess = data.Split(':')[1];
                string encryIndicate = data.Split(':')[2];
                //string logicType = data.Split(':')[4];
                byte[] commond = CommondHelper.dataExchange("", sequence, mess, "8002", encryIndicate);
                
                    socketClientMJ.send(commond);
                
            }
            catch (Exception e)
            {
                LogHelper.Debug("数据交换出错" + e);
                ltScreenInfo.WriteMessage("数据交换出错,请重启程序");
            }
        }
        //下发

        string epcDataPlan = "";
        //StringBuilder epcDataPlan = new StringBuilder();
        double moneyPlan = 0;
        int jihua = 0;
        //int moneyTotal = 0;
        //string valTotal = "";
        private void DownCommond(string data)
        {
            try
            {

                sequence = data.Split(':')[0];
               
                string encryIndicate = data.Split(':')[4];
                //string logicType = data.Split(':')[6];
                string error = "";
                byte[] commond = CommondHelper.DownCommond(error, "2002", sequence, encryIndicate);
                socketClientMJ.sendAsynchronous(commond);

                string dataTo = data.Split(':')[3];
                string dataToPDA = dataTo.Substring(8);
                dataToPDAFinal = Encoding.UTF8.GetString(HexUtils.strToHexByte(dataToPDA));
                ltTaskCmd.WriteMessage(dataToPDAFinal);
              
                JObject jo = JObject.Parse(dataToPDAFinal);
                string code = jo["code"].ToString();
                //string sstackCode = "";
                LogHelper.Debug("下发code为" + code);
                string messInfo = "";
                string messTask = "";
                epcDataPlan = "";
                //epcDataPlan.Clear();
                bool glag = readerPCSC.upPower();
                mustOutSack = false;

                if (glag)
                {

                    switch (code)
                    {
                        case ("131074"):
                            messInfo = "出库业务，请刷卡开启栅栏门";
                            messTask = "出库业务";
                            stackCode = ((JArray)jo["stockPackInfoList"])[0]["sstackCode"].ToString();
                            osc = (OutScanCMD)JsonConvert.DeserializeObject<OutScanCMD>(dataToPDAFinal);
                            foreach (outScanStockPackInfo ossp in osc.StockPackInfoList)
                            {
                                string sackNo = ossp.SackNo; 
                                string mustOutFlag = ossp.MustOutFlag;
                                epcDataPlan = epcDataPlan + sackNo + ":";
                                if (mustOutFlag.Equals("1"))
                                {
                                    mustOutSack = true;
                                    mustSackNo = mustSackNo + sackNo + ":";
                                }
                            }
                            //foreach (outScanBusiInfo osb in osc.BusiInfoList)
                            //{

                            //    string totalMoney = osb.TotalMoney.Split('.')[0];
                            //    string val = osb.Val.Split('.')[0];
                            //    if (version.Equals("1.0.4"))
                            //    {
                            //        int haveBoxInfo = osb.HaveBoxInfo;
                            //        if (haveBoxInfo == 0)
                            //        {
                            //            moneyTotal = moneyTotal + int.Parse(totalMoney);
                            //        }
                            //    }


                            //    valTotal = valTotal + val;

                            //    LogHelper.Debug("val" + val + "totalMoney" + totalMoney + "该券别数量为" + int.Parse(totalMoney) / (int.Parse(val) * 20000));

                            //}
                            break;
                        case ("131075"):
                            messInfo = "入库业务，请刷卡开启栅栏门";
                            messTask = "入库业务";
                            stackCode = ((JArray)jo["stackInfoList"])[0]["sstackCode"].ToString();
                            esc = (EnterScanCMD)JsonConvert.DeserializeObject<EnterScanCMD>(dataToPDAFinal);
                            moneyPlan = 0;
                            //epcDataPlan = "";
                            //遍历计划内的锁条号和金额
                            foreach (paymentSack ps in esc.PaymentSackList)
                            {
                                string sackNo = ps.SackNo;
                                string sackMoney = ps.SackMoney;
                                moneyPlan = moneyPlan + double.Parse(sackMoney);
                                epcDataPlan = epcDataPlan + sackNo + ":";
                            }
                            //遍历库间编号
                            foreach (stackInfo si in esc.StackInfoList)
                            {
                                stackCode = si.SstackCode;
                                stackName = si.SstackName;
                            }
                            jihua = esc.PaymentSackList.Length;
                            break;
                        case ("131078"):
                            messInfo = "日核对业务，请刷卡开启栅栏门";
                            messTask = "日核对业务";
                            stackCode = ((JArray)jo["stockList"])[0]["sstackCode"].ToString();
                            break;
                        case ("131073"):
                            messInfo = "空包袋登记业务，如需进库请刷卡开启栅栏门";
                            messTask = "空包袋登记业务";
                            //sstackCode = ((JArray)jo["stackInfoList"])[0]["sstackCode"].ToString();
                            break;
                        case ("65537"):
                            messInfo = "封装操作，如需进库请刷卡开启栅栏门";
                            messTask = "封装操作";
                            stackCode = ((JArray)jo["stackInfoList"])[0]["sstackCode"].ToString();
                            break;
                        case ("131079"):
                            messInfo = "非业务进出库，请刷卡开启栅栏门";
                            messTask = "非业务进出库";
                            stackCode = ((JArray)jo["stacks"])[0]["id"].ToString();
                            LogHelper.Debug("库间名称" + stackCode + "意图" + ((JArray)jo["stacks"])[0]["intention"].ToString());
                            messInfo = messInfo + ((JArray)jo["stacks"])[0]["intention"].ToString();
                            NoBusinessCMD nbc = (NoBusinessCMD)JsonConvert.DeserializeObject<NoBusinessCMD>(dataToPDAFinal);
                            string spbccode = nbc.Spbccode;
                            string spbccodeName = nbc.SpbccodeName;
                            string nsumAmt = nbc.NsumAmt;
                            if (nsumAmt != null&& nsumAmt!="")
                            {
                                messTask = "无签封出入库业务";
                                messInfo = "无签封出入库业务,任务总金额" + nsumAmt + "请刷卡开启栅栏门";
                            }
                            break;
                        case ("131076"):
                            messTask = "实物交接业务";
                            break;
                        case ("131080"):
                            messInfo = "库内封装业务，请刷卡开启栅栏门";
                            messTask = "库内封装";
                            stackCode = ((JArray)jo["stackInfoList"])[0]["sstackCode"].ToString();
                            break;
                    }
                    if (mustOutSack)
                    {
                        messInfo = messInfo + ",当前业务包含必出箱，请优先出必出箱";
                    }
                    ltScreenInfo.WriteMessage(messInfo);
                    //ftp.Upload(twoFile, "2.txt");
                    flagGate = true;
                    LogHelper.Debug("当前业务" + messTask);
                    ltTaskInfo.WriteMessage("当前业务:" + messTask);
                    //this.informLb.Text = "";
                    //this.informLb.Text = "当前业务："+messTask;


                    LogHelper.Debug("下发到门架数据" + dataToPDAFinal);

                    bc = new BaseCommand();
                    bc.Code = int.Parse(code);
                    flagMJ = true;
                    string[] ipArr = ipAll.Split(':');
                    bool flag1 = readerMJ.mjTurnOff(ipArr[0]);
                    bool flag2 = readerMJ.mjTurnOff(ipArr[1]);
                    LogHelper.Debug("门架关闭状态" + flag1 + flag2);

                    //开启绿灯，关闭黄灯
                    comCom(greenOn);
                    comCom(yellowOff);
                    epcList.Clear();
                    flagUser = false;
                    flagFace = false;
                    errorList.Clear();
                    notTaskList.Clear();


                }
                else
                {
                    ltScreenInfo.WriteMessage("未识别psam卡");
                }


            }
            catch (Exception e)
            {
                LogHelper.Debug("下发出错" + e);
            }
        }

        //确认
        private void DataConfirm(string data)
        {
            try
            {

                sequence = data.Split(':')[0];
                string payloadsStr = data.Split(':')[1];
                string encryIndicate = data.Split(':')[2];
                //string logicType = data.Split(':')[3];
                string id = payloadsStr.Substring(0, 8);
                string fragment = payloadsStr.Substring(8, 8);
                string complete = payloadsStr.Substring(16, 4);
                string completeBin = HexUtils.HexStringToBinString(complete);
                completeBin = completeBin.Replace(" ", "");
                LogHelper.Debug("completeBin" + completeBin);
                string deleteIf = completeBin.Substring(0, 1);
                string validateIf = completeBin.Substring(14, 1);
                string acceptIf = completeBin.Substring(15, 1);
                LogHelper.Debug("是否删除:" + deleteIf + "验证是否失败:" + validateIf + "是否被通讯组件接收:" + acceptIf);
              

                byte[] commond = CommondHelper.DownCommond("", "2004", sequence, encryIndicate);
               
                    socketClientMJ.sendAsynchronous(commond);

                    //string ipAll = ConfigHelper.GetAppConfig("MjIP");
                    //string[] ipArr = ipAll.Split(':');
                    //for (int i = 0; i < ipArr.Length; i++)
                    //{
                    //    bool flag = readerMJ.mjTurnOff(ipArr[i]);
                    //    LogHelper.Debug("门架关闭" + ipArr[i] + flag);
                    //}
                epcList.Clear();
                //flagUser = false;
                errorList.Clear();
                notTaskList.Clear();
                if (deleteIf.Equals("1") && validateIf.Equals("0") && acceptIf.Equals("0"))
                {
                    TXTHelper.deleteByName("TaskCmd.txt");
                    ltScreen.WriteClear();
                    ltScreen.WriteLineNoTime("[03]任务总金额[03]0[03]元");
                    ltScreen.WriteLineNoTime("[01]已扫描金额[01]0[01]元");
                    ltScreen.WriteLineNoTime("[07]剩余金额[07]0[07]元");
                    ltScreen.WriteLineNoTime("[01]已扫描袋数[01]0[01]袋数");
                    //ftp.Upload(oneFile, "1.txt");
                }
                else if (deleteIf.Equals("0") && validateIf.Equals("1") && acceptIf.Equals("1"))
                {
                    ltScreenInfo.WriteMessage("上传成功,但通讯组件验证异常");

                    comCom(yellowOn);
                    Thread.Sleep(500);
                    comCom(greenOff);
                    Thread.Sleep(500);
                    comCom(redOff);
                }
                else if (deleteIf.Equals("0") && validateIf.Equals("0") && acceptIf.Equals("0"))
                {
                    ltScreenInfo.WriteMessage("上传成功，已被通讯组件接收");
                    flagUser = false;
                    comCom(yellowOn);
                    Thread.Sleep(500);
                    comCom(greenOff);
                    Thread.Sleep(500);
                    comCom(redOff);
                }

             


            }
            catch (Exception e)
            {
                LogHelper.Debug("确认出错" + e);
            }
        }
        //执行
        private void DataExecute(string data)
        {
            try
            {

                sequence = data.Split(':')[0];
                string encryIndicate = data.Split(':')[2];
                //string logicType = data.Split(':')[4];
                byte[] commond = CommondHelper.DownCommond("", "2003", sequence, encryIndicate);
                
                    socketClientMJ.sendAsynchronous(commond);
               

            }
            catch (Exception e)
            {
                LogHelper.Debug("执行出错" + e);
            }
        }





        private void OCXTest_CardStateEvent(bool cardstate)
        {
            //Console.Out.WriteLine("卡状态" + cardstate);
            //throw new NotImplementedException();
        }






        bool selfNetConn = false;

        //门架扫描
        private void timer1_Tick(object sender, EventArgs e)
        {
            try
            {

               
               
                //bool selfNetFlag = NetHelper.PingIpOrDomainName("127.0.0.1");
                //if (selfNetFlag&& !selfNetConn)
                //{
                //    LogHelper.Debug("控制器网络正常，开始与通讯组件连接");
                //    socketClientMJ.conn();
                //    selfNetConn = true;
                //}

              

                //收到2005后若没有刷卡登陆则提示刷卡登陆
                if (!flagLoginUser && flagPrompt&& !loginUser)
                {
                    ltScreenInfo.WriteMessage("请刷卡登陆");
                  
                }
               
               

                //门架启动前确保已收到任务，刷卡开启栅栏门，用户已登陆
                //if (flagMJ == true&& flagUser==true&& flagLoginUser==true)
                if (flagMJ == true && flagUser == true && flagLoginUser == true)
                //if (flagMJ == true  )
                {


                    LogHelper.Debug("门架开始扫描");
                    string[] ipArr = ipAll.Split(':');

                    for (int i = 0; i < ipArr.Length; i++)
                    {
                        string ip = ipArr[i];
                        if (ip.Length > 5 && !ip.Equals("127.0.0.1"))
                        {

                            bool mjStatus = readerMJ.getMjStatus(ip);
                            LogHelper.Debug("门架状态" + ip + mjStatus);
                            if (!mjStatus)
                            {
                                bool flag = readerMJ.mjTurnOn(ip);
                                if (flag)
                                {
                                    ltScreenInfo.WriteMessage("门架" + ip + "启动成功");
                                }
                                else
                                {
                                    ltScreenInfo.WriteMessage("门架" + ip + "启动失败");
                                }

                            }
                            List<String> list = readerMJ.mjEpcData(ip);
                            list.ForEach(o => epcList.Add(o));
                            
                            LogHelper.Debug("list" + list.Count);
                        }
                        
                    }
                    int code = bc.Code;
                   
                    LogHelper.Debug("下发code为" + code);
                    if (code == 131075)
                    {
                        //入库

                      
                        epcReal = new List<enterScanPackInfo>();
                        esd = new EnterScanData();
                        esd.Code = 163843;
                        if (version.Equals("1.0.3"))
                        {
                            esd.Error = "";
                        }
                       
                        //解析入库指令
                        //esc = (EnterScanCMD)JsonConvert.DeserializeObject<EnterScanCMD>(dataToPDAFinal);
                        //int jihua = esc.PaymentSackList.Length;
                        int shiji = 0;
                        string epcData = "";
                        //string epcDataPlan = "";
                        //double moneyPlan = 0;
                        double moneyReality = 0;
                        //遍历计划内的锁条号和金额
                        //foreach (paymentSack ps in esc.PaymentSackList)
                        //{
                        //    string sackNo = ps.SackNo;
                        //    string sackMoney = ps.SackMoney;
                        //    moneyPlan = moneyPlan + double.Parse(sackMoney);
                        //    epcDataPlan = epcDataPlan + sackNo + ":";
                        //}
                        //遍历库间编号
                        //foreach (stackInfo si in esc.StackInfoList)
                        //{
                        //    stackCode = si.SstackCode;
                        //    stackName = si.SstackName;
                        //}
                        foreach (string item in epcList)
                        {

                            LogHelper.Debug("item" + item);
                            if (item.Length == 24)
                            {
                                string epc = UserTool.EpcReader.readEpc(HexUtils.strToHexByte(item));

                                if (epc.Length==14)
                                {
                                    string tag = epc.Substring(0, 10);
                                   
                                    if (epcDataPlan.Contains(tag))
                                    {
                                        bool lockStatu = epc.Substring(10, 2).Equals("34");
                                        //bool lockStatu = epc.Substring(10, 1).Equals("3");
                                        epcData = epcData + item + "|";
                                        if (lockStatu)
                                        {
                                            foreach (paymentSack ps in esc.PaymentSackList)
                                            {

                                                string sackNo = ps.SackNo;
                                                
                                                if (tag.Equals(sackNo))
                                                {
                                                    shiji++;
                                                    enterScanPackInfo espi = new enterScanPackInfo();
                                                    //epcData = epcData + item + "|";
                                                    espi.SackNo = tag;
                                                    espi.VoucherTypeID = ps.VoucherTypeID;
                                                    espi.VoucherTypeName = ps.VoucherTypeName;
                                                    espi.PaperTypeID = ps.PaperTypeID;
                                                    espi.PaperTypeName = ps.PaperTypeName;
                                                    espi.Val = ps.Val;
                                                    espi.Bundles = ps.Bundles;
                                                    espi.Tie = ps.Tie;
                                                    espi.SackMoney = ps.SackMoney;
                                                    espi.OprDT = DateTime.Now.ToString("yyyyMMddhhmmss");
                                                    espi.SstackCode = stackCode;
                                                    espi.SstackName = stackName;
                                                    epcReal.Add(espi);
                                                    moneyReality = moneyReality + double.Parse(ps.SackMoney);

                                                }

                                            }
                                        }
                                        else
                                        {                                          
                                            errorList.Add(item);                                           
                                        }
                                        
                                    }
                                    else
                                    {
                                        notTaskList.Add(item);
                                        
                                    }
                                }
                           }

                        }
                        if (epcData.Length > 2)
                        {
                            epcData = epcData.Substring(0, epcData.Length - 1);
                            epcDataResult = epcData;
                        }
                        int shengyu = jihua - shiji;
                        double moneySurplus = moneyPlan - moneyReality;
                        string moneyPlanStr = moneyPlan.ToString("N");
                        string moneyRealityStr = moneyReality.ToString("N");
                        string moneySurplusStr = moneySurplus.ToString("N");
                        ltScreen.WriteClear();
                        ltScreen.WriteLineNoTime("[03]任务总金额[03]" + moneyPlanStr.Substring(0, moneyPlanStr.Length - 3) + "[03]元");
                        ltScreen.WriteLineNoTime("[01]已扫描金额[01]" + moneyRealityStr.Substring(0, moneyRealityStr.Length - 3) + "[01]元");
                        ltScreen.WriteLineNoTime("[07]剩余金额[07]" + moneySurplusStr.Substring(0, moneySurplusStr.Length - 3) + "[07]元");
                        ltScreen.WriteLineNoTime("[01]已扫描袋数[01]" + shiji + "[01]袋数");
                        ltScreen.WriteLineNoTime(epcData);
                        //ftp.Upload(oneFile, "1.txt");
                        //确保已开启栅栏门
                        if (jihua == shiji && flagUser)
                        {
                            LogHelper.Debug("计划" + jihua + "实际" + shiji);
                            esd.PackInfoList = epcReal.ToArray();
                            var serializerSettings = new JsonSerializerSettings
                            {
                                // 设置为驼峰命名
                                ContractResolver = new CamelCasePropertyNamesContractResolver()
                            };
                            string json = JsonConvert.SerializeObject(esd, Newtonsoft.Json.Formatting.None, serializerSettings);

                            byte[] data = CommondHelper.DataCommit(sequence, "4002", "11", json, operatorUser, auditorUser);
                            socketClientMJ.sendAsynchronous(data);
                            flagMJ = false;
                            epcReal.Clear();
                        }
                        else
                        {
                            LogHelper.Debug("计划" + jihua + "实际" + shiji);
                        }



                    }
                    else if (code == 131074)
                    {
                        //出库
                       
                        //解析下发出库指令
                        //OutScanCMD osc = new OutScanCMD();
                        //osc = (OutScanCMD)JsonConvert.DeserializeObject<OutScanCMD>(dataToPDAFinal);
                        //序列化出库上送指令
                        osd = new OutScanData();
                        osd.Code = 163842;
                       
                        if (version.Equals("1.0.3"))
                        {
                            osd.Error = "";
                        }
                        epcOut = new List<transferData>();

                       // int moneyTotal = 0;
                        int moneySacn = 0;
                        int shiji = 0;
                       // string valTotal = "";
                        string epcData = "";
                        int moneyTotal = 0;

                       
                        osc = (OutScanCMD)JsonConvert.DeserializeObject<OutScanCMD>(dataToPDAFinal);
                        foreach (outScanBusiInfo osb in osc.BusiInfoList)
                        {
                            string totalMoney = osb.TotalMoney.Split('.')[0];
                            string val = osb.Val;
                            if (version.Equals("1.0.4"))
                            {
                                int haveBoxInfo = osb.HaveBoxInfo;
                                
                                if (haveBoxInfo == 0)
                                {
                                    moneyTotal = moneyTotal + int.Parse(totalMoney);
                                }
                            }
                            
                            LogHelper.Debug("val" + val + "totalMoney" + totalMoney );

                        }



                        foreach (string item in epcList)
                        {
                            LogHelper.Debug("item" + item);
                            if (item.Length == 24)
                            {
                                string epc = UserTool.EpcReader.readEpc(HexUtils.strToHexByte(item));
                                LogHelper.Debug("epc" + epc);
                                int k = 0;
                                if (epc.Length==14)
                                {
                                    string val = ValHelper.getVal(epc.Substring(epc.Length - 1, 1));
                                   
                                    LogHelper.Debug("val" + val);
                                    string tag = epc.Substring(0, 10);
                                    if (epcDataPlan.Contains(tag))
                                    {
                                        bool lockStatu = epc.Substring(10, 2).Equals("34");
                                        epcData = epcData + item + "|";
                                        if (lockStatu)
                                        {

                                            //出库详情
                                            foreach (outScanStockPackInfo ossp in osc.StockPackInfoList)
                                            {

                                                string sackNo = ossp.SackNo;
                                                int scanMoney = int.Parse(ossp.SackMoney.Split('.')[0]);
                                                //LogHelper.Debug("sackNo" + sackNo + "tag" + tag);

                                                //满足扫描包号在出库列表中
                                                if (tag.Equals(sackNo))
                                                {
                                                    if (version.Equals("1.0.3"))
                                                    {
                                                        shiji++;

                                                        moneySacn = moneySacn + scanMoney;
                                                        transferData tfd = new transferData();
                                                        tfd.SackNo = tag;
                                                        tfd.VoucherTypeID = ossp.VoucherTypeID;
                                                        tfd.VoucherTypeName = ossp.VoucherTypeName;
                                                        tfd.PaperTypeID = ossp.PaperTypeID;
                                                        tfd.PaperTypeName = ossp.PaperTypeName;
                                                        tfd.Val = ossp.Val;
                                                        tfd.Bundles = ossp.Bundles;
                                                        tfd.Tie = ossp.Tie;
                                                        tfd.SackMoney = ossp.SackMoney;
                                                        tfd.MustOutFlag = ossp.MustOutFlag;
                                                        tfd.OprDT = DateTime.Now.ToString("yyyyMMddhhmmss");
                                                        tfd.StackCode = ossp.SstackCode;
                                                        epcOut.Add(tfd);


                                                    }
                                                    else
                                                    {
                                                        foreach (outScanBusiInfo osb in osc.BusiInfoList)
                                                        {
                                                            //满足扫描包号在出库任务券别中
                                                            int totalMoney = int.Parse(osb.TotalMoney.Split('.')[0]);
                                                            LogHelper.Debug("剩余总金额" + totalMoney);
                                                            if (osb.Val.Split('.')[0].Equals(val) && osb.HaveBoxInfo == 0 && totalMoney > 0)
                                                            {

                                                                shiji++;

                                                                osb.TotalMoney = Convert.ToString(totalMoney - scanMoney);
                                                                //moneySacn = k * money;
                                                                moneySacn = moneySacn + scanMoney;
                                                                transferData tfd = new transferData();
                                                                tfd.SackNo = tag;
                                                                tfd.VoucherTypeID = ossp.VoucherTypeID;
                                                                tfd.VoucherTypeName = ossp.VoucherTypeName;
                                                                tfd.PaperTypeID = ossp.PaperTypeID;
                                                                tfd.PaperTypeName = ossp.PaperTypeName;
                                                                tfd.Val = ossp.Val;
                                                                tfd.Bundles = ossp.Bundles;
                                                                tfd.Tie = ossp.Tie;
                                                                tfd.SackMoney = ossp.SackMoney;
                                                                tfd.MustOutFlag = ossp.MustOutFlag;
                                                                tfd.OprDT = DateTime.Now.ToString("yyyyMMddhhmmss");
                                                                tfd.StackCode = ossp.SstackCode;
                                                                epcOut.Add(tfd);



                                                                LogHelper.Debug("券别" + osb.Val + "总计" + shiji);
                                                                break;

                                                            }

                                                        }
                                                    }



                                                }

                                            }

                                        }
                                        else
                                        {                                          
                                            errorList.Add(item);

                                        }
                                    }
                                    else
                                    {
                                      
                                        notTaskList.Add(item);

                                    }
                               }
                            }
                        }
                        if (epcData.Length > 2)
                        {
                            epcData = epcData.Substring(0, epcData.Length - 1);
                            epcDataResult = epcData;

                        }
                        string moneyTotalStr = moneyTotal.ToString("N");
                        string moneySacnStr = moneySacn.ToString("N");
                        string moneySurplusStr = (moneyTotal - moneySacn).ToString("N");
                        ltScreen.WriteClear();
                        ltScreen.WriteLineNoTime("[03]任务总金额[03]" + moneyTotalStr.Substring(0, moneyTotalStr.Length - 3) + "[03]元");
                        ltScreen.WriteLineNoTime("[01]已扫描总金额[01]" + moneySacnStr.Substring(0, moneySacnStr.Length - 3) + "[01]元");
                        ltScreen.WriteLineNoTime("[07]剩余总金额[07]" + moneySurplusStr.Substring(0, moneySurplusStr.Length - 3) + "[07]元");
                        ltScreen.WriteLineNoTime("[01]已扫描袋数[01]" + shiji + "[01]袋数");
                        ltScreen.WriteLineNoTime(epcData);
                        //ftp.Upload(oneFile, "1.txt");
                        //确保已开启栅栏门
                        if (moneyTotal == moneySacn && flagUser == true)
                        {
                            osd.TransferDataList = epcOut.ToArray();
                            var serializerSettings = new JsonSerializerSettings
                            {
                                // 设置为驼峰命名
                                ContractResolver = new CamelCasePropertyNamesContractResolver()
                            };
                            string json = JsonConvert.SerializeObject(osd, Newtonsoft.Json.Formatting.None, serializerSettings);

                            byte[] data = CommondHelper.DataCommit(sequence, "4002", "11", json, operatorUser, auditorUser);
                            socketClientMJ.sendAsynchronous(data);
                            flagMJ = false;
                            epcOut.Clear();
                        }

                    }
                    else if (code == 131073)
                    {
                        //空包袋登记
                        SuperScanCMD ssc = new SuperScanCMD();
                        ssc = (SuperScanCMD)JsonConvert.DeserializeObject<SuperScanCMD>(dataToPDAFinal);
                        //判断下发任务是否带库间，没有则赋为空
                        if (ssc.StackInfoList.Length == 0)
                        {
                            stackCode = "";
                        }
                        string epcData = "";
                        int scanCount = 0;
                        //序列化空包袋登记上送指令
                        ssd = new SuperScanData();
                        ssd.Code = 163841;
                       
                        if (version.Equals("1.0.3"))
                        {
                            ssd.Error = "";
                        }
                        ssdList = new List<superScanPackinfo>();
                        foreach (string item in epcList)
                        {
                            if (item.Length == 24)
                            {
                                string epc = UserTool.EpcReader.readEpc(HexUtils.strToHexByte(item));
                               
                                string lockStuts = epc.Substring(10, 1);

                                if (epc.Length==14)
                                {
                                    epcData = epcData + item + "|";
                                    string tag = epc.Substring(0, epc.Length - 4);
                                    string val = ValHelper.getVal(epc.Substring(epc.Length - 1, 1));
                                    LogHelper.Debug("val" + val);
                                    //扫描券别在任务列表，且处于开袋状态
                                    if (checkVal(val) && lockStuts.Equals("2"))
                                    {
                                        scanCount++;
                                        superScanPackinfo ossp = new superScanPackinfo();

                                        ossp.Val = val + ".00";
                                        ossp.SackNo = tag;
                                        ossp.VoucherTypeID = newVoucherTypeID;
                                        ossp.VoucherTypeName = newVoucherTypeName;
                                        ossp.StackCode = stackCode;

                                        ossp.OprDT = DateTime.Now.ToString("yyyyMMddHHmmss");
                                        ssdList.Add(ossp);

                                    }
                                    else
                                    {
                                        this.informTb.Text = "该签封不在任务列表";

                                    }


                                }
                            }
                           
                        }
                        if (epcData.Length > 2)
                        {
                            epcData = epcData.Substring(0, epcData.Length - 1);

                        }
                        ltScreen.WriteClear();
                        ltScreen.WriteLineNoTime("[03]任务总金额[03]0[03]元");
                        ltScreen.WriteLineNoTime("[01]已扫描总金额[01]0[01]元");
                        ltScreen.WriteLineNoTime("[07]剩余总金额[07]0[07]元");
                        ltScreen.WriteLineNoTime("[01]已扫描袋数[01]" + scanCount + "[01]袋数");
                        ltScreen.WriteLineNoTime(epcData);
                       

                    }
                    else if (code == 131076)
                    {
                        //实物交接
                        //解析下发指令
                        TransferCMD tc = new TransferCMD();
                        tc = (TransferCMD)JsonConvert.DeserializeObject<TransferCMD>(dataToPDAFinal);
                        int totalMoney = 0;
                        int jihua = 0;
                        int shiji = 0;
                        int scanCount = 0;
                        foreach (outDetail od in tc.OutDetailList)
                        {
                            int scanMoney = int.Parse(od.TotalMoney.Split('.')[0]);
                            jihua = jihua + scanMoney;

                        }

                        LogHelper.Debug("任务总金额" + totalMoney);
                        string epcData = "";
                        //回送指令
                        ttd = new TransferTransferData();
                        ttd.Code = 163844;
                       
                        if (version.Equals("1.0.3"))
                        {
                            ttd.Error = "";
                        }

                        epcHandover = new List<transferPackInfo>();

                        foreach (string item in epcList)
                        {
                            if (item.Length == 24)
                            {
                                string epc = UserTool.EpcReader.readEpc(HexUtils.strToHexByte(item));
                                if (epc.Length==14)
                                {
                                    epcData = epcData + item + "|";
                                    string tag = epc.Substring(0, epc.Length - 4);
                                    foreach (scanSort ss in tc.ScanSortList)
                                    {
                                        if (tag.Equals(ss.SackNo))
                                        {
                                            string bankCode = "";
                                            string bankName = "";

                                            foreach (outDetail od in tc.OutDetailList)
                                            {
                                                if (ss.VoucherTypeID.Equals(od.VoucherTypeID))
                                                {
                                                    bankCode = od.OrganID;
                                                    bankName = od.OrganName;
                                                }
                                            }
                                            scanCount++;
                                            shiji = shiji + int.Parse(ss.SackMoney.Split('.')[0]);
                                            //totalMoney = totalMoney - int.Parse(ss.SackMoney.Split('.')[0]);
                                            transferPackInfo tpi = new transferPackInfo();
                                            tpi.SackNo = tag;
                                            tpi.SackMoney = ss.SackMoney;
                                            tpi.PaperTypeID = ss.PaperTypeID;
                                            tpi.PaperTypeName = ss.PaperTypeName;
                                            tpi.Val = ss.Val;
                                            tpi.VoucherTypeID = ss.VoucherTypeID;
                                            tpi.VoucherTypeName = ss.VoucherTypeName;
                                            tpi.OprDT = DateTime.Now.ToString("yyyyMMddHHmmss");
                                            tpi.Bundles = ss.Bundles;
                                            tpi.EditionCode = "";
                                            tpi.EditionName = "";
                                            tpi.BankCode = bankCode;
                                            tpi.BankName = bankName;
                                            epcHandover.Add(tpi);



                                        }
                                    }
                                }
                            }
                        }
                        if (epcData.Length > 2)
                        {
                            epcData = epcData.Substring(0, epcData.Length - 1);

                        }
                        ltScreen.WriteClear();
                        ltScreen.WriteLineNoTime("[03]任务总金额[03]" + jihua + "[03]元");
                        ltScreen.WriteLineNoTime("[01]已扫描总金额[01]" + shiji + "[01]元");
                        ltScreen.WriteLineNoTime("[07]剩余总金额[07]" + (jihua - shiji) + "[07]元");
                        ltScreen.WriteLineNoTime("[01]已扫描袋数[01]" + scanCount + "[01]袋数");
                        ltScreen.WriteLineNoTime(epcData);
                        //ftp.Upload(oneFile, "1.txt");
                        if (jihua == shiji)
                        {
                            ttd.PackInfoList = epcHandover.ToArray();
                            var serializerSettings = new JsonSerializerSettings
                            {
                                // 设置为驼峰命名
                                ContractResolver = new CamelCasePropertyNamesContractResolver()
                            };
                            string json = JsonConvert.SerializeObject(ttd, Newtonsoft.Json.Formatting.None, serializerSettings);

                            byte[] data = CommondHelper.DataCommit(sequence, "4002", "11", json, operatorUser, auditorUser);
                            socketClientMJ.sendAsynchronous(data);
                            flagMJ = false;
                            epcHandover.Clear();
                        }
                    }
                
                //else if (code == 131080)
                //{
                //    //空电子签封入库
                //    EmptyPackCheckInCMD epci = new EmptyPackCheckInCMD();
                //    epci = (EmptyPackCheckInCMD)JsonConvert.DeserializeObject<EmptyPackCheckInCMD>(dataToPDAFinal);
                //    string epcData = "";
                //    //回送指令
                //    epcid = new EmptyPackCheckInData();
                //    epcid.Code = 163848;
                //    int scanCount = 0;
                //    int shiji = 0;
                //    int jihua = epci.PackInfoList.Length;
                //    //获取库间信息
                //    foreach (stackInfo ss in epci.StackInfoList)
                //    {
                //        stackCode = ss.SstackCode;
                //        stackName = ss.SstackName;
                //    }
                //    foreach (string item in epcList)
                //    {

                //        string epc = UserTool.EpcReader.readEpc(HexUtils.strToHexByte(item));
                //        if (item.Length == 24 && epc.Substring(0, 3).Equals(packFilter))
                //        {
                //            epcData = epcData + item + "|";
                //            string tag = epc.Substring(0, epc.Length - 4);
                //            foreach (packInfo ss in epci.PackInfoList)
                //            {
                //                if (tag.Equals(ss.SackNo))
                //                {

                //                    shiji++;

                //                    emptyPackInfo tpi = new emptyPackInfo();
                //                    tpi.SackNo = tag;

                //                    tpi.Val = ss.Val;
                //                    tpi.VoucherTypeID = ss.VoucherTypeID;
                //                    tpi.VoucherTypeName = ss.VoucherTypeName;

                //                    emptyPackInfoList.Add(tpi);


                //                }
                //            }
                //        }
                //    }
                //    if (epcData.Length > 2)
                //    {
                //        epcData = epcData.Substring(0, epcData.Length - 1);

                //    }


                //    ltScreen.WriteClear();
                //    ltScreen.WriteLineNoTime("[03]任务总金额[03]" + jihua + "[03]元");
                //    ltScreen.WriteLineNoTime("[01]已扫描金额[01]" + shiji + "[01]元");
                //    ltScreen.WriteLineNoTime("[07]剩余金额[07]" + (jihua - shiji) + "[07]元");
                //    ltScreen.WriteLineNoTime("[01]已扫描袋数[01]" + scanCount + "[01]袋数");
                //    ltScreen.WriteLineNoTime(epcData);
                //    if (jihua == shiji)
                //    {
                //        epcid.PackInfoList = emptyPackInfoList.ToArray();
                //        var serializerSettings = new JsonSerializerSettings
                //        {
                //            // 设置为驼峰命名
                //            ContractResolver = new CamelCasePropertyNamesContractResolver()
                //        };
                //        string json = JsonConvert.SerializeObject(epcid, Newtonsoft.Json.Formatting.None, serializerSettings);

                //        byte[] data = CommondHelper.DataCommit(sequence, "4002", "11", json, operatorUser, auditorUser);
                //        socketClientMJ.sendAsynchronous(data);
                //        flagMJ = false;
                //        emptyPackInfoList.Clear();
                //    }

                //}
                else if (code == 131081)
                {
                    //电子签封入库核对
                    CheckInCMD cc = new CheckInCMD();
                    cc = (CheckInCMD)JsonConvert.DeserializeObject<CheckInCMD>(dataToPDAFinal);
                    string epcData = "";
                    //回送指令
                    cidd = new CheckInData();
                    cidd.Code = 163849;
                    int scanCount = 0;
                    int shiji = 0;
                    int jihua = 0;
                    //获取总金额
                    foreach (packinfoCheck ss in cc.CheckInList)
                    {
                        jihua = jihua + int.Parse(ss.SackMoney.Split('.')[0]); ;
                    }
                    foreach (string item in epcList)
                    {
                            if (item.Length == 24)
                            {
                                string epc = UserTool.EpcReader.readEpc(HexUtils.strToHexByte(item));
                                if (epc.Length==15)
                                {
                                    epcData = epcData + item + "|";
                                    string tag = epc.Substring(0, epc.Length - 4);
                                    foreach (packinfoCheck ss in cc.CheckInList)
                                    {
                                        if (tag.Equals(ss.SackNo))
                                        {

                                            scanCount++;
                                            shiji = shiji + int.Parse(ss.SackMoney.Split('.')[0]);
                                            //totalMoney = totalMoney - int.Parse(ss.SackMoney.Split('.')[0]);
                                            packInfoCheck tpi = new packInfoCheck();
                                            tpi.SackNo = tag;
                                            tpi.SackMoney = ss.SackMoney;
                                            tpi.PaperTypeID = ss.PaperTypeID;
                                            tpi.PaperTypeName = ss.PaperTypeName;
                                            tpi.Val = ss.Val;
                                            tpi.VoucherTypeID = ss.VoucherTypeID;
                                            tpi.VoucherTypeName = ss.VoucherTypeName;
                                            tpi.OprDT = DateTime.Now.ToString("yyyyMMddHHmmss");
                                            tpi.Bundles = ss.Bundles;
                                            tpi.SstackCode = ss.SstackCode;
                                            tpi.SstackName = ss.SstackName;
                                            packInfoCheckList.Add(tpi);


                                        }
                                    }
                               }
                            }
                    }
                    if (epcData.Length > 2)
                    {
                        epcData = epcData.Substring(0, epcData.Length - 1);

                    }


                    ltScreen.WriteClear();
                    ltScreen.WriteLineNoTime("[03]任务总金额[03]" + jihua + "[03]元");
                    ltScreen.WriteLineNoTime("[01]已扫描金额[01]" + shiji + "[01]元");
                    ltScreen.WriteLineNoTime("[07]剩余金额[07]" + (jihua - shiji) + "[07]元");
                    ltScreen.WriteLineNoTime("[01]已扫描袋数[01]" + scanCount + "[01]袋数");
                    ltScreen.WriteLineNoTime(epcData);
                    if (jihua == shiji)
                    {
                        cidd.PackInfoList = packInfoCheckList.ToArray();
                        var serializerSettings = new JsonSerializerSettings
                        {
                            // 设置为驼峰命名
                            ContractResolver = new CamelCasePropertyNamesContractResolver()
                        };
                        string json = JsonConvert.SerializeObject(cidd, Newtonsoft.Json.Formatting.None, serializerSettings);

                        byte[] data = CommondHelper.DataCommit(sequence, "4002", "11", json, operatorUser, auditorUser);
                        socketClientMJ.sendAsynchronous(data);
                        flagMJ = false;
                        packInfoCheckList.Clear();
                    }

                }
            }
            }
            catch (Exception ex)
            {
                LogHelper.Debug("门架扫描出错" + ex);
            }


}


        static string newVoucherTypeID = "";
        static string newVoucherTypeName = "";
        static string newVal = "";
        public static Boolean checkVal(string val)
        {
            try
            {
                SuperScanCMD ssc = new SuperScanCMD();
                string dataToPDAFinal = ltTaskCmd.ReadMessage();
                ssc = (SuperScanCMD)JsonConvert.DeserializeObject<SuperScanCMD>(dataToPDAFinal);
                foreach (superScanBusiInfo ssbi in ssc.BusiInfoList)
                {
                    if (ssbi.Val.Contains(val))
                    {
                        newVoucherTypeID = ssbi.VoucherTypeID;
                        newVoucherTypeName = ssbi.VoucherTypeName;
                        newVal = ssbi.Val;

                        return true;

                    }
                }
               
            }
            catch (Exception e)
            {
                LogHelper.Debug("授权开启栅栏门失败" + e);
            }
            return false;
        }



        private void button1_Click(object sender, EventArgs e)
        {
            try
            {

                //string id = ltSstackCode.ReadMessage();
                List<StackCode> scList = new List<StackCode>();
                StackCode sc = new StackCode();
                sc.Id = stackCode;

                StackCodeList scl = new StackCodeList();
                scl.Code = 163847;


                scl.Stacks = sc;

                var serializerSettings = new JsonSerializerSettings
                {
                    // 设置为驼峰命名
                    ContractResolver = new CamelCasePropertyNamesContractResolver()
                };
                string json = JsonConvert.SerializeObject(scl, Newtonsoft.Json.Formatting.None, serializerSettings);

                byte[] data = CommondHelper.DataCommit(sequence, "4002", "11", json, operatorUser, auditorUser);
                socketClientMJ.sendAsynchronous(data);
                flagMJ = false;
            }
            catch (Exception ex)
            {
                LogHelper.Debug("提交出错" + ex);
            }
        }

        private void button3_Click(object sender, EventArgs e)
        {
            try
            {
                //待办业务
                if (toDealFlag)
                {
                    dataToPDAFinal = ltTaskCmd.ReadMessage();
                    LogHelper.Debug("待办业务" + dataToPDAFinal);

                    if (dataToPDAFinal.Length > 0)
                    {

                        JObject jo = JObject.Parse(dataToPDAFinal);
                        string code = jo["code"].ToString();
                        LogHelper.Debug("下发code为" + code);
                        string messInfo = "";
                        string messTask = "";
                        epcDataPlan = "";
                        mustOutSack = false;
                        switch (code)
                        {
                            case ("131074"):
                                messInfo = "出库业务，请刷卡开启栅栏门";
                                messTask = "出库业务";
                                stackCode = ((JArray)jo["stockPackInfoList"])[0]["sstackCode"].ToString();
                                //osc = (OutScanCMD)JsonConvert.DeserializeObject<OutScanCMD>(dataToPDAFinal);
                                osc = (OutScanCMD)JsonConvert.DeserializeObject<OutScanCMD>(dataToPDAFinal);
                                foreach (outScanStockPackInfo ossp in osc.StockPackInfoList)
                                {
                                    string sackNo = ossp.SackNo;
                                    string mustOutFlag = ossp.MustOutFlag;
                                    epcDataPlan = epcDataPlan + sackNo + ":";
                                    if (mustOutFlag.Equals("1"))
                                    {
                                        mustOutSack = true;
                                        mustSackNo = mustSackNo + sackNo + ":";
                                    }

                                }
                                //foreach (outScanBusiInfo osb in osc.BusiInfoList)
                                //{
                                //    string totalMoney = osb.TotalMoney.Split('.')[0];
                                //    string val = osb.Val.Split('.')[0];
                                //    if (version.Equals("1.0.4"))
                                //    {
                                //        int haveBoxInfo = osb.HaveBoxInfo;
                                //        if (haveBoxInfo == 0)
                                //        {
                                //            moneyTotal = moneyTotal + int.Parse(totalMoney);
                                //        }
                                //    }


                                //    valTotal = valTotal + val;

                                //    LogHelper.Debug("val" + val + "totalMoney" + totalMoney + "该券别数量为" + int.Parse(totalMoney) / (int.Parse(val) * 20000));

                                //}
                                break;
                            case ("131075"):
                                messInfo = "入库业务，请刷卡开启栅栏门";
                                messTask = "入库业务";
                                stackCode = ((JArray)jo["stackInfoList"])[0]["sstackCode"].ToString();
                                esc = (EnterScanCMD)JsonConvert.DeserializeObject<EnterScanCMD>(dataToPDAFinal);
                                moneyPlan = 0;

                                //遍历计划内的锁条号和金额
                                foreach (paymentSack ps in esc.PaymentSackList)
                                {
                                    string sackNo = ps.SackNo;
                                    string sackMoney = ps.SackMoney;
                                    moneyPlan = moneyPlan + double.Parse(sackMoney);
                                    epcDataPlan = epcDataPlan + sackNo + ":";
                                }
                                //遍历库间编号
                                foreach (stackInfo si in esc.StackInfoList)
                                {
                                    stackCode = si.SstackCode;
                                    stackName = si.SstackName;
                                }
                                jihua = esc.PaymentSackList.Length;
                                break;
                            case ("131078"):
                                messInfo = "日核对业务，请刷卡开启栅栏门";
                                messTask = "日核对业务";
                                stackCode = ((JArray)jo["stockList"])[0]["sstackCode"].ToString();
                                break;
                            case ("131073"):
                                messInfo = "空包袋登记业务，如需进库请刷卡开启栅栏门";
                                messTask = "空包袋登记业务";
                                //sstackCode = ((JArray)jo["stackInfoList"])[0]["sstackCode"].ToString();
                                break;
                            case ("‭‭65537"):
                                messInfo = "封装操作，如需进库请刷卡开启栅栏门";
                                messTask = "封装操作";
                                stackCode = ((JArray)jo["stackInfoList"])[0]["sstackCode"].ToString();
                                break;
                            case ("131079"):
                                messInfo = "非业务进出库，请刷卡开启栅栏门";
                                messTask = "非业务进出库";
                                stackCode = ((JArray)jo["stacks"])[0]["id"].ToString();
                                messInfo = messInfo + ((JArray)jo["stacks"])[0]["intention"].ToString();
                                NoBusinessCMD nbc = (NoBusinessCMD)JsonConvert.DeserializeObject<NoBusinessCMD>(dataToPDAFinal);
                                string spbccode = nbc.Spbccode;
                                string spbccodeName = nbc.SpbccodeName;
                                string nsumAmt = nbc.NsumAmt;
                                if (nsumAmt != null && nsumAmt != "")
                                {
                                    messTask = "无签封出入库业务";
                                    messInfo = "无签封出入库业务,任务总金额" + nsumAmt + ";请刷卡开启栅栏门";
                                }
                                break;
                            case ("131076"):
                                messTask = "实物交接业务";
                                break;
                            case ("131080"):
                                messInfo = "库内封装业务，请刷卡开启栅栏门";
                                messTask = "库内封装";
                                stackCode = ((JArray)jo["stackInfoList"])[0]["sstackCode"].ToString();
                                break;
                        }
                        if (mustOutSack)
                        {
                            messInfo = messInfo + ",当前业务包含必出箱，请优先出必出箱";
                        }
                        ltScreenInfo.WriteMessage(messInfo);

                        LogHelper.Debug("当前业务" + messTask);
                        ltTaskInfo.WriteMessage("当前业务:" + messTask);

                        flagGate = true;

                        bc = new BaseCommand();
                        bc.Code = int.Parse(code);
                        flagMJ = true;

                        string[] ipArr = ipAll.Split(':');
                        bool flag1 = readerMJ.mjTurnOff(ipArr[0]);
                        bool flag2 = readerMJ.mjTurnOff(ipArr[1]);
                        LogHelper.Debug("门架关闭状态" + flag1 + flag2);
                       
                        comCom(yellowOff);
                        comCom(greenOn);
                        epcList.Clear();
                        flagUser = false;
                        errorList.Clear();
                        notTaskList.Clear();
                    }
                }
                else
                {
                    ltScreenInfo.WriteMessage("尚未接入通讯组件，请稍后");
                }
               
            }
            catch (Exception ex)
            {
                LogHelper.Debug("===" + ex);
            }
        }
        private void button4_Click(object sender, EventArgs e)
        {
            //非业务进出库
            try
            {

                List<StackCode> scList = new List<StackCode>();
                StackCode sc = new StackCode();
                sc.Id = stackCode;

                StackCodeList scl = new StackCodeList();
                scl.Code = 163847;


                scl.Stacks = sc;



                var serializerSettings = new JsonSerializerSettings
                {
                    // 设置为驼峰命名
                    ContractResolver = new CamelCasePropertyNamesContractResolver()
                };
                string json = JsonConvert.SerializeObject(scl, Newtonsoft.Json.Formatting.None, serializerSettings);

                byte[] data = CommondHelper.DataCommit(sequence, "4002", "11", json, operatorUser, auditorUser);
                socketClientMJ.sendAsynchronous(data);
                flagMJ = false;
                flagGate = false;

            }
            catch (Exception ex)
            {
                LogHelper.Debug("提交出错" + ex);
            }
        }

        private void button5_Click(object sender, EventArgs e)
        {
            try
            {
                //空包袋登记手动提交
                if (ssdList != null && ssdList.Count > 0)
                {
                    ssd.PackInfoList = ssdList.ToArray();
                    var serializerSettings = new JsonSerializerSettings
                    {
                        // 设置为驼峰命名
                        ContractResolver = new CamelCasePropertyNamesContractResolver()
                    };
                    string json = JsonConvert.SerializeObject(ssd, Newtonsoft.Json.Formatting.None, serializerSettings);

                    byte[] data = CommondHelper.DataCommit(sequence, "4002", "11", json, operatorUser, auditorUser);
                    socketClientMJ.sendAsynchronous(data);
                    flagMJ = false;
                    ssdList.Clear();
                }

                //入库手动提交
                if (epcReal != null && epcReal.Count > 0)
                {
                    esd.PackInfoList = epcReal.ToArray();
                    var serializerSettings = new JsonSerializerSettings
                    {
                        // 设置为驼峰命名
                        ContractResolver = new CamelCasePropertyNamesContractResolver()
                    };
                    string json = JsonConvert.SerializeObject(esd, Newtonsoft.Json.Formatting.None, serializerSettings);

                    byte[] data = CommondHelper.DataCommit(sequence, "4002", "11", json, operatorUser, auditorUser);
                    socketClientMJ.sendAsynchronous(data);
                    flagMJ = false;
                    //清空数据
                    epcReal.Clear();
                }
                //出库手动提交
                if (epcOut != null && epcOut.Count > 0)
                {
                    osd.TransferDataList = epcOut.ToArray();
                    var serializerSettings = new JsonSerializerSettings
                    {
                        // 设置为驼峰命名
                        ContractResolver = new CamelCasePropertyNamesContractResolver()
                    };
                    string json = JsonConvert.SerializeObject(osd, Newtonsoft.Json.Formatting.None, serializerSettings);

                    byte[] data = CommondHelper.DataCommit(sequence, "4002", "11", json, operatorUser, auditorUser);
                    socketClientMJ.sendAsynchronous(data);
                    flagMJ = false;
                    epcOut.Clear();
                }
                //实物交接手动提交
                if (epcHandover != null && epcHandover.Count > 0)
                {
                    ttd.PackInfoList = epcHandover.ToArray();
                    var serializerSettings = new JsonSerializerSettings
                    {
                        // 设置为驼峰命名
                        ContractResolver = new CamelCasePropertyNamesContractResolver()
                    };
                    string json = JsonConvert.SerializeObject(ttd, Newtonsoft.Json.Formatting.None, serializerSettings);

                    byte[] data = CommondHelper.DataCommit(sequence, "4002", "11", json, operatorUser, auditorUser);
                    socketClientMJ.sendAsynchronous(data);
                    flagMJ = false;
                    epcHandover.Clear();
                }
            }
            catch (Exception ex)
            {
                LogHelper.Debug("==" + ex);
            }
        }
        public void cbExceptionCB(uint dwType, int lUserID, int lHandle, IntPtr pUser)
        {
            //异常消息信息类型
            string stringAlarm = "异常消息回调，信息类型：0x" + Convert.ToString(dwType, 16) + ", lUserID:" + lUserID + ", lHandle:" + lHandle;


            //创建该控件的主线程直接更新信息列表 
            UpdateClientListException(DateTime.Now.ToString(), lUserID, stringAlarm);

        }

        public bool MsgCallback_V31(int lCommand, ref CHCNetSDK.NET_DVR_ALARMER pAlarmer, IntPtr pAlarmInfo, uint dwBufLen, IntPtr pUser)
        {
            //通过lCommand来判断接收到的报警信息类型，不同的lCommand对应不同的pAlarmInfo内容
            AlarmMessageHandle(lCommand, ref pAlarmer, pAlarmInfo, dwBufLen, pUser);

            return true; //回调函数需要有返回，表示正常接收到数据
        }
        public void cbLoginCallBack(int lUserID, int dwResult, IntPtr lpDeviceInfo, IntPtr pUser)
        {
            string strLoginCallBack = "登录设备，lUserID：" + lUserID + "，dwResult：" + dwResult;

            if (dwResult == 0)
            {
                uint iErrCode = CHCNetSDK.NET_DVR_GetLastError();
                strLoginCallBack = strLoginCallBack + "，错误号:" + iErrCode;
            }

            //下面代码注释掉也会崩溃

            //创建该控件的主线程直接更新信息列表 
            UpdateClientList(strLoginCallBack, lpDeviceInfo);

        }

        public void UpdateClientList(string strAlarmTime, string strDevIP, string strAlarmMsg)
        {
            //列表新增报警信息
            Console.WriteLine("strAlarmTime" + strAlarmTime + "strDevIP" + strDevIP + "strAlarmMsg" + strAlarmMsg);
        }

        public void UpdateClientList(string strLogStatus, IntPtr lpDeviceInfo)
        {
            //列表新增报警信息
            Console.WriteLine("登录状态（异步）：" + strLogStatus);
        }
        public void UpdateClientListException(string strAlarmTime, int lUserID, string strAlarmMsg)
        {
            //异常设备信息



            //列表新增报警信息
            Console.WriteLine(strAlarmTime, lUserID, strAlarmMsg);

        }
        public void AlarmMessageHandle(int lCommand, ref CHCNetSDK.NET_DVR_ALARMER pAlarmer, IntPtr pAlarmInfo, uint dwBufLen, IntPtr pUser)
        {
            try
            {
                //通过lCommand来判断接收到的报警信息类型，不同的lCommand对应不同的pAlarmInfo内容
                switch (lCommand)
                {

                    case CHCNetSDK.COMM_ALARM_ACS://门禁主机报警上传
                        ProcessCommAlarm_AcsAlarm(ref pAlarmer, pAlarmInfo, dwBufLen, pUser);
                        break;


                    default:
                        {
                            //报警设备IP地址
                            string strIP = System.Text.Encoding.UTF8.GetString(pAlarmer.sDeviceIP).TrimEnd('\0');

                            //报警信息类型
                            string stringAlarm = "报警上传，信息类型：0x" + Convert.ToString(lCommand, 16);


                            //创建该控件的主线程直接更新信息列表 
                            UpdateClientList(DateTime.Now.ToString(), strIP, stringAlarm);

                        }
                        break;
                }
            }
            catch (Exception e)
            {
                LogHelper.Debug("==" + e);
            }
        }
        private void ProcessCommAlarm_AcsAlarm(ref CHCNetSDK.NET_DVR_ALARMER pAlarmer, IntPtr pAlarmInfo, uint dwBufLen, IntPtr pUser)
        {
            try
            {
                CHCNetSDK.NET_DVR_ACS_ALARM_INFO struAcsAlarm = new CHCNetSDK.NET_DVR_ACS_ALARM_INFO();
                uint dwSize = (uint)Marshal.SizeOf(struAcsAlarm);
                struAcsAlarm = (CHCNetSDK.NET_DVR_ACS_ALARM_INFO)Marshal.PtrToStructure(pAlarmInfo, typeof(CHCNetSDK.NET_DVR_ACS_ALARM_INFO));

                //报警设备IP地址
                string strIP = System.Text.Encoding.UTF8.GetString(pAlarmer.sDeviceIP).TrimEnd('\0');

                //保存抓拍图片
                if ((struAcsAlarm.dwPicDataLen != 0) && (struAcsAlarm.pPicData != IntPtr.Zero))
                {
                    string str = ".\\picture\\Device_Acs_CapturePic_[" + strIP + "]_lUerID_[" + pAlarmer.lUserID + "]_" + iFileNumber + ".jpg";
                    FileStream fs = new FileStream(str, FileMode.Create);
                    int iLen = (int)struAcsAlarm.dwPicDataLen;
                    byte[] by = new byte[iLen];
                    Marshal.Copy(struAcsAlarm.pPicData, by, 0, iLen);
                    fs.Write(by, 0, iLen);
                    fs.Close();
                    iFileNumber++;
                }

                //报警时间：年月日时分秒
                string strTimeYear = (struAcsAlarm.struTime.dwYear).ToString();
                string strTimeMonth = (struAcsAlarm.struTime.dwMonth).ToString("d2");
                string strTimeDay = (struAcsAlarm.struTime.dwDay).ToString("d2");
                string strTimeHour = (struAcsAlarm.struTime.dwHour).ToString("d2");
                string strTimeMinute = (struAcsAlarm.struTime.dwMinute).ToString("d2");
                string strTimeSecond = (struAcsAlarm.struTime.dwSecond).ToString("d2");
                string strTime = strTimeYear + "-" + strTimeMonth + "-" + strTimeDay + " " + strTimeHour + ":" + strTimeMinute + ":" + strTimeSecond;

                string stringAlarm = "门禁主机报警信息，dwMajor：0x" + Convert.ToString(struAcsAlarm.dwMajor, 16) + "，dwMinor：0x" +
                    Convert.ToString(struAcsAlarm.dwMinor, 16) + "，卡号：" + System.Text.Encoding.UTF8.GetString(struAcsAlarm.struAcsEventInfo.byCardNo).TrimEnd('\0')
                    + "，读卡器编号：" + struAcsAlarm.struAcsEventInfo.dwCardReaderNo + "，报警触发时间：" + strTime +
                    "，事件流水号：" + struAcsAlarm.struAcsEventInfo.dwSerialNo;
                LogHelper.Debug("===" + stringAlarm);

                //事件类型03操作  05事件
                string dwMajor = "0x" + Convert.ToString(struAcsAlarm.dwMajor, 16);
                string dwMinor = "0x" + Convert.ToString(struAcsAlarm.dwMinor, 16);
                string cardNum = System.Text.Encoding.UTF8.GetString(struAcsAlarm.struAcsEventInfo.byCardNo).TrimEnd('\0');
                LogHelper.Debug("人脸识别验证通过，卡号为" + cardNum + "ip为" + strIP);
                LogHelper.Debug("用户刷卡卡号" + cardAll);
                bool myColClear = false;
                //管库员刷卡通过
                if (flagFace)
                {
                    if (dwMajor.Equals("0x5"))
                    {
                        if (dwMinor.Equals("0x4b"))
                        {
                            if (cardAll.Contains(cardNum))
                            {

                                myCol.Add(strIP, cardNum);
                                foreach (string keys in myCol)
                                {
                                    LogHelper.Debug(keys + ":" + myCol[keys]);
                                    string[] cardArr = myCol[keys].Split(',');

                                    foreach (string cardId in cardArr)
                                    {
                                        LogHelper.Debug("cardId" + cardId);
                                        cardHash.Add(cardId);

                                        ltScreenInfo.WriteMessage("人脸识别验证通过，卡号为" + cardNum);

                                        if (cardHash.Count == userGateCount)
                                        {
                                            ltScreenInfo.WriteMessage("人脸识别验证通过，开启栅栏门");
                                            myColClear = true;
                                            flagFace = false;
                                            cardHash.Clear();
                                            cardAll = "";
                                            if (gateEncrypt)
                                            {
                                                //开启加密串口栅栏门
                                                spc.readEpc();
                                            }
                                            else
                                            {
                                                comCom(gateOn);
                                                Thread.Sleep(gateTime);
                                                comCom(gateOff);
                                            }

                                        }
                                    }

                                }
                               
                            }
                            else
                            {
                                ltScreenInfo.WriteMessage("该人脸非刷卡人员，卡号为" + cardNum);
                            }
                            if (myColClear)
                            {
                                myCol.Clear();
                            }

                        }
                        else if (dwMinor.Equals("0x4c"))
                        {
                            LogHelper.Debug("人脸识别验证失败");
                        }
                    }
                }

                if (struAcsAlarm.byAcsEventInfoExtendV20 == 1)
                {
                    CHCNetSDK.NET_DVR_ACS_EVENT_INFO_EXTEND_V20 struInfoExtendV20 = new CHCNetSDK.NET_DVR_ACS_EVENT_INFO_EXTEND_V20();
                    uint dwSizeEx = (uint)Marshal.SizeOf(struInfoExtendV20);
                    struInfoExtendV20 = (CHCNetSDK.NET_DVR_ACS_EVENT_INFO_EXTEND_V20)Marshal.PtrToStructure(struAcsAlarm.pAcsEventInfoExtendV20, typeof(CHCNetSDK.NET_DVR_ACS_EVENT_INFO_EXTEND_V20));
                    stringAlarm = stringAlarm + ", 温度:" + struInfoExtendV20.fCurrTemperature + ", 是否异常温度:" + struInfoExtendV20.byIsAbnomalTemperature
                        + ", 是否需要核验:" + struInfoExtendV20.byRemoteCheck;

                    if (struInfoExtendV20.byRemoteCheck == 2)
                    {
                        //ACS_remoteCheck(struAcsAlarm.struAcsEventInfo.dwSerialNo);
                        //下发核验结果命令，实际可以使用消息事件的方式在回调函数外面处理，避免这样直接处理阻塞回调
                    }

                    //保存热成像图片
                    if ((struInfoExtendV20.dwThermalDataLen != 0) && (struInfoExtendV20.pThermalData != IntPtr.Zero))
                    {
                        string str = ".\\picture\\Device_Acs_ThermalData_[" + strIP + "]_lUerID_[" + pAlarmer.lUserID + "]_" + iFileNumber + ".jpg";
                        FileStream fs = new FileStream(str, FileMode.Create);
                        int iLen = (int)struInfoExtendV20.dwThermalDataLen;
                        byte[] by = new byte[iLen];
                        Marshal.Copy(struInfoExtendV20.pThermalData, by, 0, iLen);
                        fs.Write(by, 0, iLen);
                        fs.Close();
                        iFileNumber++;
                    }
                }

                if (struAcsAlarm.byAcsEventInfoExtend == 1)
                {
                    CHCNetSDK.NET_DVR_ACS_EVENT_INFO_EXTEND struInfoExtend = new CHCNetSDK.NET_DVR_ACS_EVENT_INFO_EXTEND();
                    uint dwSizeEx = (uint)Marshal.SizeOf(struInfoExtend);
                    struInfoExtend = (CHCNetSDK.NET_DVR_ACS_EVENT_INFO_EXTEND)Marshal.PtrToStructure(struAcsAlarm.pAcsEventInfoExtend, typeof(CHCNetSDK.NET_DVR_ACS_EVENT_INFO_EXTEND));
                    stringAlarm = stringAlarm + ", 人员类型:" + struInfoExtend.byUserType;
                }


                //创建该控件的主线程直接更新信息列表 
                UpdateClientList(DateTime.Now.ToString(), strIP, stringAlarm);

            }
            catch (Exception e)
            {
                LogHelper.Debug("人脸识别===" + e);
            }
        }

        private void button6_Click(object sender, EventArgs e)
        {
            if (epcDataResult.Length > 2)
            {
                string[] epcDataResultArr = epcDataResult.Split('|');
                string contentView = "已扫描袋号\r\n电子签封ID:券别";
                foreach(string item in epcDataResultArr)
                {
                    string epc = UserTool.EpcReader.readEpc(HexUtils.strToHexByte(item));
                    string sackNo = epc.Substring(0, 10);
                    string val = ValHelper.getVal(epc.Substring(epc.Length - 1, 1));
                    contentView = contentView + sackNo + ":" + val+ "\r\n";
                }

                ltScreenInfo.WriteMessage(contentView);
            }

        }

        private void button7_Click(object sender, EventArgs e)
        {
            //userGate = "32098,34794,51";
            //byte[] commond = CommondHelper.UserEmpower("73201001010102", "4003", "11", userGate, sequence);

            //socketClientMJ.send(commond);

            //SerialPortComImplement spc = new SerialPortComImplement("COM3", 115200, 8);
            //bool flag = spc.Open();
            //LogHelper.Debug("flag" + flag);
            if (gateEncrypt)
            {
                if (flagEncry)
                {
                    spc.readEpc();
                }
            } 
            else
            {
                comCom(gateOn);
                Thread.Sleep(gateTime);
                comCom(gateOff);
               
            }
           

        }
        private void serialPort_DataReceivedEventHandler(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
           
            int len = this.serialPort2.BytesToRead;
            string receivedata = string.Empty;
            if (len != 0)
            {
                byte[] buff = new byte[len];
                this.serialPort2.Read(buff, 0, len);
                receivedata = HexUtils.byteToHexStr(buff);
            }
            
            LogHelper.Debug("receivedata" + receivedata);

           
           
        }

        private void button8_Click(object sender, EventArgs e)
        {
            try
            {
                LogHelper.Debug("手动连接通讯组件");
                socketClientMJ.soekctClose();
                socketClientMJ.conn();
            }
            catch (Exception ex)
            {

            }
            
            
            

        }

        private void button9_Click(object sender, EventArgs e)
        {
            //string epc = UserTool.EpcReader.readEpc(HexUtils.strToHexByte("478B3643164E20260008CEC1"));
           // epcList.Add("478B3643164E20260008CEC1");
            ltScreenInfo.WriteMessage("请刷卡解除警报" );
            //flagGate = true;
            flagAlarm = true;
           
            foreach (string item in errorList)
            {
                LogHelper.Debug("errorList" + item);
                epcList.Remove(item);
            }
            foreach (string item in notTaskList)
            {
                LogHelper.Debug("notTaskList" + item);
                epcList.Remove(item);
            }
            errorList.Clear();
            notTaskList.Clear();


        }

        private void timer2_Tick(object sender, EventArgs e)
        {

            try
            {
                if (heartStatu&& socketSatau&& socketClientMJ.socketConn())
                {
                    byte[] dataHeart = CommondHelper.HeartConnect("0000", "00", "2");
                    socketClientMJ.send(dataHeart);
                }
                if (errorList.Count > 0|| notTaskList.Count>0)
                {
                    sound.Play();
                    string errMess = "";
                    string noTaskMess = "";
                    foreach (string item in errorList)
                    {
                        string epc = UserTool.EpcReader.readEpc(HexUtils.strToHexByte(item));
                        string tag = epc.Substring(0, 10);
                        errMess = errMess + tag + "\r\n";
                    }
                    if (errorList.Count > 0)
                    {
                        errMess = "锁异常袋号:" + errMess ;
                    }
                    foreach (string item in notTaskList)
                    {
                        string epc = UserTool.EpcReader.readEpc(HexUtils.strToHexByte(item));
                        string tag = epc.Substring(0, 10);
                        noTaskMess = noTaskMess + tag + "\r\n";
                    }
                    if (notTaskList.Count > 0)
                    {
                        noTaskMess = "不在任务列表中:" + noTaskMess ;
                    }
                    ltScreenInfo.WriteMessage(errMess+ noTaskMess);
                }
                bool flag = NetHelper.PingIpOrDomainName(ServerIP);
                //检查业务机和门架网络状况
                if (flag == false)
                {
                    ltScreenInfo.WriteMessage("业务机未连接，请检查业务机");
                    sound.Play();


                }
                if (faceUseing == true)
                {
                    string deviceIp = ConfigHelper.GetAppConfig("DeviceIp");
                    bool flagDevice = NetHelper.PingIpOrDomainName(deviceIp);
                    if (flagDevice == false)
                    {
                        ltScreenInfo.WriteMessage("栅栏门未连接，请检查栅栏门");
                        sound.Play();


                    }
                }
                string[] ipArr = ipAll.Split(':');
                for (int i = 0; i < ipArr.Length; i++)
                {
                    string ip = ipArr[i];
                    flag = NetHelper.PingIpOrDomainName(ip);
                    if (flag == false)
                    {

                        ltScreenInfo.WriteMessage(ip + "门架未连接，请检查门架！");
                        sound.Play();
                    }
                }
                if (!socketSatau)
                {
                    LogHelper.Debug("检测到与通讯组件未连接，重新连接");
                    socketSatau = socketClientMJ.conn();
                }
                if (!socketClientMJ.socketConn())
                {
                    ltScreenInfo.WriteMessage( "与通讯组件连接中断，请点击手动接入通讯组件或重启通讯组件");
                }
            }
            catch (Exception ex)
            {
                LogHelper.Debug("网络监测" + ex);
            }
        }

        private void button10_Click(object sender, EventArgs e)
        {
            if (mustOutSack)
            {
                ltScreenInfo.WriteMessage(mustSackNo);
            }
            else
            {
                ltScreenInfo.WriteMessage("当前业务没有必出箱");
            }
        }

        private void button11_Click(object sender, EventArgs e)
        {
            Application.ExitThread();
            Application.Restart();
        }
    }
}