XS202408319330/MainWindow.xaml.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Threading;
using System.IO.Ports;
using System.Data;
using System.Windows.Media.Animation;
using System.Windows.Threading;
using System.Configuration;
using DAL;
using COM;
using AGV_WPF_Global;
using AGV_WPF_DisMember;
using NS_SoftKey_Win;
using System.Runtime.InteropServices;
using System.Windows.Interop;
using Casun_SoftKey;
using DataServices;
using AGV_WPF.Models;
using System.Diagnostics;
using System.Data.OleDb;
using System.Text.RegularExpressions;
using System.ServiceModel;
using System.ServiceModel.Description;
using Dispatch;
using AGV_WPF.ExtraUI;
using System.Net;
using AGV_WPF.Plugin;
using System.Data.SqlClient;
using Services;
using AGV_WPF.Services;
using System.Collections;
using System.Net.Sockets;
using UseRate;
using DataControl;
using AGV_WPF.TrafficDefine;
using AGV_WPF.Tools;
using AGV_WPF.DataControl;
using AGV_WPF.NewCotent;
using TrafficDll;
using System.IO;
using System.Xml.Serialization;
using AGV_WPF.Model;
using AGV_WPF.DLL;
using WCS.API.WebApiClient;

namespace AGV_WPF
{
    /// <summary>
    /// MainWindow.xaml 的交互逻辑
    /// </summary>
    public partial class MainWindow : Window
    {
        #region 类变量
        AGVInfoService agvService = new AGVInfoService();
        //#region AGV结构体的定义
        public struct AGVStatus_TypStr         //AGV状态,可显示到屏
        {
            public bool WlLink;         //无线连接状态
            public byte Wlink_Count;    //无线连接中断次数
            public byte AgvNum;			//AGV标号
            public byte WorkLine;		//生产区
            public int MarkNum;			//当前地标
            public byte MarkFunction;	//地标功能
            public int TrafficNum;    	//管制区号
            public byte Status;			//运行状态
            public int LineNum;			//当前线路
            public byte Speed;          //当前速度
            public int DockNum;    //是否进入停靠区
            public byte Direction;//方向
            public float Voltage;      //电压
            public float Current;      //电流
        };
        #region AGV常变量的定义

        //常变量的定义

        //AGV运行控制
        public const bool AGVMODERUN = true;
        public const bool AGVMODESTOP = false;
        public Int64 TrafficData = 0L;//初试状态运行
        //AGV无线连接状态
        public const bool AGVWLLINK_OK = true;
        public const bool AGVWLLINK_ERROR = false;
        //AGV断线踢出管制区的最大次数设定（1次==550毫秒）
        public int OffLinkMax = Convert.ToInt32(ConfigurationManager.AppSettings["OffLink_MAX"]);

        //实际的AGV数量
        public byte AGVNUM_MAX = Convert.ToByte(ConfigurationManager.AppSettings["AGVNUM_MAX"]);

        //管制区AGV等待数量
        public byte TRAFFIC_CONAREA_WAITAGVNUM_MAX = Convert.ToByte(ConfigurationManager.AppSettings["TRAFFIC_CONAREA_WAITAGVNUM_MAX"]);
        //管制区实际数量
        public int TRAFFIC_CONAREA;
        //停靠区实际数量
        public int DOCKAREA_NUM;

        //AGV地标功能
        public const byte AGVMARKFUN_OVER = 15;

        //帧校验结果
        public const byte VERIFY_NOERROR = 0;
        public const byte VERIFY_HEADERROR = 1;
        public const byte VERIFY_ENDERROR = 2;
        public const byte VERIFY_FUNERROR = 3;
        public const byte VERIFY_BCCERROR = 4;

        #endregion
        TrafficDll.Traffic traffic_1;
        #region AGV信息定义
        public string[] MarkFuncOpt;
        public string[] StatusOpt;
        public string[] SpeedOpt = { "初始化...", "低速", "中速", "高速", "最高速", "减速" };
        public Brush[] ColorOpt = { Brushes.DarkOliveGreen, Brushes.Tomato, Brushes.Purple, Brushes.Pink, Brushes.SkyBlue, Brushes.LightBlue, Brushes.GreenYellow, Brushes.Goldenrod };
        public string[] WirelessOpt = { "成功", "失败" };
        public string[] TrafficStateOpt = { "管制中", "非管制" };

        //public AgvStatus[] AgvStatusList;

        TrafficManager AgvTrafficManager;//AGV交通管制管理对象

        #endregion

        #region 串口信息定义
        //串口定义
        //private COM.SerialPortWrapper SPComControl;
        private List<COM.SerialPortWrapper> SPComCOntrolList = null;
        public static List<COM.SerialPortWrapper> SPComCOntrolList2 = null;
        private CommunicationBase communication;
        //用于转发数据的UDP
        CommunicationBase m_ReTransportUdp;
        //默认分配1页内存，并始终限制不允许超过
        private List<byte> buffer = new List<byte>(4096);
        private List<List<byte>> bufferList = new List<List<byte>>();
        //AGV交通管制命令：10字节
        byte[] buf_traffic = { 0x10, 0x61, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x71, 0x03 };
        //扩容版管制命令：40字节
        byte[] buf_trafficctl = { 0x10, 0x61, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

        byte[] buf_trafficct2 = { 0x10, 0x61, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03 };
        //2019新版 160台车 24字节
        byte[] buf_trafficct3 = { 0x10, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                  0x00, 0x00, 0x73, 0x03 };
        //2019新版 160台车 24字节
        byte[] buf_trafficct33 = { 0x10, 0x63, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
                                  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
                                  0xFF, 0xFF, 0x73, 0x03 };
        //返回交通管制信号
        byte[] buf_rettraffic = { 0x10, 0x62, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x72, 0x03 };
        //返回交通管制信号 19字节
        byte[] buf_rettraffic2 = { 0x10, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03};


        List<byte[]> buf_rettrafficList = new List<byte[]>();
        //AGV运行控制
        byte[] buf_runctl = { 0x10, 0x71, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x30, 0x03 };
        //返回AGV运行控制
        byte[] buf_retrun = { 0x10, 0x72, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x30, 0x03 };
        //虚拟交通管制命令(用于判断是否断线，未接收到数据时虚拟发送数据，使agv状态断线)
        byte[] buf_virtualtrafficctl = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
        //接收数据计数器，用于断线后自动更新数据
        byte[] data_total;
        public int iReceivedNum = 0;//接收数据的次数
        public int iLastReceivedNum = 0;
        private string str1061 = "", str1063 = "";
        public Int64 SendD1D2 = 0L;//初试状态运行
        public byte[] FlagArry;
        DispatchSystem7515 ds;
        public int IsSendCtrl = 0;
        public int CtrlWaitNum = 0;
        public bool webOrderFlag = false;//web服务任务标志
        public const int offsetNo = 25;
        object lockObject = new object();//管制函数调用互斥锁
        object checkLock = new object();//读卡检测函数调用互斥锁
        int BatteryCode = 2;
        #endregion

        #region 数据库定义
        public static DAL.ZSql TrafficPara = new DAL.ZSql();

        public static ExcelDataBase excelDataBase = null;

        #endregion

        public CheckCardUnit[] chechCardUnits;//读卡检测单元
        public CheckCardSystem checkSystem;//读卡检测系统
        public BatteryData[] batteryDatas;

        #region 动画定义
        public AGV_DisMember[] DisMember;
        public AGVStatus_TypStr[] AGVStatus;
        System.Windows.Shapes.Path[] Dottedline;
        System.Windows.Controls.Label[] dislable;
        Ellipse[] startellipse;
        Ellipse[] endellipse;
        //定时器定时刷新界面
        DispatcherTimer t = new DispatcherTimer();
        DispatcherTimer DataTimer = new DispatcherTimer();
        DispatcherTimer BatteryTimer = new DispatcherTimer();
        DispatcherTimer SendTimer = new DispatcherTimer();
        DispatcherTimer batteryInfoTimer = new DispatcherTimer();//电池信息获取定时器
        public ObservableCollection<AGV_DisMember> memberData = new ObservableCollection<AGV_DisMember>();
        public ObservableCollection<AgvMember> member = new ObservableCollection<AgvMember>();
        public ObservableCollection<TrafficAreaModel> TrafficMember = new ObservableCollection<TrafficAreaModel>();
        public List<AgvStatusTimeSpan> useRateTimeList = new List<AgvStatusTimeSpan>();
        SocketClient socketclient = null;
        Storyboard[] myLineStoryboard;
        //AGV编号报警闪烁动画
        DoubleAnimationUsingKeyFrames CarWarnningAnimation;
        //箭头移动动画
        MatrixAnimationUsingPath[] matrixAnimation;
        DoubleAnimationUsingPath[] animationX;
        DoubleAnimationUsingPath[] animationY;
        DoubleAnimationUsingPath[] animationAngle;
        Image[] animatedImage;
        #endregion

        #region 系统定义
        public bool IsOpenSystem = false;
        private bool disposed;
        #endregion
        #endregion

        #region 窗体创建与销毁

        /// <summary>
        /// 服务主机对象
        /// </summary>
        System.ServiceModel.ServiceHost host;
        public static MainWindow mainWindow = null;
        Traffic traffic;
        //DataAnalysis dataControl;//数据解析对象
        //DataHandler dataHandler;
        AGVInfoService agvser;
        int SendIndex = 1;//当前要共享的AGV编号

        public MainWindow()
        {
            agvser = new AGVInfoService();
            agvser.InitTraffic();
            NameScope.SetNameScope(this, new NameScope());
            InitializeComponent();
            //dataControl = new DataAnalysis();
            //dataHandler = new DataHandler();
            //dataControl.AnalysisCompletedEvent += new DataAnalysis.AnalysisCompletedHandler(dataControl_AnalysisCompletedEvent);
            mainWindow = this;
            //变量初始化
            //AgvStatusList = new AgvStatus[AGVNUM_MAX];
            batteryDatas = new BatteryData[AGVNUM_MAX];
            AGVStatus = new AGVStatus_TypStr[AGVNUM_MAX];
            for (int i = 1; i <= AGVNUM_MAX; i++)
            {
                //GlobalPara.WakeUpAGVNumList.Add(i);
                //GlobalPara.SleepAGVNumList.Add(i);
            }
            AgvTrafficManager = new TrafficManager();
            Dottedline = new System.Windows.Shapes.Path[AGVNUM_MAX];
            startellipse = new Ellipse[AGVNUM_MAX];
            endellipse = new Ellipse[AGVNUM_MAX];
            dislable = new System.Windows.Controls.Label[AGVNUM_MAX];
            DisMember = new AGV_DisMember[AGVNUM_MAX];
            myLineStoryboard = new Storyboard[AGVNUM_MAX];
            matrixAnimation = new MatrixAnimationUsingPath[AGVNUM_MAX]; ;
            animationX = new DoubleAnimationUsingPath[AGVNUM_MAX];
            animationY = new DoubleAnimationUsingPath[AGVNUM_MAX];
            animationAngle = new DoubleAnimationUsingPath[AGVNUM_MAX];
            CarWarnningAnimation = new DoubleAnimationUsingKeyFrames();
            data_total = new byte[AGVNUM_MAX];
            animatedImage = new Image[AGVNUM_MAX];
            //GlobalPara.Gcontrolcomname = ConfigurationManager.AppSettings["ControlCOMName"];
            InitComConfig();
            btn_OpenSystem.IsEnabled = true;
            btn_CloseSystem.IsEnabled = false;
            //casunService = new CasunWebService();
            InitLastReadMark();
            FlagArry = new byte[37];
            str1061 = UdpCommunication.ByteToHexString(buf_traffic);
            str1063 = UdpCommunication.ByteToHexString(buf_trafficct3);
            InitBuffer();//缓存区初始化
            if ((GlobalPara.type == 0 && SPComCOntrolList == null) || (GlobalPara.type == 1 && communication == null))
            {
                COMInit();
                if (GlobalPara.type == 1)
                {
                    if (!communication.IsOpen)
                    {
                        communication.Open();
                        //communication.SendData(buf_trafficctl, null);
                        for (int i = 0; i < 5; i++)
                        {
                            communication.SendData(buf_trafficct3, null);
                            Thread.Sleep(20);
                        }
                        Thread.Sleep(500);
                        for (int i = 0; i < 5; i++)
                        {
                            SendTrafficOrder160();
                            Thread.Sleep(20);
                        }
                    }
                }
            }
            //trafficAgv = new List<byte>();
            //traffic = new Traffic(AGVStatus);
            //Thread thread = new Thread(new ThreadStart(traffic.CheckStatus));
            //thread.Start();
            //Thread GetTrafficAgvThread = new Thread(new ThreadStart(getTrafficAgvServer));
            //GetTrafficAgvThread.Start();

        }
        /// <summary>
        /// 初始化最后读卡记录
        /// </summary>
        void InitLastReadMark()
        {
            if (File.Exists(@"Exception\AGV最后读卡记录.txt"))
            {
                GlobalPara.lastReadMarkList = File.ReadAllLines(@"Exception\AGV最后读卡记录.txt").ToList();
            }
        }
        void DrvWlConInit()
        {
            for (int i = 0; i < AGVNUM_MAX; i++)
            {
                AGVStatus[i].WlLink = false;
                AGVStatus[i].AgvNum = Convert.ToByte(i + 1);
                AGVStatus[i].WorkLine = 0;
                AGVStatus[i].MarkNum = 0;
                AGVStatus[i].MarkFunction = 0;
                AGVStatus[i].TrafficNum = 0;
                AGVStatus[i].Status = 0;
                AGVStatus[i].LineNum = 0;
                AGVStatus[i].Speed = 0;
                AGVStatus[i].DockNum = 0;
            }

        }

        /// <summary>
        /// 多串口配置初始化
        /// </summary>
        public void InitComConfig()
        {
            //加载串口列表，先取键名，再将键名排序，最后得到键值
            List<string> keyNameList = new List<string>();
            foreach (string key in ConfigurationManager.AppSettings.AllKeys)
            {
                if (Regex.IsMatch(key, @"^ControlCOMName[1-9][0-9]*$"))
                    keyNameList.Add(key);
            }
            keyNameList.Sort();
            for (int i = 0; i < keyNameList.Count; i++)
            {
                GlobalPara.ComNameList.Add(ConfigurationManager.AppSettings[keyNameList[i]]);
            }
            for (int i = 0; i < GlobalPara.ComNameList.Count; i++)
            {
                List<byte> buffer = new List<byte>(4096);//动态申请缓冲，一个串口对应一个

                bufferList.Add(buffer);
                byte[] returnFrame = { 0x10, 0x62, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x72, 0x03 };//返回的帧数据
                buf_rettrafficList.Add(returnFrame);
            }


        }

        /// <summary>
        /// 检测单元初始化
        /// </summary>
        public void CheckUnitInit()
        {

            excelDataBase = new ExcelDataBase(GlobalPara.excelFile);
            checkSystem = new CheckCardSystem();
            checkSystem.MissReadEvent += new CheckCardSystem.MissReadEventHandler(checkSystem_MissReadEvent);
            chechCardUnits = new CheckCardUnit[AGVNUM_MAX];//根据AGV数量加入检测单元
            //for (int i = 0; i < AGVNUM_MAX;i++ )
            //{
            //    chechCardUnits[i] = new CheckCardUnit(AgvStatusList[i].AgvNum, AgvStatusList[i].WorkLine, excelDataBase);
            //    chechCardUnits[i].AgvNum = i + 1;
            //    checkSystem.Add(chechCardUnits[i]);
            //}

        }

        /// <summary>
        /// 检测是否漏读
        /// </summary>
        /// <param name="o"></param>
        /// <param name="e"></param>
        void checkSystem_MissReadEvent(object o, MissReadEventArgs e)
        {
            if (e.info == "漏读")
                Console.WriteLine(string.Format("漏读AGV{0},漏读路线{1},漏读站点{2}", e.agvNum, e.route, e.stationNum));
            else if (e.info == "多读")
                Console.WriteLine(string.Format("AGV{0},路线{1}多读卡", e.agvNum, e.route));
        }

        /// <summary>
        /// Execute startup tasks
        /// </summary>
        /// <param name="sender">object sending the event</param>
        /// <param name="e">event arguments</param>
        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            RegisterDeviceNotification();//注册加密锁事件插拨通知 //hwh 2016-9-20 修改
            MenuBarInit();//菜单栏初始化
            StatusBarInit();//状态栏初始化
            UpdateImage2Database();//更新或加载图片到数据库
            MapInit(@"Image\background.png");//地图初始化
            DrvWlConInit();
            ControlAreaInit();//控制面板初始化
            CustomInit();//自定义参数获取初始化
            //DrvWlConInit();//交通管制区初始化
            Line_Init();//显示直线初始化
            StoryboardInit();//故事板初始化，需在Line_Init();后面

            AGVGridInit(AGVNUM_MAX);//界面表格初始化
            AGVJoinMapInit();//AGV车辆导航标示和编号加入到地图中
            TrafficGridInit();
            LoadConfig();

            if (GlobalPara.IsEnableReadCheck)
            {
                //CheckUnitInit();//检测单元初化   
            }
            if (GlobalPara.IsEnableRemote)//启用了远程服务才初始化
            {
                RemoteServiceInit();
            }
            if (GlobalPara.IsEnableDataShare)
            {
                socketclient = new SocketClient(GlobalPara.TryIP, Convert.ToInt32(GlobalPara.LocalTcpPort1));
            }
            //WcfServiceInit();//服务初始化
            LoadPlugins();

            Thread.Sleep(500);//延时2秒后开启系统

            //this.btn_OpenSystem_Click(sender, e);
        }

        Server remoteServer;

        //CasunWebService casunService;

        void RemoteServiceInit()
        {
            try
            {

                remoteServer = new Server();
                remoteServer.Open(GlobalPara.TryIP, GlobalPara.LocalTcpPort);
            }
            catch (System.Exception ex)
            {

                MessageBox.Show(ex.Message + " 416");
            }
        }

        void WcfServiceInit()
        {
            if (host == null || host.State == CommunicationState.Closed)
            {
                host = new System.ServiceModel.ServiceHost(typeof(AgvAlarmServiceLibrary.AgvAlarmService));

                NetTcpBinding binding = new NetTcpBinding(SecurityMode.None);
                string address = string.Format(@"net.tcp://{0}:10000/AgvAlarmService", GlobalPara.WcfServerIP);
                host.AddServiceEndpoint(typeof(AgvAlarmServiceLibrary.IAgvAlarmService), binding, address);
                if (host.Description.Behaviors.Find<System.ServiceModel.Description.ServiceMetadataBehavior>() == null)
                {
                    ServiceMetadataBehavior behavior = new ServiceMetadataBehavior();
                    behavior.HttpGetEnabled = true;
                    string httpAddress = string.Format(@"http://{0}:10001/AgvAlarmService", GlobalPara.WcfServerIP);
                    behavior.HttpGetUrl = new Uri(httpAddress);

                    host.Description.Behaviors.Add(behavior);
                }

            }
        }
        /// <summary>
        /// Execute shutdown tasks
        /// </summary>
        /// <param name="sender">Object sending the event</param>
        /// <param name="e">Event arguments</param>
        private void Window_Closing(object sender, CancelEventArgs e)
        {
            // Stop timer
            if (null != this.t)
            {
                this.t.Stop();
                this.t.Tick -= this.t_Tick;
            }

            // Stop timer
            if (null != this.DataTimer)
            {
                this.DataTimer.Stop();
                this.DataTimer.Tick -= this.SendDataTimerTick;
            }
            if (batteryInfoTimer != null)
            {
                batteryInfoTimer.Stop();
                batteryInfoTimer.Tick -= batteryInfoTimer_Tick;
            }
            if (SendTimer != null)
            {
                SendTimer.Stop();
                SendTimer.Tick -= SendTimer_Tick;
            }
            if (BatteryTimer != null)
            {
                BatteryTimer.Stop();
                BatteryTimer.Tick -= BatteryTimer_Tick;
            }
            // Stop Com,Unregister SPComControl data received event
            if (null != SPComCOntrolList)
            {
                for (int i = 0; i < SPComCOntrolList.Count; i++)
                {
                    if (SPComCOntrolList[i] != null)
                    {
                        this.SPComCOntrolList[i].Close();
                        this.SPComCOntrolList[i].OnDataReceived -= this.SPComControl_OnDataReceived;
                    }
                }
            }

            if (communication != null)
            {
                communication.Close();
            }
            if (remoteServer != null)
            {
                remoteServer.Close();
            }
            if (m_ReTransportUdp != null)
            {
                m_ReTransportUdp.Close();
            }
            //if (dataControl != null)
            //{
            //    dataControl.Dispose();
            //}
            //clear collection
            if (null != memberData)
            {
                memberData.Clear();
                memberData = null;
            }

            if (host != null)
            {
                if (host.State == CommunicationState.Opened)
                {
                    if (AgvAlarmServiceLibrary.AgvAlarmService.userCallBackList != null)
                    {
                        foreach (AgvAlarmServiceLibrary.ISrvToClientCallBack callback in AgvAlarmServiceLibrary.AgvAlarmService.userCallBackList)
                        {
                            callback.NotifyClient("服务端已下线");
                        }
                    }
                    host.Close();
                }
            }
            XmlSerializer serializer2 = new XmlSerializer(GlobalPara.gs_configInfo.GetType());
            using (TextWriter tw = new StreamWriter("CConfig.xml"))
            {
                serializer2.Serialize(tw, GlobalPara.gs_configInfo);
            }

            //Application.Current.Shutdown();//关闭程序
            Process.GetCurrentProcess().Kill();
        }

        /// <summary>
        /// Finalizes an instance of the MainWindow class.
        /// This destructor will run only if the Dispose method does not get called.
        /// </summary>
        ~MainWindow()
        {
            this.Dispose(false);
        }

        /// <summary>
        /// Dispose resources
        /// </summary>
        public void Dispose()
        {
            this.Dispose(true);

            // This object will be cleaned up by the Dispose method.
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Frees all memory associated with the FusionImageFrame.
        /// </summary>
        /// <param name="disposing">Whether the function was called from Dispose.</param>
        protected virtual void Dispose(bool disposing)
        {
            if (!this.disposed)
            {
                if (disposing)
                {
                    if (null != this.SPComCOntrolList)
                    {
                        for (int i = 0; i < SPComCOntrolList.Count; i++)
                        {
                            if (SPComCOntrolList[i] != null)
                                this.SPComCOntrolList[i].Dispose();
                        }
                    }
                    if (null != TrafficPara)
                    {
                        TrafficPara.Dispose();
                    }
                    if (communication != null)
                    {
                        communication.Dispose();
                    }
                }
            }

            this.disposed = true;
        }
        #endregion

        #region 初始化
        /// <summary>
        /// 状态栏初始化设置
        /// </summary>
        private void StatusBarInit()
        {
            LaunchTimer();//状态栏本地系统时间
            lblusername.Content = GlobalPara.strName;//状态栏用户名
        }

        /// <summary>
        /// 菜单栏权限设置初始化
        /// </summary>
        private void MenuBarInit()
        {
            MenuAGVManager.IsEnabled = GlobalPara.IsManager;
            MenuSettings.IsEnabled = GlobalPara.IsManager;
            MenuSystemManage.IsEnabled = GlobalPara.IsManager;
        }

        /// <summary>
        /// AGV车辆导航标示和编号加入到地图中
        /// </summary>
        private void AGVJoinMapInit()
        {
            for (int i = 0; i < dislable.Length; i++)
            {
                //canvas.Children.Add(dislable[i]);
                //实际宽度和显示宽度可能不一样
                Canvas.SetTop(dislable[i], -this.dislable[i].ActualHeight);
                Canvas.SetLeft(dislable[i], -this.dislable[i].ActualHeight / 2);
                this.dislable[i].RenderTransformOrigin = new Point(0.5, 0.5);

                Canvas.SetTop(animatedImage[i], -this.animatedImage[i].ActualHeight / 2);
                Canvas.SetLeft(animatedImage[i], -this.animatedImage[i].ActualWidth / 2);
                this.animatedImage[i].RenderTransformOrigin = new Point(0.5, 0.5);
            }
        }

        /// <summary>
        /// 定时器初始化
        /// </summary>
        private void TimerInit()
        {
            //界面UI层的定时器
            //--------------------------------------------------------------------
            //定时器定时刷新界面
            t.Interval = TimeSpan.FromMilliseconds(500);//设置执行间隔单位ms毫秒
            t.Tick += new EventHandler(t_Tick);//t_Tick是要执行的函数
            //---------------------------------------------------------------------

            //数据采集层的定时器
            //-------------------------------------------------------------------
            //PC与串口扩展板每次通信周期550+其他ms
            DataTimer.Interval = TimeSpan.FromMilliseconds(GlobalPara.ComCycle);
            //DataTimer.Interval = TimeSpan.FromMilliseconds(750);
            DataTimer.Tick += new EventHandler(this.SendDataTimerTick);

            SendTimer.Interval = TimeSpan.FromMilliseconds(200);
            SendTimer.Tick += new EventHandler(SendTimer_Tick);
            SendTimer.IsEnabled = true;

            BatteryTimer.Interval = TimeSpan.FromMilliseconds(2000);
            BatteryTimer.Tick += new EventHandler(BatteryTimer_Tick);
            BatteryTimer.IsEnabled = true;
        }

        void BatteryTimer_Tick(object sender, EventArgs e)
        {
            if (BatteryCode == 2)
            {
                BatteryCode = 3;
            }
            else if (BatteryCode == 3)
            {
                BatteryCode = 2;
            }
            SendTrafficOrder160(BatteryCode);
        }

        void SendTimer_Tick(object sender, EventArgs e)
        {
            //throw new NotImplementedException();
            try
            {
                lock (GlobalPara.SendBytesList)
                {
                    while (GlobalPara.SendBytesList.Count > 0)
                    {
                        byte[] bytes = GlobalPara.SendBytesList[0];
                        if (GlobalPara.type == 0)
                        {
                            //SPComControl.Write(buf_runctl, 0, buf_runctl.Length);
                            for (int i = 0; i < SPComCOntrolList.Count; i++)
                            {
                                {
                                    SPComCOntrolList[i].Write(bytes, 0, bytes.Length);
                                }
                            }
                        }
                        else if (GlobalPara.type == 1)
                        {
                            communication.SendData(bytes, null);
                        }
                        if (GlobalPara.SendBytesList.Contains(bytes))
                        {
                            GlobalPara.SendBytesList.Remove(bytes);
                        }
                        Thread.Sleep(100);
                    }
                }
            }
            catch (Exception)
            {

            }
        }

        /// <summary>
        /// 自定义初始化
        /// </summary>
        private void CustomInit()
        {
            DAL.ZSql sql1 = new DAL.ZSql();
            //地标功能定义
            sql1.Open("select CmdFunction from T_Custom where CustomType=1 order by CmdNum");

            if (sql1.rowcount > 0)
            {
                MarkFuncOpt = new string[sql1.rowcount];
                for (int i = 0; i < sql1.rowcount; i++)
                {
                    MarkFuncOpt[i] = sql1.Rows[i]["CmdFunction"].ToString();
                }
            }
            else
            {
                MessageBox.Show("警告：请在“自定义设置”中设置地标功能！");
            }
            //运行状态定义
            sql1.Open("select CmdFunction from T_Custom where CustomType=2 order by CmdNum");
            if (sql1.rowcount > 0)
            {
                StatusOpt = new string[sql1.rowcount];
                for (int i = 0; i < sql1.rowcount; i++)
                {
                    StatusOpt[i] = sql1.Rows[i]["CmdFunction"].ToString();
                }
            }
            else
            {
                MessageBox.Show("警告：请在“自定义设置”中设置AGV运行状态！");
            }
            sql1.Close();
        }

        /// <summary>
        /// 控制面板中数据初始化
        /// </summary>
        private void ControlAreaInit()
        {
            //小车编号加载初始化
            for (int i = 0; i < AGVNUM_MAX; i++)
            {
                cb_AgvNum.Items.Add("AGV" + (i + 1).ToString());
            }

            //线路加载初始化
            DAL.ZSql sql1 = new DAL.ZSql();
            sql1.Open("select DISTINCT LineNum from T_Line order by LineNum");
            cb_LineNum.ItemsSource = sql1.m_table.DefaultView;
            cb_LineNum.DisplayMemberPath = "LineNum";
            cb_LineNum.SelectedValuePath = "LineNum";
            cb_LineNum.SelectedValue = "0";
            //for (int i = 0; i < sql1.m_table.Rows.Count;i++ )
            //{
            //    ushort route = 0;
            //    if (ushort.TryParse(sql1.m_table.Rows[i]["LineNum"].ToString(), out route))
            //    {
            //        casunService.AddRoute(route);
            //    }
            //}
            sql1.Close();
        }

        /// <summary>
        /// 状态栏定时器
        /// </summary>
        private void LaunchTimer()
        {
            DispatcherTimer innerTimer = new DispatcherTimer(TimeSpan.FromSeconds(1.0),
                    DispatcherPriority.Loaded, new EventHandler(this.TimerTick), this.Dispatcher);
            innerTimer.Start();
        }

        /// <summary>
        ///  状态栏定时器触发函数
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void TimerTick(object sender, EventArgs e)
        {
            lblTime.Content = DateTime.Now.ToString();
            tickCount++;
            if (tickCount >= 6 * 10)
            {
                tickCount = 0;
                ClearMemory();
            }
        }
        int tickCount = 6 * 10;
        #region 内存回收
        [DllImport("kernel32.dll", EntryPoint = "SetProcessWorkingSetSize")]
        public static extern int SetProcessWorkingSetSize(IntPtr process, int minSize, int maxSize);
        /// <summary>
        /// 释放内存
        /// </summary>
        public static void ClearMemory()
        {
            GC.Collect();
            GC.WaitForPendingFinalizers();
            if (Environment.OSVersion.Platform == PlatformID.Win32NT)
            {
                SetProcessWorkingSetSize(System.Diagnostics.Process.GetCurrentProcess().Handle, -1, -1);
            }
        }
        #endregion
        /// <summary>
        /// 串口初始化
        /// </summary>
        private void COMInit()
        {
            int controlcombaudrate = int.Parse(ConfigurationManager.AppSettings["ControlCOMBaudrate"]);
            int controlcomdatabits = int.Parse(ConfigurationManager.AppSettings["ControlCOMDataBits"]);
            string controlcomstopbits = ConfigurationManager.AppSettings["ControlCOMStopBits"];
            string controlcomparity = ConfigurationManager.AppSettings["ControlCOMParity"];
            try
            {
                if (GlobalPara.type == 0)//无线模块通信
                {
                    SPComCOntrolList = new List<COM.SerialPortWrapper>();
                    for (int i = 0; i < GlobalPara.ComNameList.Count; i++)
                    {
                        COM.SerialPortWrapper port = new COM.SerialPortWrapper(GlobalPara.ComNameList[i], controlcombaudrate, controlcomparity, controlcomdatabits, controlcomstopbits);
                        port.OnDataReceived += new SerialDataReceivedEventHandler(SPComControl_OnDataReceived);
                        port.ReceivedBytesThreshold = buf_rettraffic.Length;
                        SPComCOntrolList.Add(port);
                    }
                }
                else if (GlobalPara.type == 1)//网络通信
                {
                    communication = new UdpCommunication(GlobalPara.HostIP, GlobalPara.UdpComPort, 10);
                    GlobalPara.communication = communication;
                    communication.ReceivedEvent += new CommunicationBase.ReceivedEventHandler(communication_ReceivedEvent);
                    SPComCOntrolList = new List<COM.SerialPortWrapper>(); SPComCOntrolList2 = new List<COM.SerialPortWrapper>();
                    for (int i = 0; i < GlobalPara.ComNameList.Count; i++)
                    {
                        COM.SerialPortWrapper port = new COM.SerialPortWrapper(GlobalPara.ComNameList[i], controlcombaudrate, controlcomparity, controlcomdatabits, controlcomstopbits);
                        port.OnDataReceived += new SerialDataReceivedEventHandler(SPComControl_OnDataReceived);
                        port.ReceivedBytesThreshold = buf_rettraffic.Length;
                        SPComCOntrolList.Add(port); SPComCOntrolList2.Add(port);
                    }
                }

                //转发UDP
                m_ReTransportUdp = new UdpCommunication(GlobalPara.TryIP, GlobalPara.RetransportUdpPort, 10);

            }
            catch (System.Exception ex)
            {
                MessageBox.Show("新建通信实例失败！");
                return;
            }
        }

        bool IsExistDataTable(string tableName)
        {
            string strCon = ConfigurationManager.AppSettings["ConnString"];
            string str = string.Format("select count(1) from sysObjects where xtype='u' and name='{0}'", tableName);
            try
            {
                using (SqlConnection con = new SqlConnection(strCon))
                {
                    con.Open();
                    using (SqlCommand com = new SqlCommand(str, con))
                    {
                        object o = com.ExecuteScalar();
                        int num = int.Parse(o.ToString());
                        if (num > 0)
                            return true;
                        else
                            return false;
                    }
                }
            }
            catch (System.Exception ex)
            {
                throw new Exception(ex.Message);
            }

            //return false;
        }

        void CreateServiceDatabase()
        {
            if (IsExistDataTable("T_Service"))
                return;
            string strCon = ConfigurationManager.AppSettings["ConnString"];
            string str = string.Format("create table T_Service(ID bigint identity(1,1) not null,background image null,header image null)");
            try
            {
                using (SqlConnection con = new SqlConnection(strCon))
                {
                    con.Open();
                    using (SqlCommand com = new SqlCommand(str, con))
                    {
                        com.ExecuteNonQuery();
                    }
                }
            }
            catch (System.Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }

        void AddOrUpdateServiceDatabase(string tableName, object background, object header)
        {
            string strCon = ConfigurationManager.AppSettings["ConnString"];
            try
            {
                CreateServiceDatabase();
                using (SqlConnection con = new SqlConnection(strCon))
                {
                    con.Open();
                    string str = string.Format("select count(1) from {0}", tableName);
                    using (SqlCommand com = new SqlCommand(str, con))
                    {
                        object o = com.ExecuteScalar();
                        if (int.Parse(o.ToString()) > 0)//更新
                        {
                            str = string.Format("update {0} set background=@background,header=@header where ID=(select top 1 ID from {1})", tableName, tableName);
                            com.CommandText = str;
                            com.Parameters.Add("background", SqlDbType.Image);
                            com.Parameters["background"].Value = background;
                            com.Parameters.Add("header", SqlDbType.Image);
                            com.Parameters["header"].Value = header;
                            com.ExecuteNonQuery();
                        }
                        else//添加
                        {
                            str = string.Format("insert into {0}(background,header) values(@background,@header)", tableName);
                            com.CommandText = str;
                            com.Parameters.Add("background", SqlDbType.Image);
                            com.Parameters["background"].Value = background;
                            com.Parameters.Add("header", SqlDbType.Image);
                            com.Parameters["header"].Value = header;
                            com.ExecuteNonQuery();
                        }
                    }

                }
            }
            catch (System.Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }

        void UpdateImage2Database()
        {
            byte[] backgroundBuffer = new byte[1];
            byte[] headerBuffer = new byte[1];
            string backgroundFile = @"Image\background.png";
            string headerFile = @"Image\header.png";
            if (System.IO.File.Exists(backgroundFile))
            {
                System.IO.FileStream file = System.IO.File.Open(backgroundFile, System.IO.FileMode.Open, System.IO.FileAccess.Read);
                System.IO.BinaryReader reader = new System.IO.BinaryReader(file);
                backgroundBuffer = reader.ReadBytes((int)file.Length);
                reader.Close();
                file.Close();
            }
            if (System.IO.File.Exists(headerFile))
            {
                System.IO.FileStream file = System.IO.File.Open(headerFile, System.IO.FileMode.Open, System.IO.FileAccess.Read);
                System.IO.BinaryReader reader = new System.IO.BinaryReader(file);
                headerBuffer = reader.ReadBytes((int)file.Length);
                reader.Close();
                file.Close();
            }
            AddOrUpdateServiceDatabase("T_Service", backgroundBuffer, headerBuffer);

        }
        /// <summary>
        /// 加载电子地图背景图片
        /// </summary>
        /// <param name="struri">电子地图图片位置</param>
        public void MapInit(string struri)
        {
            ImageBrush imageBrush = new ImageBrush();
            imageBrush.ImageSource = new BitmapImage(new Uri(struri, UriKind.RelativeOrAbsolute));
            imageBrush.Stretch = Stretch.Uniform;
            //imageBrush.Stretch = Stretch.Fill;
            imageBrush.AlignmentX = AlignmentX.Left;
            imageBrush.AlignmentY = AlignmentY.Top;
            canvas.Background = imageBrush;
        }

        /// <summary>
        /// agv表格绑定数据初始化
        /// </summary>
        /// <param name="agvnum"></param>
        public void AGVGridInit(int agvnum)
        {
            //AgvMember agvMember = null;
            AGV_DisMember agvMember = null;
            for (int i = 0; i < agvnum; i++)
            {
                //agvMember = new AgvMember() ;
                agvMember = new AGV_DisMember();
                agvMember.txtAGVNum = "AGV" + (i + 1).ToString();
                agvMember.PropertyChanged += new PropertyChangedEventHandler(Dis_PropertyChange);
                agvMember.AgvLabel = dislable[i];
                agvMember.AgvImage = animatedImage[i];
                //member.Add(agvMember);
                memberData.Add(agvMember);

                AgvStatusTimeSpan agv = new AgvStatusTimeSpan();
                agv.AgvNum = i + 1;
                //agv.StartTime = DateTime.Now;
                useRateTimeList.Add(agv);

                agv.Insert(agv.AgvNum, agv.StartTime, 0, 0);
            }

            //dataGrid.DataContext = member;
            dataGrid.DataContext = memberData;
            //加载AGV名称设置
            SerialClass mySerial = AgvAliasWindowModel.LoadFile(AgvAliasWindowModel.configFile);
            for (int i = 0; i < AGVNUM_MAX; i++)
            {
                //member[i].txtAgvAliasValue = mySerial.dic[member[i].txtAGVNum];
                memberData[i].txtAgvAlias = mySerial.dic[memberData[i].txtAGVNum];
            }

        }

        public void TrafficGridInit()
        {
            //TrafficAreaModel traffic = new TrafficAreaModel();
            //dataGrid2.DataContext = TrafficMember;
        }

        public static BitmapImage GetImageFromFile(string filePath)
        {
            System.IO.FileStream stream = System.IO.File.Open(filePath, System.IO.FileMode.Open, System.IO.FileAccess.Read);
            byte[] buffer = new byte[stream.Length];
            stream.Read(buffer, 0, buffer.Length);
            stream.Close();
            BitmapImage bmp = new BitmapImage();
            bmp.BeginInit();
            bmp.StreamSource = new System.IO.MemoryStream(buffer);
            bmp.EndInit();
            return bmp;
        }

        /// <summary>
        /// 故事板初始化
        /// </summary>
        private void StoryboardInit()
        {
            //连线动画故事板
            for (int i = 0; i < myLineStoryboard.Length; i++)
            {
                myLineStoryboard[i] = new Storyboard();
            }

            /*
             * 闪烁的间隔秒数更改：
             * 原值：0:100，1:200；
             * 改成：0:200,1:400
             * 修改人：胡文辉
             * 修改时间：2016-12-14
             */
            //报警闪烁关键帧动画
            CarWarnningAnimation.KeyFrames.Add(new DiscreteDoubleKeyFrame(0, KeyTime.FromTimeSpan(TimeSpan.FromMilliseconds(200))));
            CarWarnningAnimation.KeyFrames.Add(new DiscreteDoubleKeyFrame(1, KeyTime.FromTimeSpan(TimeSpan.FromMilliseconds(400))));
            CarWarnningAnimation.RepeatBehavior = RepeatBehavior.Forever;

            for (int i = 0; i < animatedImage.Length; i++)
            {
                animationX[i] = new DoubleAnimationUsingPath();
                animationX[i].Source = PathAnimationSource.X;

                animationY[i] = new DoubleAnimationUsingPath();
                animationY[i].Source = PathAnimationSource.Y;

                animationAngle[i] = new DoubleAnimationUsingPath();
                animationAngle[i].Source = PathAnimationSource.Angle;

                animatedImage[i] = new Image();
                //animatedImage[i].Source = new BitmapImage(new Uri(@"Image\navigation_24.png", UriKind.RelativeOrAbsolute));
                /************************************************************************/
                /* 修改日期：2014.7.25
                 * 修改说明：实现了每辆AGV运行箭头的自定义功能，当没图片将采用默认箭头图标
                修改者：肖丁铭*/
                /************************************************************************/

                string filePath = @"Image\箭头\" + "AGV" + (i + 1).ToString() + ".png";
                if (System.IO.File.Exists(filePath))
                {
                    animatedImage[i].Source = GetImageFromFile(filePath);
                }
                else if (System.IO.File.Exists(@"Image\箭头\Default.png"))
                {
                    animatedImage[i].Source = GetImageFromFile(@"Image\箭头\Default.png");
                }
                else
                {
                    animatedImage[i].Source = new BitmapImage(new Uri(@"Image\navigation_24.png", UriKind.RelativeOrAbsolute));

                }

                animatedImage[i].Width = GlobalPara.AgvIconW;
                animatedImage[i].Height = GlobalPara.AgvIconH;
                /************************************************************************/
                /* 2014.11.26                                                                     */
                /************************************************************************/
                Canvas.SetTop(animatedImage[i], -this.animatedImage[i].ActualHeight / 2);
                Canvas.SetLeft(animatedImage[i], -this.animatedImage[i].ActualWidth / 2);
                this.animatedImage[i].RenderTransformOrigin = new Point(0.5, 0.5);
                ////
                canvas.Children.Add(animatedImage[i]);

                TranslateTransform translate = new TranslateTransform();
                RotateTransform rotate = new RotateTransform();
                TransformGroup group = new TransformGroup();
                group.Children.Add(rotate);//先旋转
                group.Children.Add(translate);//再平移
                this.animatedImage[i].RenderTransform = group;

                //文字只平移,不旋转
                TransformGroup group1 = new TransformGroup();
                group1.Children.Add(translate);//平移
                this.dislable[i].RenderTransform = group1;

                this.RegisterName("translate" + (i + 1).ToString(), translate);
                this.RegisterName("rotate" + (i + 1).ToString(), rotate);
                Storyboard.SetTargetName(animationX[i], "translate" + (i + 1).ToString());
                Storyboard.SetTargetName(animationY[i], "translate" + (i + 1).ToString());
                Storyboard.SetTargetName(animationAngle[i], "rotate" + (i + 1).ToString());
                Storyboard.SetTargetProperty(animationX[i], new PropertyPath(TranslateTransform.XProperty));
                Storyboard.SetTargetProperty(animationY[i], new PropertyPath(TranslateTransform.YProperty));
                Storyboard.SetTargetProperty(animationAngle[i], new PropertyPath(RotateTransform.AngleProperty));
            }
        }

        /// <summary>
        /// 小车线路连线初始化
        /// </summary>
        private void Line_Init()
        {
            //AGV编号标签
            for (int i = 0; i < dislable.Length; i++)
            {
                dislable[i] = new System.Windows.Controls.Label();
                //dislable[i].Content = "AGV" + (i + 1).ToString();
                dislable[i].Content = (i + 1).ToString();
                dislable[i].Height = 30;
                //dislable[i].Width = 160;
                dislable[i].FontSize = 12;
                dislable[i].Foreground = Brushes.PaleVioletRed;
                dislable[i].FontWeight = FontWeights.UltraBold;
            }

            //连接虚线
            for (int i = 0; i < Dottedline.Length; i++)
            {
                Dottedline[i] = new System.Windows.Shapes.Path();
                Dottedline[i].StrokeThickness = 2;
                Dottedline[i].Stroke = Brushes.GreenYellow;
                DoubleCollection dc = new DoubleCollection();
                dc.Add(5);
                Dottedline[i].StrokeDashArray = dc;
            }

            //运行段起终点
            for (int i = 0; i < startellipse.Length; i++)
            {
                startellipse[i] = new Ellipse();
                endellipse[i] = new Ellipse();
                startellipse[i].Height = 10;
                startellipse[i].Width = 10;
                endellipse[i].Height = 10;
                endellipse[i].Width = 10;
            }
        }

        //AGVInfoService agvService = null;
        /// <summary>
        /// 缓存区初始化
        /// </summary>
        private void InitBuffer()
        {
            AGVInfoService agvService = new AGVInfoService();
            TrafficAreaService traffic = new TrafficAreaService();
            #region 初始化缓存区，存放AGV运行数据和管制区数据
            agvService.InitAgvBuffer();
            traffic.InitTrafficBuffer();
            //traffic.InitTrafficMarkBuffer();
            #endregion
        }

        #endregion

        public void PostPelletIdStatus(StationInfo infos, string ApiAdress)
        {
            string address = "http://10.197.244.100:10057";

            string url = address + ApiAdress;
            string id = DateTime.Now.ToString("yyyyMMddhhmmssffff");
            string s = $"123 {id}";

            AGVInfo info = GetStationInfo(infos.Mark);

            if (info.AgvCode != 0)
            {
                info.stationName = infos.StationName;
                info.Time = DateTime.Now;


                bool res = WcsApi.Post(url, null, info, out string data, out string msg);
                string str = $"离港上报：{res}，信息：{msg}，数据：{data}";

                string Responses = $"离港AGV信息：工站名={info.stationName},mark ={infos.Mark}, AGVID = {info.AgvCode}，ProductCode = {info.ProductCode}，HolderBarCode = {info.HolderBarCode}，ProductType = {info.ProductType},返回时间 = {DateTime.Now.ToString()}";//，产品个数 = {products.Count}


                WriteFile("离港上报-" + DateTime.Now.ToString("yyyy-MM-dd"), Responses);
            }
            string Responses1 = $"离港记录：工站名={info.stationName},mark ={infos.Mark}, AGVID = {info.AgvCode}，ProductCode = {info.ProductCode}，HolderBarCode = {info.HolderBarCode}，ProductType = {info.ProductType},返回时间 = {DateTime.Now.ToString()}";//，产品个数 = {products.Count}

            WriteFile("MES工位点记录-" + DateTime.Now.ToString("yyyy-MM-dd"), Responses1);


        }
        private static object portLock = new object();

        void WriteFile(string fileName, string context)
        {
            try
            {
                lock (portLock)
                {
                    DateTime time = DateTime.Now;
                    //MessageBox.Show("线程异常:"+e.ExceptionObject);
                    FileStream stream = File.Open(@"Exception\" + fileName + ".txt", FileMode.Append, FileAccess.Write);
                    StreamWriter writer = new StreamWriter(stream);


                    {
                        string msg = string.Format("[{0}]Test:\r\nMessage:{1}\r\n", time.ToString("yyyy-MM-dd HH:mm:ss"), context);
                        writer.WriteLine(msg);
                        writer.Close();
                        stream.Close();
                    }
                }
            }
            catch (Exception)
            {
            }
        }


        PLCSqlDLL PLCSql = new PLCSqlDLL();

        public AGVInfo GetStationInfo(string statiom)
        {
            string mark = "";
            AGVInfo Agvinfo = new AGVInfo();

            try
            {

                {
                    List<AGVInfoModel> listModel = GlobalPara.AgvInfoDic.Values.ToList();

                    List<AGVInfoModel> temp4 = listModel.FindAll(o => (o.MARKNUM.ToString() == statiom && o.ConnectStatus == true && o.AGVNUM != 0));
                    if (temp4 != null && temp4.Count() > 0)
                    {
                        List<AGVInfoModel> infos = temp4.ToList();
                        infos = infos.OrderByDescending(o => o.LastModifyMarkTime).ToList();

                        AGVInfoModel info = infos[0];

                        if (info != null && info.IsOutFlag)
                        {
                            PLCSql.PLCMESSelect(info.AGVNUM.ToString(), "2", ref Agvinfo);
                          // DispatcherTool.ReleaseAgvOnStop(info.MARKNUM, 0);
                            info.IsReachFlag = false;
                            info.IsOutFlag = false;
                        }

                    }

                    //    List<AGVInfoModel> results = listModel.FindAll(o => o.MARKNUM.ToString() == statiom && o.ConnectStatus == true); //停止点有车

                }// 
            }
            catch (Exception ex)
            {

            }

            return Agvinfo;

        }
        public void LoadConfig()
        {
            string currPath = System.AppDomain.CurrentDomain.BaseDirectory;
            string dataPath = currPath + @"data";
            string dataFile = dataPath + @"\对接配置表.xls";
            try
            {

                string confStr1 = @"Provider=Microsoft.ACE.OLEDB.12.0;";
                string confStr2 = @"Persist Security Info=false;";
                string confStr3 = @"Data Source=" + dataFile + ";";
                string confStr4 = @"Extended Properties=" + "'Excel 12.0;HDR=YES;IMEX=1'";
                string connStr = confStr1 + confStr2 + confStr3 + confStr4;

                OleDbConnection oleDC = new OleDbConnection(connStr);
                OleDbDataAdapter oleDDA1 = new OleDbDataAdapter("Select * From [参数设置$]", oleDC);
                oleDDA1.Fill(GlobalPara.DtWirelessBox);

                if (!Directory.Exists("D:/Logs/对接盒记录"))
                {
                    Directory.CreateDirectory("D:/Logs/对接盒记录");
                }
                GlobalPara.logNetDateTimeTrans = new HslCommunication.LogNet.LogNetDateTime("D:/Logs/对接盒记录", HslCommunication.LogNet.GenerateMode.ByEveryDay);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.StackTrace);
            }
        }
        public void PLCFlag()
        {


        }

        #region 事件委托触发更新
        Dictionary<int, byte[]> ReceiveDataDic = new Dictionary<int, byte[]>();
        List<byte> tempbuffer = new List<byte>();
        List<string> EmergencyList = new List<string> { "38","39","44"};
        /// <summary>
        /// 串口类SerialPortWrapper的数据接收触发委托函数
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void SPComControl_OnDataReceived(object sender, SerialDataReceivedEventArgs e)
        {

            try
            {
                SerialPort port = sender as SerialPort;
                AGVInfoService agvService = new AGVInfoService();

                int index = SPComCOntrolList.FindIndex(c => c.portname == port.PortName);


                // int index1 = SPComCOntrolList.FindIndex(a=>a.portname==port.PortName);
                if (index != -1)
                {
                    int n = SPComCOntrolList[index].BytesToRead;
                    byte[] RecBuffer = new byte[n];//缓存接收到的数据
                    SPComCOntrolList[index].Read(RecBuffer, 0, n);
                    // bool flag;

                    

                    if (RecBuffer[0] == 0xAA)
                    {
                        string Mark = RecBuffer[7].ToString();

                        ControlAGVStop(Mark, RecBuffer[2]);

                    } //急停控制
                    else
                    {
                        string Mark = RecBuffer[DispatcherTool.COM_MARK + 1].ToString();

                        List<AGVInfoModel> listModel = GlobalPara.AgvInfoDic.Values.ToList();
                        if (RecBuffer[1] == 0x37)
                        {
                            {
                                if (GlobalPara.plcs.Count > 0)
                                {
                                    List<DataRow> list = GlobalPara.plcs.Keys.ToList();
                                    DataRow dr = list.Find(o => o["工位地标"].ToString() == Mark);
                                    if (dr != null && GlobalPara.plcs.ContainsKey(dr))
                                    {
                                        if (dr.Table.Columns.Contains("请求出门DB")&&!string.IsNullOrEmpty(dr["请求出门DB"].ToString()))
                                        {
                                            GlobalPara.plcs[dr].Write(dr["请求出门DB"].ToString(), true);

                                            return;
                                        }
                                    }
                                }
                            }
                        }

                        if (Mark != "36")
                        {
                            List<AGVInfoModel> results = listModel.FindAll(o => o.MARKNUM.ToString() == Mark && o.ConnectStatus == true && (o.RUNSTATUS_Cur == 0x41|| o.RUNSTATUS_Cur == 0x44)); //停止点有车
                            if (results != null && results.Count > 0)
                            {
                                foreach (AGVInfoModel info in results)
                                {
                                    if (info != null)
                                    {
                                        if (info.EmergencyCar == false && EmergencyList.Contains(info.MARKNUM.ToString()))
                                        {
                                            WriteFile("线束记录" + DateTime.Now.ToString("yyyy-MM-dd"), "AGVID+" + info.AGVNUM + " 线束信号为：+" + info.EmergencyCar + "无法放行，Mark:+" + info.MARKNUM.ToString() + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                                        }
                                        else
                                        {
                                            WriteFile("线束记录" + DateTime.Now.ToString("yyyy-MM-dd"), "AGVID+" + info.AGVNUM + " 线束信号为：+" + info.EmergencyCar + "正常放行 ， Mark:+" + info.MARKNUM.ToString() + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));

                                            communication.SendData(RecBuffer, null);

                                            if (RecBuffer[1] == 0x37)
                                            {
                                                if (!GlobalPara.ReleaseMarkList.Contains(Mark))
                                                {
                                                    GlobalPara.ReleaseMarkList.Add(Mark);
                                                    WriteFile("点灭放行盒记录" + DateTime.Now.ToString("yyyy-MM-dd"), "工位放行成功，等待点灭，当前放行地标:" + info.MARKNUM + ",车号为:" + info.AGVNUM);
                                                }
                                            }
                                        }

                                    }
                                }
                            }
                        }
                        else  //同一放行盒放两个地标
                        {

                            List<AGVInfoModel> results = listModel.FindAll(o => o.MARKNUM.ToString() == "63" && o.ConnectStatus == true && (o.RUNSTATUS_Cur == 0x41 || o.RUNSTATUS_Cur == 0x44)); //停止点有车
                            if (results != null && results.Count > 0)
                            {

                                RecBuffer[DispatcherTool.COM_MARK + 1] = 0x3F;
                                string Mark2 = RecBuffer[DispatcherTool.COM_MARK + 1].ToString();
                                RecBuffer[DispatcherTool.COM_CHECK] = DispatcherTool.XOR_Check(RecBuffer, 12); //校验

                                WriteFile("63判断放行记录-" + DateTime.Now.ToString("yyyy-MM-dd"), "小车放行记录2:" + Mark2);
                            }



                            communication.SendData(RecBuffer, null);

                            if (RecBuffer[1] == 0x37)
                            {
                                if (!GlobalPara.ReleaseMarkList.Contains(Mark))
                                {
                                    GlobalPara.ReleaseMarkList.Add(Mark);
                                    WriteFile("点灭放行盒记录" + DateTime.Now.ToString("yyyy-MM-dd"), "工位放行成功，等待点灭，当前放行地标:" + Mark);

                                }
                            }

                        }


                        //List<AGVInfoModel> results1 = listModel.FindAll(o => o.MARKNUM.ToString() == Mark && o.ConnectStatus == true && (o.RUNSTATUS_Cur == 0x40)); //运行
                        //if (results1 != null && results1.Count > 0)
                        //{
                        //    if (RecBuffer[1] == 0x37)
                        //    {
                        //        MainWindow.ReleaseStopPoint(int.Parse(Mark), 0);  //点灭放行盒
                        //    }

                        //}



                        //  MainWindow.ReleaseStopPoint(RecBuffer[DispatcherTool.COM_MARK+1], 0);  //点灭放行盒
                    }

                    // tempbuffer.RemoveAt(0);



                    //  info1.StationName = dr["工位名称"].ToString();


                    //  if (!GlobalPara.UseNewProtrol)
                    {
                        //if (GlobalPara.DataHandleType == 1)
                        //{
                        //    tempbuffer.AddRange(RecBuffer);
                        //    byte ver = 0;

                        //    #region 数据处理
                        //    while (tempbuffer.Count >= 10)
                        //    {
                        //        if (DrvWlConCheck(tempbuffer, 8, out ver))
                        //        {
                        //            #region
                        //            tempbuffer.CopyTo(0, buf_rettraffic, 0, 10);
                        //            tempbuffer.RemoveRange(0, 10);
                        //            if (UdpCommunication.ByteToHexString(buf_rettraffic) == str1061)
                        //            {
                        //                continue;
                        //            }
                        //            #region 数据转发
                        //            //if (GlobalPara.IsEnableDataShare)
                        //            {
                        //                //Action action = new Action(delegate()
                        //                //{
                        //                //    if (ShareData(tempbuffer.ToArray()).Length > 9)
                        //                //    {
                        //                //        socketclient.socket_send(ShareData(tempbuffer.ToArray()));
                        //                //    }
                        //                //});
                        //                //action.BeginInvoke(null, null);
                        //            }
                        //            #endregion
                        //            if (ReceiveDataDic.Keys.Contains(buf_rettraffic[2]))
                        //            {
                        //                int agvnum = buf_rettraffic[2];

                        //                //if (ReceiveDataDic[agvnum] != buf_rettraffic)
                        //                {
                        //                    ReceiveDataDic[agvnum] = buf_rettraffic;
                        //                    try
                        //                    {
                        //                        //DrvWlCon_AgvStatus(buf_rettraffic.ToList());
                        //                        agvser.UpdateBuffer(buf_rettraffic.ToList());
                        //                    }
                        //                    catch (System.Exception ex)
                        //                    {
                        //                        MessageBox.Show(ex.Message+" 1185");
                        //                    }
                        //                }
                        //            }
                        //            else
                        //            {
                        //                ReceiveDataDic.Add(buf_rettraffic[2], buf_rettraffic);
                        //                try
                        //                {
                        //                    agvser.UpdateBuffer(buf_rettraffic.ToList());
                        //                }
                        //                catch (System.Exception ex)
                        //                {
                        //                    MessageBox.Show(ex.Message + " 1198");
                        //                }
                        //            }
                        //            #endregion
                        //        }
                        //        else
                        //        {
                        //            tempbuffer.RemoveAt(0);

                        //        }
                        //    }
                        //    #endregion
                        //}
                        //else if (GlobalPara.DataHandleType == 0)
                        {
                            //    bufferList[index].AddRange(RecBuffer);
                            //    byte[] tempbuffer = CheckData(RecBuffer);
                            {
                                // agvService.UpdateBuffer(RecBuffer.ToList());
                            }
                        }
                    }
                    //else
                    //{
                    //    if (GlobalPara.DataHandleType == 0)
                    //    {
                    //        tempbuffer.AddRange(RecBuffer);
                    //        byte ver = 0;

                    //        #region 数据处理
                    //        while (tempbuffer.Count >= 19)
                    //        {
                    //            if (DrvWlConCheck(tempbuffer, 17, out ver))
                    //            {
                    //                #region
                    //              tempbuffer.CopyTo(0, buf_trafficct3, 0, 19);
                    //                tempbuffer.RemoveRange(0, 19);
                    //                if (UdpCommunication.ByteToHexString(buf_trafficct3) == str1063)
                    //                {
                    //                    continue;
                    //                }
                    //                #region 数据转发
                    //                #endregion
                    //                if (ReceiveDataDic.Keys.Contains(buf_trafficct3[2]))
                    //                {
                    //                    int agvnum = buf_trafficct3[2];

                    //                    //if (ReceiveDataDic[agvnum] != buf_rettraffic)
                    //                    {
                    //                        ReceiveDataDic[agvnum] = buf_trafficct3;
                    //                        try
                    //                        {
                    //                            //DrvWlCon_AgvStatus(buf_rettraffic.ToList());
                    //                            agvser.UpdateBuffer(buf_trafficct3.ToList());
                    //                        }
                    //                        catch (System.Exception ex)
                    //                        {
                    //                            MessageBox.Show(ex.Message + " 1251");
                    //                        }
                    //                    }
                    //                }
                    //                else
                    //                {
                    //                    ReceiveDataDic.Add(buf_trafficct3[2], buf_trafficct3);
                    //                    try
                    //                    {
                    //                        agvser.UpdateBuffer(buf_trafficct3.ToList());
                    //                    }
                    //                    catch (System.Exception ex)
                    //                    {
                    //                        MessageBox.Show(ex.Message + " 1264");
                    //                    }
                    //                }
                    //                #endregion
                    //            }
                    //            else
                    //            {
                    //                tempbuffer.RemoveAt(0);

                    //            }
                    //        }
                    //        #endregion
                    //    }
                    //    else if (GlobalPara.DataHandleType == 1)
                    //    {
                    //        bufferList[index].AddRange(RecBuffer);
                    //        byte[] tempbuffer = CheckData(RecBuffer);
                    //        {
                    //            agvService.UpdateBuffer(tempbuffer.ToList());
                    //        }
                    //    }
                    //}
                }
            }
            catch (Exception es)

            {


            }
            //  SPComCOntrolList[index].Dispose();
        }



        public bool ControlAGVStop(string mark, byte type)
        {
            Boolean flag = false;
            String ReleaseType = "";
            try
            {

                {
                    List<AGVInfoModel> listModel = GlobalPara.AgvInfoDic.Values.ToList();
                    List<AGVInfoModel> results = listModel.FindAll(o => o.MARKNUM.ToString() == mark && o.ConnectStatus == true); //停止点有车
                    if (results != null && results.Count > 0)
                    {
                        foreach (AGVInfoModel info in results)
                        {
                            if (info != null)
                            {
                                switch (type)
                                {
                                    case 0x50:
                                        DispatcherTool.ControlAGVBy1071(info.AGVNUM, 1); //急停
                                        ReleaseType = "小车急停";                                              //  WriteFile("工位点记录-" + dr["IP地址"].ToString() + "-" + DateTime.Now.ToString("yyyy-MM-dd"), "(放行地标：" + info.MARKNUM + ",放行路线：0" + ", " + ",车号:" + info.AGVNUM + ",急停) ");
                                        break;
                                    case 0x40:
                                        DispatcherTool.ControlAGVBy1071(info.AGVNUM, 0); //解除急停放行
                                        ReleaseType = "急停解除";
                                        break;

                                }
                                WriteFile("MES站急停小车记录", "AGVID+" + info.AGVNUM + "Type：+" + ReleaseType + " Mark:+" + info.MARKNUM.ToString() + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                                //  info.AllowReleaseFlag = true;
                                flag = true;
                            }

                        }
                    }

                }
                Thread.Sleep(500);
            }   //AGVpos为false代表未叫车 才进循环

            catch (Exception ex)
            {

            }

            return flag;

        }
        public void SendDataToServer()
        {
            while (GlobalPara.IsEnableDataShare)
            {
                if (SendIndex == GlobalPara.AgvInfoDic.Count + 1)
                {
                    SendIndex = 1;
                }
                if (GlobalPara.AgvInfoDic != null && GlobalPara.AgvInfoDic.Count > 0 && socketclient != null
                    && GlobalPara.AgvInfoDic.ContainsKey(SendIndex))
                {
                    AGVInfoModel agvinfo = GlobalPara.AgvInfoDic[SendIndex];
                    if (agvinfo.MARKNUM != 0)
                    {
                        bool runflag = true;
                        byte status = 0;
                        byte[] buf_ShareDate = { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03 };
                        byte temp = (byte)agvinfo.RUNSTATUS;
                        switch (temp)
                        {
                            case 0x40:
                                runflag = true;
                                status = 0;
                                break;
                            case 0x41:
                            //memberData[i].txtStatusValue = "暂停";
                            case 0x42:
                            //memberData[i].txtStatusValue = "结束地标停止";
                            case 0x43:
                            //memberData[i].txtStatusValue = "停止";
                            case 0x44:
                                //memberData[i].txtStatusValue = "充电中";
                                runflag = false;
                                status = 0;
                                break;
                            default:
                                runflag = true;
                                status = temp;
                                break;
                        }
                        if (status == 0)
                        {
                            if (runflag)//运行状态
                            {
                                buf_ShareDate[6] = 0x02;
                            }
                            else//停止状态
                            {
                                buf_ShareDate[6] = 0x01;
                            }
                            buf_ShareDate[9] = 0x00;
                        }
                        else//有故障
                        {
                            buf_ShareDate[6] = 0x00;
                            buf_ShareDate[9] = (byte)((temp & 0x3f) + 0x01);
                        }
                        buf_ShareDate[1] = (byte)agvinfo.AGVNUM;

                        //修改说明：地标号扩展两位，速度等级的bit8,bit7作为地标号的bit9，bit10
                        //     buf_ShareDate[2] = Convert.ToByte(buf[3] | ((buf[7] & 0xC0) << 2));//地标
                        int mark = agvinfo.MARKNUM;
                        buf_ShareDate[2] = (byte)((mark & 0xff00) >> 8);
                        buf_ShareDate[3] = (byte)(mark & 0x00ff);
                        buf_ShareDate[4] = (byte)agvinfo.ROUTENUM;//路线
                        buf_ShareDate[5] = Convert.ToByte(agvinfo.SPEEDLEVEL);//速度              

                        buf_ShareDate[7] = 0;   //电压
                        buf_ShareDate[8] = 0;   //电流

                        //buf_ShareDate[9] = 0;   //备用
                        buf_ShareDate[10] = 0;  //备用
                        buf_ShareDate[11] = 0;  //备用
                        buf_ShareDate[12] = DrvWlConGetBCC(buf_ShareDate, buf_ShareDate.Length - 2);//校验位;
                        socketclient.socket_send(buf_ShareDate);
                    }
                }
                SendIndex++;
                Thread.Sleep(100);
            }
        }

        /// <summary>
        /// TCP要转发的数据
        /// </summary>
        /// <param name="buf"></param>
        /// <returns></returns>
        public byte[] ShareData(byte[] buf)
        {
            bool runflag = true;
            byte status = 0;
            byte[] buf_ShareDate = { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03 };
            int agvnum = buf[2];
            if ((agvnum > 0) && (agvnum <= AGVNUM_MAX))
            {
                switch (buf[5])
                {
                    case 0x40:
                        runflag = true;
                        status = 0;
                        break;
                    case 0x41:
                    //memberData[i].txtStatusValue = "暂停";
                    case 0x42:
                    //memberData[i].txtStatusValue = "结束地标停止";
                    case 0x43:
                    //memberData[i].txtStatusValue = "停止";
                    case 0x44:
                        //memberData[i].txtStatusValue = "充电中";
                        runflag = false;
                        status = 0;
                        break;
                    default:
                        runflag = true;
                        status = buf[5];
                        break;
                }
            }

            if (status == 0)
            {
                if (runflag)//运行状态
                {
                    buf_ShareDate[7] = 0x02;
                }
                else//停止状态
                {
                    buf_ShareDate[7] = 0x01;
                }
                buf_ShareDate[8] = 0x00;
            }
            else//有故障
            {
                buf_ShareDate[7] = 0x00;

                buf_ShareDate[8] = (byte)((buf[5] & 0x3f) + 0x01);
            }

            buf_ShareDate[1] = buf[2];  //得到AGV编号，编号从0x01开始


            //if (DrvWlConCheck(buf, 8) == VERIFY_NOERROR)  //校验无错
            {
                //修改说明：地标号扩展两位，速度等级的bit8,bit7作为地标号的bit9，bit10
                //     buf_ShareDate[2] = Convert.ToByte(buf[3] | ((buf[7] & 0xC0) << 2));//地标
                int mark = (int)buf[3] | ((buf[7] & 0xC0) << 2);
                buf_ShareDate[2] = (byte)((mark & 0xff00) >> 8);
                buf_ShareDate[3] = (byte)(mark & 0x00ff);
                buf_ShareDate[5] = buf[6];//路线
                buf_ShareDate[6] = Convert.ToByte(buf[7] & 0x3F);//速度              

                //buf_ShareDate[7] = 0;   //电压
                //buf_ShareDate[8] = 0;   //电流

                //buf_ShareDate[9] = 0;   //备用
                buf_ShareDate[10] = 0;  //备用
                buf_ShareDate[11] = 0;  //备用
                buf_ShareDate[12] = DrvWlConGetBCC(buf_ShareDate, buf_ShareDate.Length - 2);//校验位;

                return buf_ShareDate;
            }
        }
        /// <summary>
        /// //用于管制逻辑的数据
        /// </summary>
        /// <param name="buf"></param>
        void DrvWlCon_AgvStatus(List<byte> buf)
        {
            byte AgvNum = 0, SpeedGrade = 0;
            int bMarkNum = 0;
            AgvNum = buf[2];  //得到AGV编号，编号从0x01开始            

            AGVStatus[AgvNum - 1].Wlink_Count = 0;
            //由于生产区在运行过程中不会改变，故将此放置在AGV的初始化中，不需要每次更新
            AGVStatus[AgvNum - 1].AgvNum = AgvNum;
            AGVStatus[AgvNum - 1].MarkNum = Convert.ToInt16(buf[3] | ((buf[7] & 0xC0) << 2));
            AGVStatus[AgvNum - 1].LineNum = buf[6];
            //| ((buf[8] & 0xFF) << 8)
            if (bMarkNum > 0)
            {
                //AGVStatus[AgvNum - 1].MarkNum = bMarkNum;
                //当前AGV运行速度等级，不会接收到保持现状的0
                //修改时间：2013-11-28
                //修改说明：屏蔽速度等级的bit8,bit7
                SpeedGrade = Convert.ToByte(buf[7] & 0x3F);
                if (SpeedGrade > 0 && SpeedGrade < SpeedOpt.Length)
                {
                    AGVStatus[AgvNum - 1].Speed = SpeedGrade;
                }
                //当前地标功能
                if (buf[4] > 0 && buf[4] < MarkFuncOpt.Length)
                {
                    AGVStatus[AgvNum - 1].MarkFunction = buf[4];
                }
                //当前AGV运行路线
                //AGVStatus[AgvNum - 1].LineNum = buf[6];
                //新协议增加电压电流
                if (buf.Count == 16)
                {
                    ushort uVoltage = (ushort)(buf[8] << 8 | buf[9]);
                    ushort temp = (ushort)(buf[10] << 8 | buf[11]);
                    ushort uCurrent = (ushort)(temp);

                    AGVStatus[AgvNum - 1].Voltage = uVoltage / 10.0f;
                    AGVStatus[AgvNum - 1].Current = uCurrent / 10.0f;
                }
                else
                {
                    AGVStatus[AgvNum - 1].Voltage = 0;
                    AGVStatus[AgvNum - 1].Current = 0;
                }
            }
            //当前AGV状态，由于接收到数据不是按照顺序，中间有间隔，在使用时才验证数据正确性 
            AGVStatus[AgvNum - 1].Status = (byte)(buf[5] & 0x7f);//不取最高位
            //方向,取运行状态中最高位
            AGVStatus[AgvNum - 1].Direction = (byte)((buf[5] >> 7) & 1);

            AGVStatus[AgvNum - 1].WlLink = AGVWLLINK_OK;

        }

        /// <summary>
        /// 网口类数据接收触发委托事件
        /// </summary>
        /// <param name="o"></param>
        /// <param name="e"></param>
        void communication_ReceivedEvent(object o, ReceivedEventArgs e)
        {
            try
            {
                IPEndPoint remotePoint = o as IPEndPoint;
                if (e.buffer[0] == 0x10 && e.buffer[1] == 0x37 && e.buffer.Length == 14)
                {
                    communication.SendData(e.buffer, null);
                    string str = string.Format("收到IP为{0}的盒子放行数据:{1}", remotePoint.Address.ToString(), DispatcherTool.ByteToHexString(e.buffer));
                    return;
                }
                
                if (e != null && e.buffer != null && e.buffer.Length > 10)
                {
                    if (!GlobalPara.UseNewProtrol)
                    {
                        if (GlobalPara.DataHandleType == 1)
                        {
                            buffer.AddRange(e.buffer);
                            byte ver = 0;
                            #region 数据处理
                            while (buffer.Count >= 10)
                            {
                                if (DrvWlConCheck(buffer, 8, out ver))
                                {
                                    #region
                                    byte[] tempBuffer = new byte[10];
                                    buffer.CopyTo(0, tempBuffer, 0, 10);
                                    buffer.RemoveRange(0, 10);
                                    #region 数据转发
                                    //if (GlobalPara.IsEnableDataShare)
                                    {
                                        //Action action = new Action(delegate()
                                        //{
                                        //    if (ShareData(tempbuffer.ToArray()).Length > 9)
                                        //    {
                                        //        socketclient.socket_send(ShareData(tempbuffer.ToArray()));
                                        //    }
                                        //});
                                        //action.BeginInvoke(null, null);
                                    }
                                    #endregion
                                    if (ReceiveDataDic.Keys.Contains(tempBuffer[2]))
                                    {
                                        int agvnum = tempBuffer[2];

                                        //if (ReceiveDataDic[agvnum] != buf_rettraffic)
                                        {
                                            ReceiveDataDic[agvnum] = tempBuffer;
                                            try
                                            {
                                                //DrvWlCon_AgvStatus(buf_rettraffic.ToList());
                                                agvser.UpdateBuffer(tempBuffer.ToList(),remotePoint);
                                            }
                                            catch (System.Exception ex)
                                            {
                                                MessageBox.Show(ex.Message + " 1561");
                                            }
                                        }
                                    }
                                    else
                                    {
                                        ReceiveDataDic.Add(tempBuffer[2], tempBuffer);
                                        try
                                        {
                                            agvser.UpdateBuffer(tempBuffer.ToList(),remotePoint);
                                        }
                                        catch (System.Exception ex)
                                        {
                                            MessageBox.Show(ex.Message + " 1574");
                                        }
                                    }
                                    #endregion
                                }
                                else
                                {
                                    buffer.RemoveAt(0);

                                }
                            }
                            #endregion

                        }
                        else if (GlobalPara.DataHandleType == 0)//线程中单独处理
                        {
                            //Thread t = new Thread(new ThreadStart(delegate
                            // {
                            agvService.UpdateBuffer(e.buffer.ToList(),remotePoint);
                            // }));
                            //t.IsBackground = true;
                            //t.Start();
                        }
                    }
                    else
                    {
                        if (GlobalPara.DataHandleType == 0)
                        {
                            buffer.AddRange(e.buffer);
                            #region 数据处理
                            while (buffer.Count >= 19)
                            {
                                byte ver = 0;
                                if (DrvWlConCheck(buffer, 17, out ver))
                                {
                                    #region
                                    byte[] tempBuffer = new byte[19];
                                    buffer.CopyTo(0, tempBuffer, 0, 19);
                                    buffer.RemoveRange(0, 19);
                                    #region 数据转发
                                    //if (GlobalPara.IsEnableDataShare)
                                    {
                                        //Action action = new Action(delegate()
                                        //{
                                        //    if (ShareData(tempbuffer.ToArray()).Length > 9)
                                        //    {
                                        //        socketclient.socket_send(ShareData(tempbuffer.ToArray()));
                                        //    }
                                        //});
                                        //action.BeginInvoke(null, null);
                                    }
                                    #endregion
                                    if (ReceiveDataDic.Keys.Contains(tempBuffer[2]))
                                    {
                                        int agvnum = tempBuffer[2];

                                        //if (ReceiveDataDic[agvnum] != buf_rettraffic)
                                        {
                                            ReceiveDataDic[agvnum] = tempBuffer;
                                            try
                                            {
                                                //DrvWlCon_AgvStatus(buf_rettraffic.ToList());
                                                agvser.UpdateBuffer(tempBuffer.ToList(),remotePoint);
                                            }
                                            catch (System.Exception ex)
                                            {
                                                MessageBox.Show(ex.Message + " 1635");
                                            }
                                        }
                                    }
                                    else
                                    {
                                        ReceiveDataDic.Add(tempBuffer[2], tempBuffer);
                                        try
                                        {
                                            agvser.UpdateBuffer(tempBuffer.ToList(), remotePoint);
                                        }
                                        catch (System.Exception ex)
                                        {
                                            MessageBox.Show(ex.Message + " 1648");
                                        }
                                    }
                                    #endregion
                                }
                                else
                                {
                                    buffer.RemoveAt(0);

                                }
                            }
                            #endregion
                        }
                        else if (GlobalPara.DataHandleType == 1)//线程中单独处理
                        {
                            agvService.UpdateBuffer(e.buffer.ToList(), remotePoint);
                        }
                    }
                }
            }
            catch (Exception)
            {

            }
        }

        #region 校验数据
        byte[] CheckData(byte[] buffer)
        {
            byte[] tempBuffer = null;
            if (buffer.Length >= 10)
            {
                if (buffer[0] == 0x10 && (buffer[1] == 0x62 || buffer[1] == 0x72) && buffer[10] == DrvWlConGetBCC(buffer, 10) && buffer[11] == 0x03)
                {
                    tempBuffer = new byte[12];
                    buffer.CopyTo(tempBuffer, 12);

                    return tempBuffer;
                }
            }
            return tempBuffer;
        }
        #endregion

        #region 电池信息
        /// <summary>
        /// 获取电池信息
        /// </summary>
        /// <param name="buffer">字节流</param>
        /// <returns>电池对象</returns>
        BatteryData GetBatteryData(byte[] buffer)
        {
            //电池信息从Buffer中第3字节开始
            BatteryData data = new BatteryData();
            byte temp;
            data.AgvNum = buffer[2];
            data.BMSAlarm = buffer[3];
            data.BMSCommand = buffer[4];
            data.Voltage = (ushort)(buffer[5] | buffer[6] << 8);
            data.Temprature = (sbyte)buffer[7];
            data.SOC = buffer[8];
            data.Month = (ushort)(buffer[9] | buffer[10] << 8);
            data.Date = (ushort)(buffer[11] | buffer[12] << 8);
            data.Current = (ushort)(buffer[13] | buffer[14] << 8);
            data.BatteryId = (ushort)(buffer[15] | buffer[16] << 8);
            data.Cell1Voltage = (ushort)(buffer[17] | buffer[18] << 8);
            data.Cell2Voltage = (ushort)(buffer[19] | buffer[20] << 8);
            data.Cell3Voltage = (ushort)(buffer[21] | buffer[22] << 8);
            data.Cell4Voltage = (ushort)(buffer[23] | buffer[24] << 8);
            data.Cell5Voltage = (ushort)(buffer[25] | buffer[26] << 8);
            data.Cell6Voltage = (ushort)(buffer[27] | buffer[28] << 8);
            data.Cell7Voltage = (ushort)(buffer[29] | buffer[30] << 8);
            temp = buffer[31];
            temp = buffer[32];
            data.Cell1Temp = (sbyte)buffer[33];
            data.Cell2Temp = (sbyte)buffer[34];
            data.Cell3Temp = (sbyte)buffer[35];
            data.Cell4Temp = (sbyte)buffer[36];
            data.Cell5Temp = (sbyte)buffer[37];
            data.Cell6Temp = (sbyte)buffer[38];
            data.Cell7Temp = (sbyte)buffer[39];
            temp = buffer[40];
            return data;
        }

        //long tempTrafficFlag = 0;//管制标志，从Web服务中获取的
        //bool threadRunFlag = false;

        bool batteryInfoFlag = false;//是否需要获取信息标志
        ushort batteryInfo_AgvNum = 1;//需要获取电池信息的AGV编号
        byte[] batterySendBuffer = new byte[10];

        /// <summary>
        /// 获取电池信息定时器
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void batteryInfoTimer_Tick(object sender, EventArgs e)
        {
            if (!batteryInfoFlag)
            {
                batteryInfoFlag = true;
                if (batteryInfo_AgvNum > AGVNUM_MAX)
                    batteryInfo_AgvNum = 1;
                {
                    batterySendBuffer[0] = 0x10;
                    batterySendBuffer[1] = 0x81;
                    batterySendBuffer[2] = (byte)batteryInfo_AgvNum;

                    batterySendBuffer[8] = DrvWlConGetBCC(batterySendBuffer, 8);
                    batterySendBuffer[9] = 0x03;
                }
                batteryInfo_AgvNum++;
            }
        }
        #endregion

        /// <summary>
        /// 发送数据定时器
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void SendDataTimerTick(object sender, EventArgs e)
        {
            if (IsSendCtrl == 1)
            {
                #region 发送控制命令
                if (GlobalPara.type == 0)
                {
                    //SPComControl.Write(buf_runctl, 0, buf_runctl.Length);
                    for (int i = 0; i < SPComCOntrolList.Count; i++)
                    {
                        {
                            SPComCOntrolList[i].Write(buf_runctl, 0, buf_runctl.Length);
                        }
                    }
                }
                else if (GlobalPara.type == 1)
                {
                    communication.SendData(buf_runctl, null);
                }
                CtrlWaitNum++;
                if (CtrlWaitNum > 3)//发送控制命令未接收到时重复发送次数3次
                {
                    IsSendCtrl = 0;
                    CtrlWaitNum = 0;
                }
                #endregion

                //线程挂起100ms，等待接收数据中断（挂起时，其他线程运行）
                Thread.Sleep(100);
            }
            #region 掉线踢出管制区
            //掉线计数
            AGVInfoModel agv = null;
            for (int i = 1; i <= AGVNUM_MAX; i++)
            {
                if (GlobalPara.AgvInfoDic.Keys.Contains(i))
                {
                    agv = GlobalPara.AgvInfoDic[i];
                    agv.OffLineCount++;
                    if (agv.OffLineCount > OffLinkMax && agv.ConnectStatus)
                    {
                        //掉线，连接状态显示失败
                        agv.ConnectStatus = false;

                        if (agv.TRAFFICNUM.Count > 0)
                        {
                            List<TrafficAreaModel> templist = new List<TrafficAreaModel>();
                            templist.AddRange(agv.TRAFFICNUM);
                            foreach (TrafficAreaModel traffic in templist)
                            {
                                //踢出管制区
                                //tt.OutTraffic(agv);
                                int a1 = agv.ReleaseCount;
                                traffic.AGVLEAVE(agv);//管制区有AGV离开
                                int a = agv.ReleaseCount;
                                if (traffic.listAgvQueue.Count > 0)
                                {
                                    traffic.ReleaseAgv(); //调用放行事件
                                }
                                agv.TRAFFICNUM.Remove(traffic);//清空之前，先做一些处理。让AGV退出的那些管制区解除管制状态。

                                string astr = string.Format("管制状态{0}--{1}", agv.TrafficFlag, agv.ReleaseCount);
                            }
                        }
                    }
                }
            }
            #endregion
            if (!GlobalPara.UseNewProtrol)
            {
                //             SendTrafficOrder64();
                SendTrafficOrder160();
            }
            else
            {
                SendTrafficOrder160();
            }
        }


        #region 管制标识位的赋值更新
        void SendOrderBy48()
        {
            //byte [] buf_traffic=new byte[10];
            buf_traffic[0] = 0x10;
            buf_traffic[1] = 0x61;
            buf_traffic[2] = FlagArry[0];
            buf_traffic[3] = FlagArry[1];
            buf_traffic[4] = FlagArry[2];
            buf_traffic[5] = FlagArry[3];
            buf_traffic[6] = FlagArry[4];
            buf_traffic[7] = FlagArry[5];
            buf_traffic[8] = DrvWlConGetBCC(buf_traffic, 8);
            buf_traffic[9] = 0x03;
            if (GlobalPara.type == 0)
            {
                for (int i = 0; i < SPComCOntrolList.Count; i++)
                {
                    if (SPComCOntrolList[i] != null)
                    {
                        SPComCOntrolList[i].Write(buf_traffic, 0, buf_traffic.Length);
                    }
                }
            }
            else if (GlobalPara.type == 1)
            {
                communication.SendData(buf_traffic, null);
            }
            Thread.Sleep(10);
        }

        void SendOrderBy200()
        {
            buf_trafficctl[0] = 0x10;
            buf_trafficctl[1] = 0x61;
            buf_trafficctl[2] = FlagArry[0];
            buf_trafficctl[3] = FlagArry[1];
            buf_trafficctl[4] = FlagArry[2];
            buf_trafficctl[5] = FlagArry[3];
            buf_trafficctl[6] = FlagArry[4];
            buf_trafficctl[7] = FlagArry[5];
            buf_trafficctl[8] = FlagArry[6];
            buf_trafficctl[9] = FlagArry[7];
            buf_trafficctl[10] = FlagArry[8];
            buf_trafficctl[11] = FlagArry[9];
            buf_trafficctl[12] = FlagArry[10];
            buf_trafficctl[13] = FlagArry[11];
            buf_trafficctl[14] = FlagArry[12];
            buf_trafficctl[15] = FlagArry[13];
            buf_trafficctl[16] = FlagArry[14];
            buf_trafficctl[17] = FlagArry[15];
            buf_trafficctl[18] = FlagArry[16];
            buf_trafficctl[19] = FlagArry[17];
            buf_trafficctl[20] = FlagArry[18];
            buf_trafficctl[21] = FlagArry[19];
            buf_trafficctl[22] = FlagArry[20];
            buf_trafficctl[23] = FlagArry[21];
            buf_trafficctl[24] = FlagArry[22];
            buf_trafficctl[25] = FlagArry[23];
            buf_trafficctl[26] = FlagArry[24];
            buf_trafficctl[27] = FlagArry[25];
            buf_trafficctl[28] = FlagArry[26];
            buf_trafficctl[29] = FlagArry[27];
            buf_trafficctl[30] = FlagArry[28];
            buf_trafficctl[31] = FlagArry[29];
            buf_trafficctl[32] = FlagArry[30];
            buf_trafficctl[33] = FlagArry[31];
            buf_trafficctl[34] = FlagArry[32];
            buf_trafficctl[35] = FlagArry[33];
            buf_trafficctl[36] = FlagArry[34];
            buf_trafficctl[37] = FlagArry[35];
            buf_trafficctl[38] = FlagArry[36];
            buf_trafficctl[39] = DrvWlConGetBCC(buf_trafficctl, 39);
            if (GlobalPara.type == 0)
            {
                for (int i = 0; i < SPComCOntrolList.Count; i++)
                {
                    if (SPComCOntrolList[i] != null)
                    {
                        SPComCOntrolList[i].Write(buf_trafficctl, 0, buf_trafficctl.Length);
                    }
                }
            }
            else if (GlobalPara.type == 1)
            {
                communication.SendData(buf_trafficctl, null);
            }
            Thread.Sleep(10);
        }

        #endregion

        /// <summary>
        /// 更新屏幕定时器
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public void t_Tick(object sender, EventArgs e)
        {
            try
            {
                UpdateAgvGrid();
                dataGrid.Items.Refresh();
                UpdateTrafficGrid();
            }
            catch (System.Exception ex)
            {
                MessageBox.Show(ex.Message + " 1949");
            }

        }

        #region 获取所有AGV的管制状态，并发送10 61管制命令给所有agv
        Dictionary<int, bool> TrafficFlagDic = new Dictionary<int, bool>();

        /// <summary>
        /// 初始化
        /// </summary>
        void InitTrafficFlagDic()
        {
            for (int i = 1; i <= AGVNUM_MAX; i++)
            {
                TrafficFlagDic.Add(i, false);
            }
        }
        /// <summary>
        /// 更新AGV的管制状态
        /// </summary>
        /// <param name="agvnum"></param>
        void SetTrafficFlagDic(int agvnum)
        {
            if (TrafficFlagDic.ContainsKey(agvnum))
            {
                TrafficFlagDic[agvnum] = true;
            }
        }
        /// <summary>
        /// 发送管制命令（可达200以上）
        /// </summary>
        void SendTrafficOrder()
        {
            foreach (var agv in GlobalPara.AgvInfoDic.Values)
            {
                int BitIndex = (agv.AGVNUM - 1) % 8;
                int ByteIndex = (agv.AGVNUM - 1) / 8;

                if (agv.TrafficFlag)//管制标识为true，相应位置1
                {
                    SendD1D2 |= Convert.ToInt64((long)1 << (agv.AGVNUM - 1));

                    //把这个8位的字节中，与AGV编号相对应的bit位置为1
                    FlagArry[ByteIndex] |= (byte)((0x01) << BitIndex);
                }
                else
                {
                    SendD1D2 &= Convert.ToInt64(~((long)1 << (agv.AGVNUM - 1)));

                    //把这个8位的字节中，与AGV编号相对应的bit位置为0,要注意别把其他位的值给覆盖了
                    FlagArry[ByteIndex] &= (byte)(~((0x01) << BitIndex));
                }
            }
            if ((bool)chBox_Traffic.IsChecked)//开启了管制才发数据
            {
                #region 管制状态更新（200）
                buf_trafficctl[0] = 0x10;
                buf_trafficctl[1] = 0x61;
                buf_trafficctl[2] = FlagArry[0];
                buf_trafficctl[3] = FlagArry[1];
                buf_trafficctl[4] = FlagArry[2];
                buf_trafficctl[5] = FlagArry[3];
                buf_trafficctl[6] = FlagArry[4];
                buf_trafficctl[7] = FlagArry[5];
                buf_trafficctl[8] = FlagArry[6];
                buf_trafficctl[9] = FlagArry[7];
                buf_trafficctl[10] = FlagArry[8];
                buf_trafficctl[11] = FlagArry[9];
                buf_trafficctl[12] = FlagArry[10];
                buf_trafficctl[13] = FlagArry[11];
                buf_trafficctl[14] = FlagArry[12];
                buf_trafficctl[15] = FlagArry[13];
                buf_trafficctl[16] = FlagArry[14];
                buf_trafficctl[17] = FlagArry[15];
                buf_trafficctl[18] = FlagArry[16];
                buf_trafficctl[19] = FlagArry[17];
                buf_trafficctl[20] = FlagArry[18];
                buf_trafficctl[21] = FlagArry[19];
                buf_trafficctl[22] = FlagArry[20];
                buf_trafficctl[23] = FlagArry[21];
                buf_trafficctl[24] = FlagArry[22];
                buf_trafficctl[25] = FlagArry[23];
                buf_trafficctl[26] = FlagArry[24];
                buf_trafficctl[27] = FlagArry[25];
                buf_trafficctl[28] = FlagArry[26];
                buf_trafficctl[29] = FlagArry[27];
                buf_trafficctl[30] = FlagArry[28];
                buf_trafficctl[31] = FlagArry[29];
                buf_trafficctl[32] = FlagArry[30];
                buf_trafficctl[33] = FlagArry[31];
                buf_trafficctl[34] = FlagArry[32];
                buf_trafficctl[35] = FlagArry[33];
                buf_trafficctl[36] = FlagArry[34];
                buf_trafficctl[37] = FlagArry[35];
                buf_trafficctl[38] = FlagArry[36];
                buf_trafficctl[39] = DrvWlConGetBCC(buf_trafficctl, 39);
                #endregion
                if (GlobalPara.type == 0)
                {
                    for (int i = 0; i < SPComCOntrolList.Count; i++)
                    {
                        if (SPComCOntrolList[i] != null)
                        {
                            SPComCOntrolList[i].Write(buf_trafficctl, 0, buf_trafficctl.Length);
                        }
                    }
                }
                else if (GlobalPara.type == 1)
                {
                    communication.SendData(buf_trafficctl, null);
                }
                Thread.Sleep(10);
            }
        }
        /// <summary>
        /// 获取多区域管制  2017.2.15 王锴修改
        /// </summary>
        private void getTrafficAgvServer()
        {
            while (true)
            {
                if (traffic != null)
                {
                    List<byte> trafficAgv = traffic.GetTrafficAgvNum();
                    if (trafficAgv.Count > 0)
                    {
                        int aa = 0;
                        for (int i = 0; i < trafficAgv.Count; i++)
                        {
                            if (trafficAgv[i] > 0)
                                aa = aa | (1 << trafficAgv[i] - 1);
                        }
                        TrafficData = aa;
                    }
                    else
                    {
                        TrafficData = 0;
                    }
                }

                Thread.Sleep(50);
            }
        }
        void SendTrafficOrder88()
        {
            {
                long temp = 0;
                temp = SendD1D2 | TrafficData;//组合Web服务的交管和本地的交管数据

                buf_trafficct2[0] = 0x10;
                buf_trafficct2[1] = 0x61;
                buf_trafficct2[2] = Convert.ToByte(temp & 0x00000000000000ff);
                buf_trafficct2[3] = Convert.ToByte((temp & 0x000000000000ffff) >> 8);
                buf_trafficct2[4] = Convert.ToByte((temp & 0x0000000000ffffff) >> 16);
                buf_trafficct2[5] = Convert.ToByte((temp & 0x00000000ffffffff) >> 24);
                buf_trafficct2[6] = Convert.ToByte((temp & 0x000000ffffffffff) >> 32);

                buf_trafficct2[7] = Convert.ToByte((temp & 0x0000ffffffffffff) >> 40);

                buf_trafficct2[8] = DrvWlConGetBCC(buf_trafficct2, 8);
                buf_trafficct2[9] = 0x03;
                if (GlobalPara.type == 0)
                {
                    //SPComControl.Write(buf_trafficctl, 0, buf_trafficctl.Length);
                    for (int i = 0; i < SPComCOntrolList.Count; i++)
                    {
                        if (SPComCOntrolList[i] != null)
                        {
                            SPComCOntrolList[i].Write(buf_trafficct2, 0, buf_trafficct2.Length);
                        }
                    }
                }
                else if (GlobalPara.type == 1)
                {
                    communication.SendData(buf_trafficct2, null);
                }
                Thread.Sleep(5);
            }
        }
        string Str1063 = "";
        byte[] buf_boxAsk = { 0x11, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x44 };
        /// <summary>
        /// 发送管制命令（最多16台）
        /// </summary>
        void SendTrafficOrder160(int flag = 1)
        {
            foreach (var agv in GlobalPara.AgvInfoDic.Values)
            {
                if (agv.AGVNUM > AGVNUM_MAX) break;
                int BitIndex = (agv.AGVNUM - 1) % 8;
                int ByteIndex = (agv.AGVNUM - 1) / 8;

                if (agv.TrafficFlag)//管制标识为true，相应位置1
                {
                    SendD1D2 |= Convert.ToInt64((long)1 << (agv.AGVNUM - 1));

                    //把这个8位的字节中，与AGV编号相对应的bit位置为1
                    FlagArry[ByteIndex] |= (byte)((0x01) << BitIndex);
                }
                else
                {
                    SendD1D2 &= Convert.ToInt64(~((long)1 << (agv.AGVNUM - 1)));

                    //把这个8位的字节中，与AGV编号相对应的bit位置为0,要注意别把其他位的值给覆盖了
                    FlagArry[ByteIndex] &= (byte)(~((0x01) << BitIndex));
                }
            }
            if ((bool)chBox_Traffic.IsChecked)//开启了管制才发数据
            {
                #region 管制状态更新

                buf_trafficct3[2] = FlagArry[0];
                buf_trafficct3[3] = FlagArry[1];
                buf_trafficct3[4] = FlagArry[2];
                buf_trafficct3[5] = FlagArry[3];
                buf_trafficct3[6] = FlagArry[4];
                buf_trafficct3[7] = FlagArry[5];
                buf_trafficct3[8] = FlagArry[6];
                buf_trafficct3[9] = FlagArry[7];
                buf_trafficct3[10] = FlagArry[8];
                buf_trafficct3[11] = FlagArry[9];
                buf_trafficct3[12] = FlagArry[10];
                buf_trafficct3[13] = FlagArry[11];
                buf_trafficct3[14] = FlagArry[12];
                buf_trafficct3[15] = FlagArry[13];
                buf_trafficct3[16] = FlagArry[14];
                buf_trafficct3[17] = FlagArry[15];
                buf_trafficct3[18] = FlagArry[16];
                buf_trafficct3[19] = FlagArry[17];
                buf_trafficct3[20] = FlagArry[18];
                buf_trafficct3[21] = (byte)(FlagArry[19] | (flag << 5));
                buf_trafficct3[22] = DrvWlConGetBCC(buf_trafficct3, 22);
                #endregion
                if (GlobalPara.type == 0)
                {
                    for (int i = 0; i < SPComCOntrolList.Count; i++)
                    {
                        if (SPComCOntrolList[i] != null)
                        {
                            SPComCOntrolList[i].Write(buf_trafficct3, 0, buf_trafficct3.Length);
                        }
                    }
                }
                else if (GlobalPara.type == 1)
                {
                    communication.SendData(buf_trafficct3, null);
                    for (int i = 0; i < GlobalPara.DtWirelessBox.Rows.Count; i++)
                    {
                        IPEndPoint ip = new IPEndPoint(IPAddress.Parse(GlobalPara.DtWirelessBox.Rows[i]["设备IP"].ToString()), 8899);
                        communication.SendData(buf_boxAsk, ip);
                    }
                    if (GlobalPara.Gloal1063Flag)
                    {
                        if (Str1063 != UdpCommunication.ByteToHexString(buf_trafficct3))
                        {
                            Str1063 = UdpCommunication.ByteToHexString(buf_trafficct3);
                            WriteFile("1063发送记录-" + DateTime.Now.ToString("yyyy-MM-dd"), Str1063);
                        }
                    }
                }
                Thread.Sleep(10);
            }
        }
        /// <summary>
        /// 发送管制命令（最多64台）
        /// </summary>
        void SendTrafficOrder64()
        {
            foreach (var agv in GlobalPara.AgvInfoDic.Values)
            {
                if (agv.AGVNUM > AGVNUM_MAX) break;
                int BitIndex = (agv.AGVNUM - 1) % 8;
                int ByteIndex = (agv.AGVNUM - 1) / 8;

                if (agv.TrafficFlag)//管制标识为true，相应位置1
                {
                    SendD1D2 |= Convert.ToInt64((long)1 << (agv.AGVNUM - 1));

                    //把这个8位的字节中，与AGV编号相对应的bit位置为1
                    FlagArry[ByteIndex] |= (byte)((0x01) << BitIndex);
                }
                else
                {
                    SendD1D2 &= Convert.ToInt64(~((long)1 << (agv.AGVNUM - 1)));

                    //把这个8位的字节中，与AGV编号相对应的bit位置为0,要注意别把其他位的值给覆盖了
                    FlagArry[ByteIndex] &= (byte)(~((0x01) << BitIndex));
                }
            }
            if ((bool)chBox_Traffic.IsChecked)//开启了管制才发数据
            {
                #region 管制状态更新
                buf_traffic[0] = 0x10;
                buf_traffic[1] = 0x61;
                buf_traffic[2] = FlagArry[0];
                buf_traffic[3] = FlagArry[1];
                buf_traffic[4] = FlagArry[2];
                buf_traffic[5] = FlagArry[3];
                buf_traffic[6] = FlagArry[4];
                buf_traffic[7] = FlagArry[5];
                buf_traffic[8] = DrvWlConGetBCC(buf_traffic, 8);
                buf_traffic[9] = 0x03;
                #endregion
                if (GlobalPara.type == 0)
                {
                    for (int i = 0; i < SPComCOntrolList.Count; i++)
                    {
                        if (SPComCOntrolList[i] != null)
                        {
                            SPComCOntrolList[i].Write(buf_traffic, 0, buf_traffic.Length);
                        }
                    }
                }
                else if (GlobalPara.type == 1)
                {
                    communication.SendData(buf_traffic, null);
                }
                Thread.Sleep(10);
            }
        }
        #endregion

        #region 属性更新，屏幕刷新
        /// <summary>
        /// 更新屏幕
        /// </summary>
        void UpdateAgvGrid()
        {
            AGVInfoModel agvinfo = null;
            for (int i = 0; i < AGVNUM_MAX; i++)
            {
                if (GlobalPara.AgvInfoDic.Keys.Contains(i + 1))
                {
                    agvinfo = GlobalPara.AgvInfoDic[i + 1];

                    try
                    {
                        memberData[i].txtWorkLineValue = "1";
                        memberData[i].txtAGVNumValue = agvinfo.AGVNUM.ToString();

                        StringBuilder trafficnumsb = new StringBuilder();
                        foreach (var t in agvinfo.TRAFFICNUM)
                        {
                            trafficnumsb.Append(t.TrafficNum.ToString());//管制区号
                            trafficnumsb.Append(",");
                        }

                        memberData[i].txtElectricityValue = agvinfo.Battery_Electricity.ToString("f2");
                        memberData[i].txtVoltageValue = agvinfo.Bttery_Voltage.ToString("f2");
                        memberData[i].txtPowerValue = agvinfo.Battery_Power.ToString();
                        memberData[i].txtTemperatureValue = agvinfo.Battery_Temperature.ToString();
                        memberData[i].txtTrafficNumValue = trafficnumsb.ToString();
                        memberData[i].txtTrafficStateValue = agvinfo.TrafficFlag ? "管制中" : "无";
                        memberData[i].txtLineNumValue = agvinfo.ROUTENUM.ToString();
                        memberData[i].txtMarkFunctionValue = MarkFuncOpt[agvinfo.MARKFUN];
                        memberData[i].txtSpeedValue = SpeedOpt[agvinfo.SPEEDLEVEL];
                        memberData[i].txtMarkNumValue = agvinfo.MARKNUM.ToString();
                        memberData[i].txtWLValue = agvinfo.ConnectStatus ? "成功" : "失败";
                        if (agvinfo.TRAFFICAGV != null)
                        {
                            memberData[i].txtTrafficAgvValue = agvinfo.TRAFFICAGV.AGVNUM.ToString();
                            memberData[i].txtTrafficAgvListValue = agvinfo.TRAFFICAGV.AGVNUM.ToString();
                        }
                        else
                        {
                            memberData[i].txtTrafficAgvValue = "0";
                            memberData[i].txtTrafficAgvListValue = "0";
                        }

                        memberData[i].txtOffLineCountValue = agvinfo.ConnectStatus.ToString();//20141127增加掉线计数
                        memberData[i].txtIsMainAgvValue = agvinfo.IsMainAgv ? "主机" : "从机";

                        #region 运行状态更新
                        switch (GlobalPara.AgvInfoDic[i + 1].RUNSTATUS_Cur)
                        {
                            case 0x40:
                                memberData[i].txtStatusValue = "运行";
                                break;
                            case 0x43:
                                memberData[i].txtStatusValue = "暂停";
                                break;
                            case 0x42:
                                memberData[i].txtStatusValue = "结束地标停止";
                                break;
                            case 0x41:
                                memberData[i].txtStatusValue = "停止";
                                break;
                            case 0x44:
                                memberData[i].txtStatusValue = "充电中";
                                break;
                            case 0x00:
                                memberData[i].txtStatusValue = "无效";
                                break;
                            default:
                                if (agvinfo.RUNSTATUS < StatusOpt.Length)
                                {
                                    memberData[i].txtStatusValue = StatusOpt[agvinfo.RUNSTATUS];
                                }
                                break;
                        }
                        //int code = 0;
                        //if (agvinfo.ALARMCODE != "")
                        //{
                        //    code = int.Parse(agvinfo.ALARMCODE);
                        //}
                        //if (code < StatusOpt.Length)
                        //{
                        //    if (code != 0)
                        //    {
                        //        memberData[i].txtAlertsValue = StatusOpt[code];
                        //    }
                        //    else
                        //    {
                        //        memberData[i].txtAlertsValue = "正常";
                        //    }
                        //}
                        #endregion
                    }
                    catch (Exception ex)
                    {
                        DateTime time = DateTime.Now;
                        //MessageBox.Show("线程异常:"+e.ExceptionObject);
                        FileStream stream = File.Open(@"Exception\程序异常.txt", FileMode.Append, FileAccess.Write);
                        StreamWriter writer = new StreamWriter(stream);

                        if (ex != null)
                        {
                            string msg = string.Format("[{0}]Test:\r\nMessage:{1}\r\nStackTrace:\r\n{2}", time.ToString("yyyy-MM-dd HH:mm:ss"), ex.Message, ex.StackTrace);
                            writer.WriteLine(msg);
                            writer.Close();
                            stream.Close();
                        }
                        //          MessageBox.Show(ex.Message + " 2352");
                    }

                }
            }
        }

        /// <summary>
        /// 更新管制区列表
        /// </summary>
        void UpdateTrafficGrid()
        {
            foreach (var traffic in GlobalPara.TrafficBuffer.Values)
            {
                if (traffic.IsTraffic && traffic.MainAgv != null)
                {
                    if (!TrafficMember.Contains(traffic))
                    {
                        try
                        {
                            TrafficMember.Add(traffic);
                        }
                        catch (Exception ex)
                        {
                            throw ex;
                        }
                    }
                }
                else
                {
                    if (TrafficMember.Contains(traffic))
                    {
                        try
                        {
                            TrafficMember.Remove(traffic);
                        }
                        catch (Exception ex)
                        {
                            throw ex;
                        }

                    }
                }
            }
            //dataGrid2.Items.Refresh();
        }

        /// <summary>
        /// 界面显示类AGV_DisMember属性更改委托函数
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public void Dis_PropertyChange(object sender, PropertyChangedEventArgs e)
        {
            if (e.PropertyName.Equals("txtMarkNum"))
            {
                MarkChangeAction((AGV_DisMember)sender);
                RunLog.WriteLog((AGV_DisMember)sender);
            }
            else if (e.PropertyName.Equals("txtStatus"))
            {
                StatusChangeAction((AGV_DisMember)sender);
                //        UpdateStatusForUseRate(sender as AGV_DisMember);//稼动率 
            }
            else if (e.PropertyName.Equals("txtWL"))
            {
                WLChangeAction((AGV_DisMember)sender);
                //         UpdateStatusForUseRate(sender as AGV_DisMember); //稼动率             
            }
            else if (e.PropertyName.Equals("txtTrafficNum"))
            {
                //AlertsChangeAction((AGV_DisMember)sender);
                //UpdateStatusForUseRate(sender as AGV_DisMember);//稼动率 
            }
            //UpdateCasunService(sender as AGV_DisMember);
        }
        /// <summary>
        /// 稼动率数据更新
        /// </summary>
        /// <param name="agv"></param>
        void UpdateStatusForUseRate(AGV_DisMember agv)
        {
            if (agv != null)
            {
                int agvNum = int.Parse(agv.txtAGVNum);
                if (agvNum <= useRateTimeList.Count)
                {
                    if (agv.txtWL == "成功")
                    {
                        if (agv.txtStatus == "无效")
                        {
                            useRateTimeList[agvNum - 1].StatusType = -1;//无效状态
                        }
                        else
                        {
                            useRateTimeList[agvNum - 1].StatusType = GlobalPara.AgvInfoDic[agvNum].RUNSTATUS;//0x40运行，0x41暂停，0x42结束地标停止，0x40前的都为报警,暂将0x43当作充电

                        }
                    }
                    else
                    {
                        useRateTimeList[agvNum - 1].StatusType = 0;//离线状态
                    }
                }
            }
        }

        /// <summary>
        /// 地标属性更改时触发的事件
        /// 移除上次动画，显示下一动画
        /// </summary>
        /// <param name="temp1">AGV_DisMember类</param>
        private void MarkChangeAction(AGV_DisMember temp1)
        {
            int iagvnum = string.IsNullOrEmpty(temp1.txtAGVNum) ? 0 : Convert.ToInt16(temp1.txtAGVNum);
            //int iagvnum = Convert.ToInt16(temp1.txtAGVNum.Remove(0, 3));

            /************************************************************************/
            /* 修改日期：2014.9.25
             * 修改者：肖丁铭
             说明：在此处添加了读卡检测功能*/
            /************************************************************************/
            RoutePoint point = new RoutePoint();
            point.route = int.Parse(temp1.txtLineNum);
            point.currentPoint = int.Parse(temp1.txtMarkNum);
            Console.ForegroundColor = ConsoleColor.Green;



            //Console.WriteLine(string.Format("当前:AGV{0},路线{1},当前地标{2}", iagvnum, point.route, point.currentPoint));
            Action action = new Action(delegate ()
            {
                Console.ResetColor();
                if (iagvnum >= 1 && chechCardUnits != null && chechCardUnits[iagvnum - 1] != null)
                {
                    try
                    {
                        lock (checkLock)
                        {
                            if (GlobalPara.IsEnableReadCheck)
                                chechCardUnits[iagvnum - 1].CheckPoint(point);//检查是否有漏读卡
                        }
                    }
                    catch (System.Exception ex)
                    {
                        Console.WriteLine(string.Format("类型:{0},{1}", ex.TargetSite, ex.Message));

                    }
                }
            });
            action.BeginInvoke(null, null);
            //只在坐标上显示
            if (!GlobalPara.IsEnableRouteView)
            {
                if (iagvnum > 0 && iagvnum <= AGVNUM_MAX)
                {
                    Point pStart = new Point();

                    string a = "select T_Mark.XPos, T_Mark.YPos FROM T_Mark where Mark=" + temp1.txtMarkNum.ToString() + "";
                    TrafficPara.Open("select T_Mark.XPos, T_Mark.YPos FROM T_Mark where Mark=" + temp1.txtMarkNum.ToString() + "");

                    if (TrafficPara.Rows.Count > 0)
                    {
                        pStart.X = Convert.ToDouble(TrafficPara.Rows[0]["XPos"]);
                        pStart.Y = Convert.ToDouble(TrafficPara.Rows[0]["YPos"]);
                        DrawCarInPoint(pStart, ColorOpt[iagvnum % ColorOpt.Length], iagvnum);

                    }
                    else return;

                }
            }
            else
            {
                if (iagvnum > 0 && iagvnum <= AGVNUM_MAX)
                {
                    Point pStart = new Point(), pEnd = new Point(), pVirtual = new Point();
                    if (Convert.ToInt32(temp1.txtDockNum) > 0)
                    {
                        TrafficPara.Open("Select RouteNum from T_DockSetting where DockNum=" + temp1.txtDockNum + " and AGVNum=" + iagvnum.ToString());
                        if (TrafficPara.rowcount > 0)
                        {
                            temp1.txtLineNum = TrafficPara.Rows[0]["RouteNum"].ToString();
                        }
                    }
                    string sql_str = "select T_Line.MarkOrder, T_Mark.XPos, T_Mark.YPos FROM T_Line LEFT OUTER JOIN T_Mark ON T_Mark.ID = T_Line.MarkID where WorkLine=" + temp1.txtWorkLine + " and Mark=" + temp1.txtMarkNum + " and LineNum=" + temp1.txtLineNum + "";
                    TrafficPara.Open("select T_Line.MarkOrder, T_Mark.XPos, T_Mark.YPos FROM T_Line LEFT OUTER JOIN T_Mark ON T_Mark.ID = T_Line.MarkID where WorkLine=(select distinct WorkLine from T_WorkLine  where CarID=" + iagvnum + ") and Mark=" + temp1.txtMarkNum + " and LineNum=" + temp1.txtLineNum);

                    if (TrafficPara.Rows.Count > 0)
                    {
                        pStart.X = Convert.ToDouble(TrafficPara.Rows[0]["XPos"]);
                        pStart.Y = Convert.ToDouble(TrafficPara.Rows[0]["YPos"]);
                        List<Point> pointcollection1 = new List<Point>();
                        pointcollection1.Add(pStart);
                        int currentOrder = Convert.ToInt16(TrafficPara.Rows[0]["MarkOrder"]) + 1;
                        bool isvirtualpoint = true;
                        double dMarkdistance = 0;
                        while (isvirtualpoint)
                        {
                            TrafficPara.Open("select XPos,YPos,T_Line.Distance from T_Mark Left join T_Line on T_Mark.ID = T_Line.MarkID where WorkLine=(select distinct WorkLine from T_WorkLine  where CarID=" + iagvnum + ") and T_Line.MarkOrder=" + currentOrder.ToString() +
                                "and LineNum=" + temp1.txtLineNum + "and T_Mark.VirtualMark=1");
                            if (TrafficPara.Rows.Count > 0)
                            {
                                pVirtual.X = Convert.ToDouble(TrafficPara.Rows[0]["XPos"]);
                                pVirtual.Y = Convert.ToDouble(TrafficPara.Rows[0]["YPos"]);
                                pointcollection1.Add(pVirtual);
                                dMarkdistance += Convert.ToDouble(TrafficPara.Rows[0]["Distance"]);
                                currentOrder++;
                            }
                            else { isvirtualpoint = false; break; }
                        }
                        TrafficPara.Open("select XPos,YPos,T_Line.Distance from T_Mark Left join T_Line on T_Mark.ID = T_Line.MarkID where WorkLine=(select distinct WorkLine from T_WorkLine  where CarID=" + iagvnum + ") and T_Line.MarkOrder=" + currentOrder.ToString() +
                            "and LineNum=" + temp1.txtLineNum + "and T_Mark.VirtualMark=0");
                        if (TrafficPara.Rows.Count > 0)
                        {
                            pEnd.X = Convert.ToDouble(TrafficPara.Rows[0]["XPos"]);
                            pEnd.Y = Convert.ToDouble(TrafficPara.Rows[0]["YPos"]);
                            pointcollection1.Add(pEnd);
                            dMarkdistance += Convert.ToDouble(TrafficPara.Rows[0]["Distance"]);
                        }
                        else return;
                        if (pointcollection1.Count >= 2)
                        {
                            double dAgvspeed = 0;
                            TrafficPara.Open("select Speed from T_Speed where SpeedGrade='" + temp1.txtSpeedValue + "'");
                            if (TrafficPara.Rows.Count > 0)
                            {
                                dAgvspeed = Convert.ToDouble(TrafficPara.Rows[0]["Speed"]) / 60.0;
                            }
                            else return;
                            DrawCarLine(pointcollection1, ColorOpt[iagvnum % ColorOpt.Length], iagvnum, dMarkdistance / dAgvspeed);
                        }
                    }
                }
            }

            TrafficPara.Close();
        }

        private void AlertsChangeAction(AGV_DisMember temp1)
        {
            int iagvnum = string.IsNullOrEmpty(temp1.txtAGVNum) ? 0 : Convert.ToInt16(temp1.txtAGVNum);
            if (iagvnum > 0 && iagvnum <= AGVNUM_MAX)
            {
                dislable[iagvnum - 1].BeginAnimation(OpacityProperty, null);
                dislable[iagvnum - 1].Opacity = 1;
                {
                    //将报警记录写入到数据库
                    string txttimer = System.DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");

                    if (!temp1.txtAlertsValue.Contains("障碍物") && !temp1.txtAlertsValue.Contains("正常"))//过滤掉障碍物，不会存数据库
                    {
                        TrafficPara.Open("Insert into T_Ex (CarID,ExTimer,ExType,ExRouteNum,ExMarkNum,ExWorkLine) VALUES (" + iagvnum.ToString() + ",'" + txttimer + "','" + temp1.txtAlertsValue + "'," + temp1.txtLineNum + "," + temp1.txtMarkNum + "," + temp1.txtWorkLine + ")");
                        TrafficPara.Close();
                    }
                    if (contextMenuChangeDisplay.IsChecked)
                    {
                        dislable[iagvnum - 1].Content = temp1.txtAgvAlias + temp1.txtAlertsValue.Trim();
                    }
                    else
                    {
                        dislable[iagvnum - 1].Content = iagvnum.ToString() + temp1.txtAlertsValue.Trim();
                    }
                    //报警信息字体颜色设置
                    if (temp1.txtAlertsValue.Contains("报警") || temp1.txtAlertsValue.Contains("电压") || temp1.txtAlertsValue.Contains("障碍物"))
                    {
                        if (temp1.txtAlertsValue.Contains("障碍物"))
                        {
                            dislable[iagvnum - 1].Foreground = Brushes.DeepSkyBlue;
                        }
                        else if (temp1.txtAlertsValue.Contains("低电压报警"))
                        {
                            dislable[iagvnum - 1].Foreground = Brushes.DeepSkyBlue;
                        }
                        else
                        {
                            dislable[iagvnum - 1].Foreground = Brushes.Red;
                        }
                    }

                    dislable[iagvnum - 1].ToolTip = temp1.txtAlertsValue.Trim();
                    myLineStoryboard[iagvnum - 1].Pause(this);
                    //  dislable[iagvnum - 1].BeginAnimation(OpacityProperty, CarWarnningAnimation);

                    //过滤掉频繁出现的报警(将报警信息以服务的形式分发出去)
                    if (!temp1.txtAlertsValue.Contains("障碍物") && !temp1.txtAlertsValue.Contains("停止") && !temp1.txtAlertsValue.Contains("急停"))
                    {
                        AgvAlarmServiceLibrary.AlarmInfo info = new AgvAlarmServiceLibrary.AlarmInfo();
                        info.AgvId = iagvnum;
                        info.Route = int.Parse(temp1.txtLineNum);
                        info.Mark = int.Parse(temp1.txtMarkNum);
                        info.WorkLine = int.Parse(temp1.txtWorkLine);
                        info.AlarmTime = txttimer;
                        info.Area = GlobalPara.areaName;
                        info.Type = temp1.txtAlertsValue;

                        if (host != null && host.State == CommunicationState.Opened)
                        {
                            if (AgvAlarmServiceLibrary.AgvAlarmService.userCallBackList != null)
                            {
                                foreach (AgvAlarmServiceLibrary.ISrvToClientCallBack callback in AgvAlarmServiceLibrary.AgvAlarmService.userCallBackList)
                                {
                                    callback.NotifyClientAlarm(info);
                                }
                            }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// 运行状态属性更改时触发的事件
        /// </summary>
        /// <param name="temp1">AGV_DisMember类</param>
        private void StatusChangeAction(AGV_DisMember temp1)
        {
            //int iagvnum = Convert.ToInt16(temp1.txtAGVNum.Remove(0, 3));
            int iagvnum = string.IsNullOrEmpty(temp1.txtAGVNum) ? 0 : Convert.ToInt16(temp1.txtAGVNum);
            if (iagvnum > 0 && iagvnum <= AGVNUM_MAX)
            {
                dislable[iagvnum - 1].BeginAnimation(OpacityProperty, null);
                dislable[iagvnum - 1].Opacity = 1;
                switch (temp1.txtStatus.Trim())
                {
                    case "运行":
                        myLineStoryboard[iagvnum - 1].Resume(this);
                        dislable[iagvnum - 1].ToolTip = "正常";
                        if (contextMenuChangeDisplay.IsChecked)
                            dislable[iagvnum - 1].Content = temp1.txtAgvAlias;
                        else
                            //dislable[iagvnum - 1].Content = "AGV" + iagvnum.ToString();
                            dislable[iagvnum - 1].Content = iagvnum.ToString();
                        dislable[iagvnum - 1].Foreground = Brushes.Black;
                        break;
                    case "暂停":
                        dislable[iagvnum - 1].ToolTip = "暂停";
                        /*
                        if (Convert.ToInt32(temp1.txtDockNum) > 0)
                        {
                            dislable[iagvnum - 1].Content = iagvnum.ToString();
                        }
                        else
                        {
                            dislable[iagvnum - 1].Content = iagvnum.ToString() + temp1.txtStatus.Trim();
                        }*/
                        if (contextMenuChangeDisplay.IsChecked)
                        {
                            dislable[iagvnum - 1].Content = temp1.txtAgvAlias + temp1.txtStatus.Trim();
                        }
                        else
                        {
                            dislable[iagvnum - 1].Content = iagvnum.ToString() + temp1.txtStatus.Trim();
                        }
                        //dislable[iagvnum - 1].Foreground = Brushes.OrangeRed;//橙红色
                        dislable[iagvnum - 1].Foreground = Brushes.Black;//正常暂停显示黑色
                        myLineStoryboard[iagvnum - 1].Pause(this);
                        //    dislable[iagvnum - 1].BeginAnimation(OpacityProperty, CarWarnningAnimation);
                        break;
                    case "结束地标停止":
                        dislable[iagvnum - 1].ToolTip = "结束地标停止";
                        dislable[iagvnum - 1].Foreground = Brushes.GreenYellow;
                        if (contextMenuChangeDisplay.IsChecked)
                        {
                            dislable[iagvnum - 1].Content = temp1.txtAgvAlias;
                        }
                        else
                        {
                            dislable[iagvnum - 1].Content = iagvnum.ToString();
                        }
                        myLineStoryboard[iagvnum - 1].Pause(this);
                        //     dislable[iagvnum - 1].BeginAnimation(OpacityProperty, CarWarnningAnimation);
                        break;
                    case "无效":
                        break;
                    default:
                        {
                            //将报警记录写入到数据库
                            string txttimer = System.DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");

                            if (!temp1.txtStatus.Contains("障碍物"))//过滤掉障碍物，不会存数据库
                            {
                                TrafficPara.Open("Insert into T_Ex (CarID,ExTimer,ExType,ExRouteNum,ExMarkNum,ExWorkLine) VALUES (" + iagvnum.ToString() + ",'" + txttimer + "','" + temp1.txtStatus + "'," + temp1.txtLineNum + "," + temp1.txtMarkNum + "," + temp1.txtWorkLine + ")");
                                TrafficPara.Close();
                            }
                            if (contextMenuChangeDisplay.IsChecked)
                            {
                                dislable[iagvnum - 1].Content = temp1.txtAgvAlias + temp1.txtStatus.Trim();
                            }
                            else
                            {
                                dislable[iagvnum - 1].Content = iagvnum.ToString() + temp1.txtStatus.Trim();
                            }
                            //报警信息字体颜色设置
                            if (temp1.txtStatus.Contains("报警") || temp1.txtStatus.Contains("电压") || temp1.txtStatus.Contains("障碍物"))
                            {
                                if (temp1.txtStatus.Contains("障碍物"))
                                {
                                    dislable[iagvnum - 1].Foreground = Brushes.DeepSkyBlue;
                                }
                                else if (temp1.txtStatus.Contains("低电压报警"))
                                {
                                    dislable[iagvnum - 1].Foreground = Brushes.DeepSkyBlue;
                                }
                                else
                                {
                                    dislable[iagvnum - 1].Foreground = Brushes.Red;
                                }
                                //#region 侧边栏信息提示
                                ///*** */
                                //IList<AGV_DisMember> alarmlist = temp1.Where(p => p.txtStatus != "无效").Where(p => p.txtStatus != "障碍物").Where(p => p.txtStatus != "运行").Where(p => p.txtStatus != "暂停").Where(p => p.txtStatus != "停止").ToList();
                                ////IList<AGV_DisMember> alarmlist = DisMember.Where(p => !p.txtStatus.Contains("无效") || !p.txtStatus.Contains("障碍物") || p.txtStatus.Contains("运行") || p.txtStatus.Contains("暂停") || p.txtStatus.Contains("停止")).ToList();
                                //IList<AGV_DisMember> alarmlistFlag = new List<AGV_DisMember>();                      
                                //foreach(var m in alarmlist)
                                //{
                                //    AGV_DisMember a = new AGV_DisMember();
                                //    a.txtStatus=m.txtStatus;
                                //    a.txtAGVNum=m.txtAGVNum;
                                //    alarmlistFlag.Add(a);
                                //}
                                ////更新侧边栏数据源
                                //dataGrid1.DataContext = alarmlistFlag;

                                //#endregion
                            }

                            dislable[iagvnum - 1].ToolTip = temp1.txtStatus.Trim();
                            myLineStoryboard[iagvnum - 1].Pause(this);
                            //    dislable[iagvnum - 1].BeginAnimation(OpacityProperty, CarWarnningAnimation);

                            //过滤掉频繁出现的报警(将报警信息以服务的形式分发出去)
                            if (!temp1.txtStatus.Contains("障碍物") && !temp1.txtStatus.Contains("停止") && !temp1.txtStatus.Contains("急停"))
                            {
                                AgvAlarmServiceLibrary.AlarmInfo info = new AgvAlarmServiceLibrary.AlarmInfo();
                                info.AgvId = iagvnum;
                                info.Route = int.Parse(temp1.txtLineNum);
                                info.Mark = int.Parse(temp1.txtMarkNum);
                                info.WorkLine = int.Parse(temp1.txtWorkLine);
                                info.AlarmTime = txttimer;
                                info.Area = GlobalPara.areaName;
                                info.Type = temp1.txtStatus;

                                if (host != null && host.State == CommunicationState.Opened)
                                {
                                    if (AgvAlarmServiceLibrary.AgvAlarmService.userCallBackList != null)
                                    {
                                        foreach (AgvAlarmServiceLibrary.ISrvToClientCallBack callback in AgvAlarmServiceLibrary.AgvAlarmService.userCallBackList)
                                        {
                                            callback.NotifyClientAlarm(info);
                                        }
                                    }
                                }
                            }
                            break;
                        }
                }
            }
        }

        /// <summary>
        /// 无线连接属性更改时触发的事件
        /// </summary>
        /// <param name="temp1">AGV_DisMember类</param>
        private void WLChangeAction(AGV_DisMember temp1)
        {
            //int iagvnum = Convert.ToInt16(temp1.txtAGVNum.Remove(0, 3));
            int iagvnum = string.IsNullOrEmpty(temp1.txtAGVNum) ? 0 : Convert.ToInt16(temp1.txtAGVNum);
            if (temp1.txtWLValue.Equals("失败"))
            {
                //    sendOffilineExMsg(temp1);
                canvas.Children.Remove(startellipse[iagvnum - 1]);
                canvas.Children.Remove(endellipse[iagvnum - 1]);
                canvas.Children.Remove(dislable[iagvnum - 1]);
                canvas.Children.Remove(Dottedline[iagvnum - 1]);
                canvas.Children.Remove(animatedImage[iagvnum - 1]);
                myLineStoryboard[iagvnum - 1].Pause(this);

                //清除检测单元中漏读记录
                if (chechCardUnits != null && chechCardUnits[iagvnum - 1] != null)
                {
                    chechCardUnits[iagvnum - 1].missPoints.Clear();
                }

                return;
            }
            else
            {
                myLineStoryboard[iagvnum - 1].Resume(this);
                MarkChangeAction(temp1);
            }
        }

        private void TrafficChangeAction(AGV_DisMember temp)
        {
            #region 管制区的管理
            int AGVNUM = Convert.ToInt16(temp.txtAGVNum);
            AGVInfoModel agvinfo = GlobalPara.AgvInfoDic[AGVNUM];
            List<TrafficAreaModel> outTrafficList = new List<TrafficAreaModel>();
            //agvinfo.TRAFFICNUM.CopyTo(currentTrafficList.ToArray(),0);
            outTrafficList.AddRange(agvinfo.PTRAFFICNUM);
            //循环获取新管制区列表中的管制区对象
            foreach (TrafficAreaModel traffic in agvinfo.TRAFFICNUM)
            {
                //更新AGV的管制区对象列表
                if (!agvinfo.TRAFFICNUM.Contains(traffic))
                {
                    //添加最新的管制区
                    agvinfo.AddTraffic(traffic);
                    //currentTrafficList把存在新管制区对象列表的对象，从就管制区列表中删除。
                    //这样就管制区对象列表就只有AGV之前经过的管制区对象，现在AGV已经退出这些管制区了。
                    //currentTrafficList,到最后就只记录了AGV退出的那些管制区。
                    traffic.AGVINTER(agvinfo, false);
                }
                if (outTrafficList.Contains(traffic))
                {
                    outTrafficList.Remove(traffic);
                    //agvinfo.RemoveTraffic(traffic);//AGV退出该管制区
                    traffic.AGVLEAVE(agvinfo);//管制区有AGV离开
                }
            }
            //循环把AGV已经退出的管制区给清除掉。
            foreach (TrafficAreaModel traffic in outTrafficList)
            {
                agvinfo.RemoveTraffic(traffic);//清空之前，先做一些处理。让AGV退出的那些管制区解除管制状态。
            }

            #endregion

            #region 管制逻辑
            /***
            if (agvinfo.TRAFFICNUM.Count == 1)
            {
                #region 车子现在在某独立管制区
                //1：车子在某独立管制区
                foreach (TrafficAreaModel newTraffic in agvinfo.TRAFFICNUM)
                {
                    if (agvinfo.PTRAFFICNUM.Count > 1)
                    {
                               
                        //1.1：AGV前一个管制区是交叉管制区
                        foreach (var oldtraffic in agvinfo.PTRAFFICNUM)
                        {
                            //AGV退出前交叉管制区
                            if(oldtraffic!=newTraffic)
                            {
                                //找出现在这个管制区以外的其他管制区，全部退出
                                oldtraffic.OutTraffic(agvinfo);
                                if (agvinfo.TRAFFICNUM.Contains(oldtraffic))
                                {
                                    //agvinfo.TRAFFICNUM.Remove(oldtraffic);
                                    agvinfo.RemoveTraffic(oldtraffic);
                                }
                            }
                        }
                    }
                    else if (agvinfo.PTRAFFICNUM.Count == 1)
                    {
                                
                        //1.2：AGV前一个管制区是独立管制区
                        foreach (var oldtraffic in agvinfo.PTRAFFICNUM)
                        {
                            if (oldtraffic != newTraffic)
                            {
                                //找出现在这个管制区以外的其他管制区，全部退出
                                oldtraffic.OutTraffic(agvinfo);
                                if (agvinfo.TRAFFICNUM.Contains(oldtraffic))
                                {
                                    //agvinfo.TRAFFICNUM.Remove(oldtraffic);
                                    agvinfo.RemoveTraffic(oldtraffic);
                                }

                            }
                            else
                            {
                                newTraffic.InTraffic(agvinfo);
                                if (!agvinfo.PTRAFFICNUM.Contains(newTraffic))
                                {
                                            
                                    //agvinfo.TRAFFICNUM.Add(newTraffic);
                                    agvinfo.AddTraffic(newTraffic);
                                }
                            }
                        }
                    }
                    else
                    {
                        //1.3：AGV之前是在管制区外面
                        newTraffic.InTraffic(agvinfo);
                        if (!agvinfo.PTRAFFICNUM.Contains(newTraffic))
                        {
                            //agvinfo.TRAFFICNUM.Add(newTraffic);
                            agvinfo.AddTraffic(newTraffic);
                        }
                    }
                }
                #endregion
            }
            else if (agvinfo.TRAFFICNUM.Count > 1)
            {
                #region 车子进到了交叉管制区里面，多个管制区
                //2：车子进到了交叉管制区里面，多个管制区

                if (agvinfo.PTRAFFICNUM.Count <= 1)
                {
                    //2.1从管制区外面进入交叉管制区
                    //2.2从独立管制区进入交叉管制区
                    foreach (var traffic in agvinfo.TRAFFICNUM)
                    {
                        if (!agvinfo.PTRAFFICNUM.Contains(traffic))
                        {
                            //我进入交叉管制区
                            traffic.InMixTraffic(agvinfo);

                            //agvinfo.TRAFFICNUM.Add(traffic);
                            agvinfo.AddTraffic(traffic);
                            //查看交叉管制区有没有车先进入，
                            //有则放行那辆先进的车，没有车我则停留在交叉管制区前，直到有第二辆车进来把我放行了
                            if (traffic.MainAgv != agvinfo.AGVNUM)
                            {
                                GlobalPara.AgvInfoDic[traffic.MainAgv].TrafficFlag = false;
                                GlobalPara.AgvInfoDic[traffic.MainAgv].TRAFFICAGV = 0;
                            }
                        }
                    }
                }
                else
                {
                    //2.3:车子在一个交叉管制区进入到另一个交叉管制区？？未知情况
                }
                        
                #endregion
            }
            else
            {
                #region 车子不在任何管制区，已出所有管制区
                //3:车子不在任何管制区，已出所有管制区
                if (agvinfo.PTRAFFICNUM.Count > 0)
                {
                    foreach (var t in agvinfo.PTRAFFICNUM)
                    {
                        t.OutTraffic(agvinfo);
                        agvinfo.RemoveTraffic(t);
                    }
                    if (agvinfo.TRAFFICNUM.Count > 0)
                    {
                        //agvinfo.TRAFFICNUM.Clear();
                        agvinfo.ClearTraffic();
                    }
                }
                #endregion
            }
            **/
            #endregion
        }

        private void DrawCarInPoint(Point point, Brush color, int agvnum)
        {
            Point startpoint = point;

            myLineStoryboard[agvnum - 1].Children.Clear();

            Canvas.SetLeft(startellipse[agvnum - 1], startpoint.X - 5);

            Canvas.SetTop(startellipse[agvnum - 1], startpoint.Y - 5);

            startellipse[agvnum - 1].Fill = color;

            canvas.Children.Remove(startellipse[agvnum - 1]);

            canvas.Children.Remove(dislable[agvnum - 1]);

            canvas.Children.Add(startellipse[agvnum - 1]);

            canvas.Children.Add(dislable[agvnum - 1]);

            Canvas.SetTop(dislable[agvnum - 1], startpoint.Y - 5);
            Canvas.SetLeft(dislable[agvnum - 1], startpoint.X - 5);
        }



        /// <summary>
        /// 更新AGV编号和线路
        /// </summary>
        /// <param name="points"></param>
        /// <param name="color"></param>
        /// <param name="agvnum"></param>
        /// <param name="animationtime"></param>
        private void DrawCarLine(List<Point> points, Brush color, int agvnum, double animationtime)
        {
            Point startpoint = points[0];
            Point endpoint = points[points.Count - 1];
            myLineStoryboard[agvnum - 1].Children.Clear();
            Canvas.SetLeft(startellipse[agvnum - 1], startpoint.X - 5);
            Canvas.SetTop(startellipse[agvnum - 1], startpoint.Y - 5);
            Canvas.SetLeft(endellipse[agvnum - 1], endpoint.X - 5);
            Canvas.SetTop(endellipse[agvnum - 1], endpoint.Y - 5);

            endellipse[agvnum - 1].Fill = color;
            startellipse[agvnum - 1].Fill = color;

            canvas.Children.Remove(startellipse[agvnum - 1]);
            canvas.Children.Remove(endellipse[agvnum - 1]);
            canvas.Children.Remove(dislable[agvnum - 1]);
            canvas.Children.Remove(Dottedline[agvnum - 1]);
            canvas.Children.Add(startellipse[agvnum - 1]);
            canvas.Children.Add(endellipse[agvnum - 1]);
            canvas.Children.Add(dislable[agvnum - 1]);

            Canvas.SetTop(dislable[agvnum - 1], -this.dislable[agvnum - 1].ActualHeight);
            Canvas.SetLeft(dislable[agvnum - 1], -this.dislable[agvnum - 1].ActualWidth / 2);

            Canvas.SetTop(animatedImage[agvnum - 1], -this.animatedImage[agvnum - 1].ActualHeight / 2);
            Canvas.SetLeft(animatedImage[agvnum - 1], -this.animatedImage[agvnum - 1].ActualWidth / 2);

            // Create the animation path.
            PathGeometry animationPath = new PathGeometry();
            PathFigure pFigure = new PathFigure();
            pFigure.StartPoint = points[0];
            PolyLineSegment pLineSegment = new PolyLineSegment();
            for (int i = 1; i < points.Count; i++)
            {
                pLineSegment.Points.Add(points[i]);
            }
            pFigure.Segments.Add(pLineSegment);
            animationPath.Figures.Add(pFigure);

            Dottedline[agvnum - 1].Data = animationPath;
            canvas.Children.Add(Dottedline[agvnum - 1]);

            animationX[agvnum - 1].PathGeometry = animationPath;
            animationX[agvnum - 1].Duration = new Duration(TimeSpan.FromMilliseconds(animationtime * 1000));

            animationY[agvnum - 1].PathGeometry = animationPath;
            animationY[agvnum - 1].Duration = animationX[agvnum - 1].Duration;

            animationAngle[agvnum - 1].PathGeometry = animationPath;
            animationAngle[agvnum - 1].Duration = animationX[agvnum - 1].Duration;

            myLineStoryboard[agvnum - 1].Children.Add(animationX[agvnum - 1]);
            myLineStoryboard[agvnum - 1].Children.Add(animationY[agvnum - 1]);
            myLineStoryboard[agvnum - 1].Children.Add(animationAngle[agvnum - 1]);
            myLineStoryboard[agvnum - 1].Begin(this, true);
        }

        #endregion
        #endregion

        #region AGV控制区

        byte DrvWlConGetBCC(byte[] buf, int length)   //取异或校验码
        {
            int bcc = 0, i = 0;
            for (i = 0; i < length; i++)
            {
                bcc = bcc ^ (buf[i]);
            }
            return Convert.ToByte(bcc);
        }

        byte DrvWlConGetBCC(List<byte> buf, int length)   //取异或校验码
        {
            int bcc = 0, i = 0;
            for (i = 0; i < length; i++)
            {
                bcc = bcc ^ (buf[i]);
            }
            return Convert.ToByte(bcc);
        }

        byte DrvWlConCheck(byte[] buf, byte length)   //判断一帧数据正确性
        {
            if ((buf[0]) != 0x10)
            {
                return VERIFY_HEADERROR;  //头错误
            }
            else if ((buf[buf.Length - 1]) != 0x03)
            {
                return VERIFY_ENDERROR;    //尾错误
            }
            else if ((buf[1]) != 0x62 && (buf[1]) != 0x72)  //功能码错误
            {
                return VERIFY_FUNERROR;
            }
            else if (DrvWlConGetBCC(buf, length) != buf[buf.Length - 2])
            {
                return VERIFY_BCCERROR;  // 校验错误 
            }
            else
            {
                return VERIFY_NOERROR;
            }
        }

        bool DrvWlConCheck(List<byte> buf, byte length, out byte verify)   //判断一帧数据正确性
        {
            if ((buf[0]) != 0x10)
            {
                verify = VERIFY_HEADERROR;  //头错误
                return false;
            }
            else if ((buf[buf.Count - 1]) != 0x03)
            {
                verify = VERIFY_ENDERROR;    //尾错误
                return false;
            }
            else if ((buf[1]) != 0x62 && (buf[1]) != 0x72 && !GlobalPara.UseNewProtrol)  //功能码错误
            {
                verify = VERIFY_FUNERROR;
                return false;
            }
            else if (GlobalPara.UseNewProtrol && (buf[1]) != 0x64)  //功能码错误
            {
                verify = VERIFY_FUNERROR;
                return false;
            }
            else if (!GlobalPara.UseNewProtrol && DrvWlConGetBCC(buf, length) != buf[10 - 2])//buf[buf.Count - 2])
            {
                verify = VERIFY_BCCERROR;  // 校验错误 
                return false;
            }
            else if (GlobalPara.UseNewProtrol && DrvWlConGetBCC(buf, length) != buf[24 - 2])//buf[buf.Count - 2])
            {
                verify = VERIFY_BCCERROR;  // 校验错误 
                return false;
            }     
            else
            {
                verify = VERIFY_NOERROR;
                return true;
            }
        }

        #endregion

        #region 界面消息响应
        /// <summary>
        /// 系统打开
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btn_OpenSystem_Click(object sender, RoutedEventArgs e)
        {
            Stopwatch sw = new Stopwatch();

            if (IsOpenSystem)
            {
                MessageBox.Show("系统已启动!");
                return;
            }
            try
            {
                //AGVInfoModel a = new AGVInfoModel();
                sw.Start();
                TimerInit();//定时器初始化
                sw.Stop();
                Console.WriteLine("定时器初始化总共花费{0}s.", sw.Elapsed.TotalSeconds);
                sw.Restart();
                //  InitBuffer();//缓存区初始化
                sw.Stop();
                Console.WriteLine("缓存区初始化总共花费{0}s.", sw.Elapsed.TotalSeconds);
                //AGVGridInit2(AGVNUM_MAX);//初始化AGV绑定列表数据
                sw.Restart();
                //交通管制串口
                if ((GlobalPara.type == 0 && SPComCOntrolList == null) || (GlobalPara.type == 1 && communication == null))
                {
                    COMInit();
                }
                if (GlobalPara.type == 0)
                {
                    for (int i = 0; i < SPComCOntrolList.Count; i++)
                    {
                        if (SPComCOntrolList[i] != null && !SPComCOntrolList[i].IsOpen)
                        {
                            SPComCOntrolList[i].portname = GlobalPara.ComNameList[i];
                            try
                            {
                                SPComCOntrolList[i].Open();
                                SPComCOntrolList[i].DiscardInBuffer();
                                //SPComCOntrolList[i].Write(buf_trafficctl, 0, buf_trafficctl.Length);
                                SPComCOntrolList[i].Write(buf_trafficct3, 0, buf_trafficct3.Length);
                            }
                            catch (System.Exception ex)
                            {
                                if (MessageBox.Show(string.Format("{0}打开失败，是否继续？", GlobalPara.ComNameList[i]), "Error", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
                                    ;
                                else
                                    return;
                            }


                        }
                    }
                }
                else if (GlobalPara.type == 1)
                {
                    for (int i = 0; i < SPComCOntrolList2.Count; i++)
                    {
                        if (SPComCOntrolList2[i] != null && !SPComCOntrolList2[i].IsOpen)
                        {
                            SPComCOntrolList2[i].portname = GlobalPara.ComNameList[i];
                            try
                            {
                                SPComCOntrolList2[i].Open();
                                SPComCOntrolList2[i].DiscardInBuffer();
                                //SPComCOntrolList[i].Write(buf_trafficctl, 0, buf_trafficctl.Length);
                                //SPComCOntrolList2[i].Write(buf_trafficct3, 0, buf_trafficct3.Length);
                            }
                            catch (System.Exception ex)
                            {
                                if (MessageBox.Show(string.Format("{0}打开失败，是否继续？", GlobalPara.ComNameList[i]), "Error", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
                                    ;
                                else
                                    return;
                            }


                        }
                    }
                    if (!communication.IsOpen)
                    {
                        communication.Open();
                        //communication.SendData(buf_trafficctl, null);
                        for (int i = 0; i < 5; i++)
                        {
                            //    communication.SendData(buf_trafficct3, null);
                            //    Thread.Sleep(200);
                        }
                    }
                }
                if (GlobalPara.IsEnableDataShare)
                {
                    Thread t1 = new Thread(new ThreadStart(delegate
                    {
                        SendDataToServer();
                    }));
                    t1.IsBackground = true;
                    t1.Start();
                }
                sw.Stop();
                Console.WriteLine("操作（1）总共花费{0}s.", sw.Elapsed.TotalSeconds);
                sw.Restart();
            }
            catch (System.Exception ex)
            {
                MessageBox.Show(ex.StackTrace + " 3251");
                return;
            }
            Array.Clear(buf_virtualtrafficctl, 0, buf_virtualtrafficctl.Length);

            if (!t.IsEnabled)
            {
                t.Start();//开始计时，开始循环
            }

            if (!DataTimer.IsEnabled)
            {
                if (SPComCOntrolList != null)
                {
                    for (int i = 0; i < SPComCOntrolList.Count; i++)
                    {
                        if (SPComCOntrolList[i] != null)
                        {
                            SPComCOntrolList[i].DiscardInBuffer();
                        }
                    }
                }
                DataTimer.Start();//数据发送Timers
            }

            if (GlobalPara.type == 1)
            {
                if (communication != null && communication.IsOpen)
                {
                    imgCOM.Source = new BitmapImage(new Uri("pack://application:,,,/Image/Light_Open_24.png"));
                    lblcomstate.Content = "打开";
                    lblcomstate.Foreground = Brushes.Green;
                }
                else
                    return;
            }
            else if (GlobalPara.type == 0)
            {
                if (SPComCOntrolList != null)
                {
                    string str = "";
                    int errorNum = 0;
                    for (int i = 0; i < SPComCOntrolList.Count; i++)
                    {
                        if (SPComCOntrolList[i].IsOpen)
                        {
                            str += string.Format("{0}打开", SPComCOntrolList[i].portname);
                        }
                        else
                        {
                            errorNum++;
                            str += string.Format("{0}关闭", SPComCOntrolList[i].portname);
                        }
                        if (i < SPComCOntrolList.Count - 1)
                            str += ",";
                    }
                    lblcomstate.ToolTip = str;
                    if (errorNum < SPComCOntrolList.Count)
                    {
                        imgCOM.Source = new BitmapImage(new Uri("pack://application:,,,/Image/Light_Open_24.png"));
                        lblcomstate.Content = "打开";
                        lblcomstate.Foreground = Brushes.Green;
                    }
                    else
                    {
                        return;
                    }
                }
                else
                    return;
            }
            else
            {
                return;
            }
            // Thread.Sleep(2000);
            IsOpenSystem = true;
            GlobalPara.IsRealOpenSystem = true;
            imgSystem.Source = new BitmapImage(new Uri("pack://application:,,,/Image/Light_Open_24.png"));
            lblsystemstate.Content = "打开";
            lblsystemstate.Foreground = Brushes.Green;
            btn_OpenSystem.IsEnabled = false;
            btn_CloseSystem.IsEnabled = true;
            sw.Stop();
            Console.WriteLine("操作（2）总共花费{0}s.", sw.Elapsed.TotalSeconds);
            sw.Restart();
            //  Thread thread = new Thread(Analzye); thread.IsBackground = true;
            //  thread.Start();
            if (ds == null || ds.IsDisposed)
            {
                //Action action = new Action(delegate()
                //{
                //    ds = new DispatchSystem();
                //    ds.Show();
                //});
                //action.BeginInvoke(null, null);
                //     Thread th = new Thread(new ThreadStart(delegate
                //      {
                ds = new DispatchSystem7515();
                ds.Show();
                //    }));                                                                                                                                            
                //   th.IsBackground = true;
                //    th.Start();
            }

            sw.Stop();
            Console.WriteLine("打开窗口总共花费{0}s.", sw.Elapsed.TotalSeconds);
        }

        /// <summary>
        /// 系统关闭
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btn_CloseSystem_Click(object sender, RoutedEventArgs e)
        {
            if (MessageBox.Show(string.Format("{0}将关闭，是否继续?", this.Title), "警告", MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.No)
            {
                return;
            }

            if (!IsOpenSystem)
            {
                MessageBox.Show("系统已关闭!");
                return;
            }
            if (GlobalPara.type == 0)
            {
                if (SPComCOntrolList != null)
                {
                    for (int i = 0; i < SPComCOntrolList.Count; i++)
                    {
                        try
                        {
                            if (SPComCOntrolList[i] != null)
                                SPComCOntrolList[i].Close();
                        }
                        catch (System.Exception ex)
                        {
                            if (MessageBox.Show(string.Format("{0}关闭失败，忽略？", SPComCOntrolList[i].portname), "Error", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
                                ;
                            else
                                return;
                        }
                    }
                }
            }
            else if (GlobalPara.type == 1)
            {
                if (communication != null)
                    communication.Close();
            }
            if (t.IsEnabled)
            {
                t.Stop();
            }
            if (batteryInfoTimer.IsEnabled)
            {
                batteryInfoTimer.Stop();
            }
            if (DataTimer.IsEnabled)
            {
                DataTimer.Stop();
            }

            if (GlobalPara.type == 0)
            {
                for (int i = 0; i < SPComCOntrolList.Count; i++)
                {
                    if (!SPComCOntrolList[i].IsOpen)
                    {
                        imgCOM.Source = new BitmapImage(new Uri("pack://application:,,,/Image/Light_Close_24.png"));
                        lblcomstate.Content = "关闭";
                        lblcomstate.Foreground = Brushes.Red;
                    }
                }
            }
            else if (GlobalPara.type == 1)
            {

                if (!communication.IsOpen)
                {
                    imgCOM.Source = new BitmapImage(new Uri("pack://application:,,,/Image/Light_Close_24.png"));
                    lblcomstate.Content = "关闭";
                    lblcomstate.Foreground = Brushes.Red;
                }

            }
            IsOpenSystem = false;
            //for (int i = 0; i < startellipse.Length; i++)
            //{
            //    if (AgvStatusList[i].WirelessStaus)
            //    {
            //        AgvStatusList[i].WirelessStaus = false;
            //    }
            //}

            imgSystem.Source = new BitmapImage(new Uri("pack://application:,,,/Image/Light_Close_24.png"));
            lblsystemstate.Content = "关闭";
            lblsystemstate.Foreground = Brushes.Red;
            btn_OpenSystem.IsEnabled = true;
            btn_CloseSystem.IsEnabled = false;
            if (ds != null && !ds.IsDisposed)
            {
                ds.Close();
                ds.Dispose();

            }
            string address = "http://" + GlobalPara.HostIP + ":3350";
           
        }

        /// <summary>
        /// 小车控制
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnControl_Click(object sender, RoutedEventArgs e)
        {

            int iAgvnum = this.cb_AgvNum.SelectedIndex;
            int iOperation = this.cb_Operation.SelectedIndex - 1;
            int iSpeed = this.cb_Speed.SelectedIndex;
            buf_runctl[0] = 0x10;
            buf_runctl[1] = 0x71;

            buf_runctl[2] = Convert.ToByte(iAgvnum + 1);


            //修改日期：2014-01-02
            //操作设置添加了“保持现状”功能,按位来设置的
            if (iOperation >= 0 && iOperation < 8)
            {
                buf_runctl[3] = Convert.ToByte((1 << iOperation) | 0x00);
            }
            else
            {
                buf_runctl[3] = 0x00;
            }
            byte linenum = string.IsNullOrEmpty(this.cb_LineNum.Text) ? (byte)0 : Convert.ToByte(this.cb_LineNum.Text);
            buf_runctl[4] = Convert.ToByte(iSpeed);
            buf_runctl[5] = linenum;
            buf_runctl[6] = 0x00;
            buf_runctl[7] = 0x00;
            buf_runctl[8] = DrvWlConGetBCC(buf_runctl, 8);
            buf_runctl[9] = 0x03;
            IsSendCtrl = 1;
        }

        private void cb_AgvNum_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            //修改日期：2014-01-02
            cb_Speed.SelectedIndex = 0;
            cb_Operation.SelectedIndex = 0;
            cb_LineNum.SelectedIndex = 0;
        }
        #endregion

        #region 菜单栏响应消息

        private void AGVPara_Click(object sender, RoutedEventArgs e)
        {
            AGVParaSetting apsdialog = new AGVParaSetting();
            apsdialog.Show();
        }

        private void COM_Click(object sender, RoutedEventArgs e)
        {
            COMSetting csdialog = new COMSetting();
            csdialog.Show();
        }

        private void PassWord_Click(object sender, RoutedEventArgs e)
        {
            PassWordSetting psdialog = new PassWordSetting();
            psdialog.Show();
        }

        private void UserManage_Click(object sender, RoutedEventArgs e)
        {
            UserManage umdialog = new UserManage();
            umdialog.Show();
        }

        private void Mark_Click(object sender, RoutedEventArgs e)
        {
            AGVManage amdialog = new AGVManage("Mark");
            amdialog.Show();
        }

        private void Route_Click(object sender, RoutedEventArgs e)
        {
            AGVManage amdialog = new AGVManage("Route");
            amdialog.Show();
        }
        private void HostRoute_Click(object sender, RoutedEventArgs e)
        {
            //AGVManage amdialog = new AGVManage("NewTraffic");

            //amdialog.Show();
            TrafficManageNew amdialog = new TrafficManageNew();
            amdialog.Show();

        }


        private void Traffic_Click(object sender, RoutedEventArgs e)
        {
            AGVManage amdialog = new AGVManage("Traffic");
            amdialog.Show();
        }

        private void WorkLine_Click(object sender, RoutedEventArgs e)
        {
            WorkLineManage wmdialog = new WorkLineManage();
            wmdialog.Show();
        }

        private void DockArea_Click(object sender, RoutedEventArgs e)
        {
            DockManage dmdialog = new DockManage();
            dmdialog.Show();
        }

        private void Speed_Click(object sender, RoutedEventArgs e)
        {
            SpeedManage smdialog = new SpeedManage();
            smdialog.Show();
        }

        private void Custom_Click(object sender, RoutedEventArgs e)
        {
            CustomManage cmdialog = new CustomManage();
            cmdialog.Show();
        }

        private void Exception_Click(object sender, RoutedEventArgs e)
        {
            ExceptionManage emdialog = new ExceptionManage();
            emdialog.Show();
        }
        private void MapResee_Click(object sender, RoutedEventArgs e)
        {
            canvas.Scale = 1;
            canvas.Offset = new Point(0, 0);
        }
        private void WiressBox_Click(object sender, RoutedEventArgs e)
        {
            WirelessDockingSystem system = new WirelessDockingSystem();
            system.Show();
            GlobalPara.wirelessDockingSystem = system;
        }
        private void Help_Click(object sender, RoutedEventArgs e)
        {
            Help hdialog = new Help();
            hdialog.Show();
        }
        private void AGVControl1_Click(object sender, RoutedEventArgs e)
        {
            AGVSingleControl ac = new AGVSingleControl();
            ac.Show();
        }
        private void AGVControl2_Click(object sender, RoutedEventArgs e)
        {
            AutoRelease ac = new AutoRelease();
            ac.Show();
        }

        private void AGVControl4_Click(object sender, RoutedEventArgs e)
        {
            AGVMonitor ac = new AGVMonitor();
            ac.Show();
        }
        private void AGVControl_Click(object sender, RoutedEventArgs e)
        {
            MenuItem btn = (MenuItem)sender;
            int ActionCode = 0;
            if (btn.Header.ToString().Contains("休眠"))
            {
                ActionCode = 0x20;
                GlobalPara.IsOneKeySleep = true;
                GlobalPara.isSingleControl = false;
            }
            else if (btn.Header.ToString().Contains("唤醒"))
            {
                ActionCode = 0x30;
                GlobalPara.isSingleControl = false;
            }
            else if (btn.Header.ToString().Contains("启动"))
            {
                ActionCode = 0x40;
            }
            else if (btn.Header.ToString().Contains("停止"))
            {
                ActionCode = 0x50;
            }
            if (btn.Header.ToString().Contains("休眠"))
            {
                GlobalPara.IsOneKeySleep = true;
            }
            for (int i = 0; i < 5; i++)
            {
                DispatcherTool.ControlAllAgv(ActionCode);
                Thread.Sleep(20);
            }
            if (btn.Header.ToString().Contains("休眠"))
            {

                SleepAndWakeUpForm saw = new SleepAndWakeUpForm();
                saw.Show();
            }
            if (btn.Header.ToString().Contains("唤醒"))
            {

                GlobalPara.IsOneKeySleep = false;
                SleepAndWakeUpForm saw = new SleepAndWakeUpForm();
                saw.Show();
            }
        }

        #endregion

        #region 在画布中的鼠标处理

        bool MouseLeftPress = false;
        Point lastpoint = new Point(0, 0);
        bool FullScreen = false;
        Point OffsetPoint = new Point(0, 0);
        private void canvas_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            MouseLeftPress = true;
            lastpoint.X = e.GetPosition(null).X + OffsetPoint.X;
            lastpoint.Y = e.GetPosition(null).Y + OffsetPoint.Y;
            this.Cursor = Cursors.Hand;
        }

        private void canvas_MouseMove(object sender, MouseEventArgs e)
        {
            if (MouseLeftPress)
            {
                Point newpoint = e.GetPosition(null);
                canvas.Offset = new Point(lastpoint.X - newpoint.X, lastpoint.Y - newpoint.Y);
            }
        }

        private void canvas_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
        {
            MouseLeftPress = false;
            this.Cursor = Cursors.Arrow;
            OffsetPoint = canvas.Offset;
        }

        private void canvas_MouseLeave(object sender, MouseEventArgs e)
        {
            MouseLeftPress = false;
        }

        private void canvas_MouseRightButtonDown(object sender, MouseButtonEventArgs e)
        {
            FullScreen = !FullScreen;
            if (FullScreen)
            {
                Panel.SetZIndex(canvas, 30);
                /************************************************************************/
                /* 修改日期：2014.7.25
                 * 修改说明：实现了电子地图的全屏显示
                 修改者：肖丁铭*/
                /************************************************************************/
                menu1.Visibility = Visibility.Hidden;
                status1.Visibility = Visibility.Hidden;
                dataGrid1.Visibility = Visibility.Hidden;
                this.WindowStyle = WindowStyle.None;
                this.WindowState = WindowState.Maximized;
            }
            else
            {
                Panel.SetZIndex(canvas, 0);
                canvas.Scale = 1;
                canvas.Offset = new Point(0, 0);
                /************************************************************************/
                /* 修改日期：2014.7.25
                 * 修改说明：实现了电子地图的全屏显示
                 修改者：肖丁铭*/
                /************************************************************************/
                this.WindowStyle = WindowStyle.SingleBorderWindow;
                this.WindowState = WindowState.Maximized;
                menu1.Visibility = Visibility.Visible;
                status1.Visibility = Visibility.Visible;
            }
        }

        private void mCanvas_MouseWheel(object sender, MouseWheelEventArgs e)
        {
            Point zoomCenter = e.GetPosition(this.canvas);
            canvas.Scale += e.Delta / 1000.0;
            //最大放大十倍
            if (canvas.Scale > 10)
            {
                canvas.Scale = 10;
            }
            //缩小可以小到3倍
            if (canvas.Scale < 0.3)
            {
                canvas.Scale = 0.3;
            }
        }
        #endregion

        #region 加密狗事件插拨通知

        //加密狗变量定义，类中包含了加密狗的读写密码及其他信息
        SoftKey ytsoftkey = new SoftKey();

        /// <summary>
        /// 注册加密锁事件插拨通知
        /// </summary>
        void RegisterDeviceNotification()
        {
            Win32.DEV_BROADCAST_DEVICEINTERFACE dbi = new
                Win32.DEV_BROADCAST_DEVICEINTERFACE();
            int size = Marshal.SizeOf(dbi);
            dbi.dbcc_size = size;
            dbi.dbcc_devicetype = Win32.DBT_DEVTYP_DEVICEINTERFACE;
            dbi.dbcc_reserved = 0;
            dbi.dbcc_classguid = Win32.GUID_DEVINTERFACE_USB_DEVICE;
            dbi.dbcc_name = 0;
            IntPtr buffer = Marshal.AllocHGlobal(size);
            Marshal.StructureToPtr(dbi, buffer, true);
            WindowInteropHelper helper = new WindowInteropHelper(this);
            IntPtr ptr = helper.Handle;
            IntPtr r = Win32.RegisterDeviceNotification(ptr, buffer,
                Win32.DEVICE_NOTIFY_WINDOW_HANDLE);
            if (r == IntPtr.Zero)
                MessageBox.Show(Win32.GetLastError().ToString() + " 3680");
        }

        void win_SourceInitialized(object sender, EventArgs e)
        {
            HwndSource hwndSource = PresentationSource.FromVisual(this) as HwndSource;
            if (hwndSource != null)
            {
                hwndSource.AddHook(new HwndSourceHook(WndProc));
            }

        }

        protected override void OnSourceInitialized(EventArgs e)
        {
            base.OnSourceInitialized(e);
            this.win_SourceInitialized(this, e);
        }

        protected virtual IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
        {
            switch (msg)
            {
                case Win32.WM_DEVICECHANGE:
                    OnDeviceChange(msg);
                    break;
            }
            return IntPtr.Zero;
        }

        void OnDeviceChange(int msg)
        {
            int wParam = 32772;
            int lParam = 170714116;
            if ((int)wParam == Win32.DBT_DEVICEARRIVAL)
            {
                int devType = Marshal.ReadInt32((int)lParam, 4);
                if (devType == Win32.DBT_DEVTYP_DEVICEINTERFACE)
                {
                    Win32.DEV_BROADCAST_DEVICEINTERFACE1 DeviceInfo = (Win32.DEV_BROADCAST_DEVICEINTERFACE1)Marshal.PtrToStructure((IntPtr)lParam, typeof(Win32.DEV_BROADCAST_DEVICEINTERFACE1));
                }
            }
            if ((int)wParam == Win32.DBT_DEVICEREMOVECOMPLETE)
            {
                if (ytsoftkey.CheckKeyByEncstring_New() != 0)
                {
                    //this._loading.Visibility = Visibility.Visible;
                }
            }
        }

        #endregion

        #region 界面鼠标单击事件（杂项）
        private void LookUpData_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                string date = string.Format(@"Link\{0}.xls", DateTime.Now.ToString("yyyy-MM-dd"));
                string tempFile = string.Format(@"{0}\{1}.xls", System.IO.Path.GetTempPath(), DateTime.Now.ToString("yyyy-MM-dd"));
                System.IO.File.Copy(date, tempFile, true);
                Process.Start(tempFile);
            }
            catch (System.Exception ex)
            {
                MessageBox.Show(ex.Message + " 3745");
            }

        }
        protected override void OnClosing(CancelEventArgs e)
        {
            if (MessageBox.Show(string.Format("{0}将关闭，是否继续?", this.Title), "警告", MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.No)
            {
                e.Cancel = true;
            }
            else
            {

                foreach (Iplugin p in PluginLoader.pluginList)
                {
                    p.Close();
                }
                foreach (AgvStatusTimeSpan agv in useRateTimeList)
                {
                    agv.Close();
                }
                base.OnClosing(e);
            }

        }

        private void OpenAlarmService_Click(object sender, RoutedEventArgs e)
        {
            if (host == null || host.State == CommunicationState.Closed)
            {
                host = new System.ServiceModel.ServiceHost(typeof(AgvAlarmServiceLibrary.AgvAlarmService));

                NetTcpBinding binding = new NetTcpBinding(SecurityMode.None);
                string address = string.Format(@"net.tcp://{0}:10000/AgvAlarmService", GlobalPara.HostIP);
                host.AddServiceEndpoint(typeof(AgvAlarmServiceLibrary.IAgvAlarmService), binding, address);
                if (host.Description.Behaviors.Find<System.ServiceModel.Description.ServiceMetadataBehavior>() == null)
                {
                    ServiceMetadataBehavior behavior = new ServiceMetadataBehavior();
                    behavior.HttpGetEnabled = true;
                    string httpAddress = string.Format(@"http://{0}:10001/AgvAlarmService", GlobalPara.HostIP);
                    behavior.HttpGetUrl = new Uri(httpAddress);

                    host.Description.Behaviors.Add(behavior);
                }

            }
            try
            {
                host.Open();
                MessageBox.Show("成功开启报警服务");
                OpenAlarmService.IsEnabled = false;
                CloseAlarmService.IsEnabled = true;
            }
            catch (System.Exception ex)
            {
                MessageBox.Show(string.Format("{0}", ex.Message), "错误", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        private void CloseAlarmService_Click(object sender, RoutedEventArgs e)
        {
            try
            {

                if (host != null)
                {
                    if (host.State == CommunicationState.Opened)
                    {
                        if (AgvAlarmServiceLibrary.AgvAlarmService.userCallBackList != null)
                        {
                            foreach (AgvAlarmServiceLibrary.ISrvToClientCallBack callback in AgvAlarmServiceLibrary.AgvAlarmService.userCallBackList)
                            {
                                callback.NotifyClient("服务端已下线");
                            }
                        }
                    }
                    Action action = delegate { host.Close(); };
                    //host.Close();
                    action.BeginInvoke(null, null);
                    MessageBox.Show("成功关闭报警服务");
                    OpenAlarmService.IsEnabled = true;
                    CloseAlarmService.IsEnabled = false;

                }


            }
            catch (System.Exception ex)
            {
                //Console.WriteLine(ex.Message);
                MessageBox.Show(string.Format("{0}", ex.Message), "错误", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        void LoadPlugins()
        {
            try
            {
                PluginLoader.LoadAllPlugins();
                foreach (Iplugin p in PluginLoader.pluginList)
                {
                    p.InitPlugin();
                }
            }
            catch (System.Exception ex)
            {
                MessageBox.Show(ex.Message + " 3851");
            }
        }
        /// <summary>
        /// 配置数据库连接字
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public static bool SetIndexConfigValue(string key, string value)
        {
            string startPath = System.IO.Path.GetDirectoryName(Process.GetCurrentProcess().MainModule.FileName);
            string pluginPath = System.IO.Path.Combine(startPath, "plugins");
            string pluginPath1 = System.IO.Path.Combine(pluginPath, "UseRate.dll.config");
            if (!Directory.Exists(pluginPath))
            {
                Directory.CreateDirectory(pluginPath);
            }
            if (!File.Exists(pluginPath1))
                throw new Exception(string.Format("配置文件不存在：{0}", pluginPath));
            ExeConfigurationFileMap ecf = new ExeConfigurationFileMap();
            ecf.ExeConfigFilename = pluginPath1;
            Configuration config = ConfigurationManager.OpenMappedExeConfiguration(ecf, ConfigurationUserLevel.None);
            config.AppSettings.Settings[key].Value = value;
            config.Save();
            return true;
        }
        private void MenuItem_Click(object sender, RoutedEventArgs e)
        {
            using (SqlConnection con = new SqlConnection(ConfigurationManager.AppSettings["ConnString"]))
            {
                con.Open();
                string strCon = string.Format("Data Source={0};Initial Catalog={1};Integrated Security={2}", con.DataSource, con.Database, "True");
                SetIndexConfigValue("ConnectStr", strCon);
                con.Close();
            }


        }

        public object GetControl(string ctrlName)
        {
            return FindName(ctrlName);
        }

        /// <summary>
        /// 标题栏鼠标左键按下事件（隐藏或显示侧边栏）
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Image_MouseDown(object sender, MouseButtonEventArgs e)
        {
            if (dataGrid1.Width > 10)
            {
                dataGrid1.Width = 10;
            }
            else
            {
                dataGrid1.Width = 200;
            }

        }
        #endregion
        void sendOffilineExMsg(AGV_DisMember agvinfo)
        {
            byte[] buf_ShareDate = { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03 };
            buf_ShareDate[1] = byte.Parse(agvinfo.txtAGVNum);
            int mark = int.Parse(agvinfo.txtMarkNum);
            buf_ShareDate[2] = (byte)((mark & 0xff00) >> 8);
            buf_ShareDate[3] = (byte)(mark & 0x00ff);
            buf_ShareDate[4] = byte.Parse(agvinfo.txtLineNum);
            buf_ShareDate[6] = 0x00;
            buf_ShareDate[7] = 0x03;
            buf_ShareDate[12] = DrvWlConGetBCC(buf_ShareDate, 12);
            socketclient.socket_send(buf_ShareDate);
        }
        public void Clear_Click(object sender, EventArgs e)
        {
            string pwd = Microsoft.VisualBasic.Interaction.InputBox("请输入密码", "提示", "", -1, -1);
            if (pwd == "casun36689")
            {
                if (MessageBox.Show("是否清空所有地标、路线、管制区", "警告", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
                {
                    string sql = "truncate table dbo.T_Ex;";
                    sql += "truncate table dbo.T_Line;";
                    sql += "truncate table dbo.T_Mark;";
                    sql += "truncate table dbo.T_Traffic;";
                    DAL.ZSql sql1 = new DAL.ZSql();
                    sql1.Open(sql);
                    sql1.Close();
                    MessageBox.Show("清除成功，请重启程序");
                }
            }
            else
            {
                MessageBox.Show("密码错误");
            }
        }
        /// <summary>
        /// 增加最小化出来事件-12-12
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Window_StateChanged(object sender, EventArgs e)
        {
            //if (this.WindowState == WindowState.Minimized)
            //{
            //    this.Hide();
            //}

            //if (this.WindowState == WindowState.Maximized || this.WindowState == WindowState.Normal)

            //{
            //    this.Show();
            //    this.Activate();
            //}

        }
        /// <summary>
        /// 处理调度的协议
        /// </summary>
        private void Analzye()
        {
            while (true)
            {
                try
                {
                    while (GlobalPara.dispatchList.Count > 0)
                    {
                        byte[] bytes = GlobalPara.dispatchList[0];
                        if (bytes != null)
                        {
                            AnalzyeBytes(bytes);
                            Console.WriteLine("调度模块收到数据:" + GlobalPara.ByteToHexString(bytes));
                            if (GlobalPara.dispatchList.Contains(bytes))
                            {
                                GlobalPara.dispatchList.Remove(bytes);
                            }
                        }
                        else
                        {
                            if (GlobalPara.dispatchList.Contains(bytes))
                            {
                                GlobalPara.dispatchList.Remove(bytes);
                            }
                        }
                    }
                }
                catch (Exception)
                {
                }
                //  Thread.Sleep(50);
            }
        }
        int lastSWAGVNum = -1;
        List<string> BoxMarkList = new List<string>();
        public void AnalzyeBytes(byte[] bytes)
        {
            try
            {
                if (bytes != null && bytes.Length >= 14 && bytes[0] == 0xAA && bytes[1] == 0x11 && bytes[bytes.Length - 1] == 0xAB)
                {
                    int agvnum = (int)bytes[5];
                    if (GlobalPara.isSingleControl && GlobalPara.SingleSWAGVNum == agvnum && lastSWAGVNum != agvnum)
                    {
                        lastSWAGVNum = agvnum;
                        if (bytes[2] == 0x22)
                        {
                            MessageBox.Show(agvnum + "号AGV休眠成功！");
                        }
                        else if (bytes[2] == 0x32)
                        {
                            MessageBox.Show(agvnum + "号AGV唤醒成功！");
                        }
                    }
                    else if (!GlobalPara.isSingleControl)
                    {
                        if (bytes[2] == 0x22)
                        {
                            if (!GlobalPara.SleepAGVNumList.Contains(agvnum))
                            {
                                GlobalPara.SleepAGVNumList.Add(agvnum);
                            }
                            if (GlobalPara.WakeUpAGVNumList.Contains(agvnum))
                            {
                                GlobalPara.WakeUpAGVNumList.Remove(agvnum);
                            }
                        }
                        else if (bytes[2] == 0x32)
                        {
                            if (!GlobalPara.WakeUpAGVNumList.Contains(agvnum))
                            {
                                GlobalPara.WakeUpAGVNumList.Add(agvnum);
                            }
                            if (GlobalPara.SleepAGVNumList.Contains(agvnum))
                            {
                                GlobalPara.SleepAGVNumList.Remove(agvnum);
                            }
                        }
                    }
                }
                else if (bytes != null && bytes.Length >= 14 && bytes[0] == 0x10 && bytes[1] == 0x37)
                {
                    int agvnum = (int)bytes[11];
                    if (GlobalPara.AgvInfoDic.ContainsKey(agvnum))
                    {
                        AGVInfoModel agvinfo = GlobalPara.AgvInfoDic[agvnum];
                        if (agvinfo.RUNSTATUS_Cur != 0x43)
                        {
                            agvinfo.RUNSTATUS_Cur = 0x43;
                            agvinfo.ConnectStatus = true;
                            agvinfo.OffLineCount = 0;
                        }

                        for (int i = 0; i < BoxMarkList.Count; i++)
                        {
                            if (BoxMarkList[i] == (agvinfo.MARKNUM.ToString()))
                            {
                                DispatcherTool.ReleaseAgvOnStop(agvinfo.MARKNUM, agvinfo.ROUTENUM, 0, 1);

                                break;
                            }
                        }
                    }
                    else
                    {
                        // for (int i = 0; i < BoxMarkList.Count; i++)
                        {
                            //if (BoxMarkList[i] == (agvinfo.MARKNUM.ToString()))
                            {
                                DispatcherTool.ReleaseAgvOnStop((int)bytes[9], 0, 0, 1);

                                //      break;
                            }
                        }
                    }
                }
                else if (bytes != null && bytes.Length >= 14 && bytes[0] == 0x10 && bytes[1] == 0x38)
                {
                    int agvnum = (int)bytes[11];
                    if (GlobalPara.AgvInfoDic.ContainsKey(agvnum))
                    {
                        AGVInfoModel agvinfo = GlobalPara.AgvInfoDic[agvnum];
                        if (agvinfo.RUNSTATUS_Cur != 0x40)
                        {
                            agvinfo.RUNSTATUS_Cur = 0x40;
                            agvinfo.ConnectStatus = true;
                            agvinfo.OffLineCount = 0;
                        }
                    }
                }
                else if (bytes != null && bytes.Length >= 14 && bytes[0] == 0x10 && bytes[1] == 0x55)
                {
                    bytes[1] = 0x56;
                    byte checkSum = 0x00;
                    for (int i = 0; i < 12; i++)
                    {
                        checkSum ^= bytes[i];
                    }
                    bytes[12] = checkSum;
                   // GlobalPara.communication.SendData(bytes, null);
                }
            }
            catch (Exception ex)
            {

            }
        }
        public static void ReadingStopPoint(int mark, int route, int times = 7)
        {
            byte[] buffer = new byte[14] { 0x10, 0, 0x30, 0x30, 0x30, 0x50, 0x30, 0x30, 0, 0, 0, 0, 0, 0x03 };
            buffer[DispatcherTool.COM_FUNC] = 0x35;
            int Route = 0x3030 + route;
            buffer[DispatcherTool.COM_ROUTE - 1] = (byte)((Route >> 8) & 0xFF);
            buffer[DispatcherTool.COM_ROUTE] = (byte)(Route & 0xFF);
            buffer[DispatcherTool.COM_MARK] = (byte)((mark & 0xff00) >> 8);
            buffer[DispatcherTool.COM_MARK + 1] = (byte)(mark & 0x00ff);
            buffer[DispatcherTool.COM_CHECK] = DispatcherTool.XOR_Check(buffer, 12);
            // if (!GlobalPara.SendBytesList.Contains(buffer))
            {
                for (int j = 0; j < times; j++)
                {
                    for (int i = 0; i < SPComCOntrolList2.Count; i++)
                    {
                        if (SPComCOntrolList2[i] != null)
                        {
                            SPComCOntrolList2[i].Write(buffer, 0, buffer.Length);

                            System.Threading.Thread.Sleep(100);
                        }
                    }

                }
            }
        }

        public static void ReleaseStopPoint(int mark, int route, string ipAddress = null, int times = 12)
        {
            byte[] buffer = new byte[14] { 0x10, 0, 0x30, 0x30, 0x30, 0x50, 0x30, 0x30, 0, 0, 0, 0, 0, 0x03 };
            buffer[DispatcherTool.COM_FUNC] = 0x38;
            int Route = 0x3030 + route;
            buffer[DispatcherTool.COM_ROUTE - 1] = (byte)((Route >> 8) & 0xFF);
            buffer[DispatcherTool.COM_ROUTE] = (byte)(Route & 0xFF);
            buffer[DispatcherTool.COM_MARK] = (byte)((mark & 0xff00) >> 8);
            buffer[DispatcherTool.COM_MARK + 1] = (byte)(mark & 0x00ff);
            buffer[DispatcherTool.COM_CHECK] = DispatcherTool.XOR_Check(buffer, 12);
            // if (!GlobalPara.SendBytesList.Contains(buffer))
            {
                for (int j = 0; j < times; j++)
                {
                    for (int i = 0; i < SPComCOntrolList2.Count; i++)
                    {
                        if (SPComCOntrolList2[i] != null)
                        {
                            SPComCOntrolList2[i].Write(buffer, 0, buffer.Length);
                            System.Threading.Thread.Sleep(100);
                        }
                    }
                }
            }
        }
    }
}