XS202408319330/Models/Traffic.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace TrafficDll
{
    public class Traffic
    {
        /// 
        /// 凡是在管制区域的等待队列中的AGV都是需要被管制的对象
        /// 被管制区域的主agv
        /// 

        private List<TrafficArea> TrafficAreaList = new List<TrafficArea>();
        private List<TrafficArea> UsageTrafficAreaList = new List<TrafficArea>();
        public object UsageTrafficLock = new object();
        public AGV_WPF.MainWindow.AGVStatus_TypStr[] agvArray;
        public AGV_WPF.MainWindow.AGVStatus_TypStr[] agvArrayOlde;
        public Thread TrafficThread=null;
        public Traffic()
        {
           // AGVStatus
            agvArrayOlde = new AGV_WPF.MainWindow.AGVStatus_TypStr[] { };
            TrafficAreaList = new List<TrafficArea>();
            UsageTrafficAreaList = new List<TrafficArea>();
            TrafficAreaInit();
            
          //  TrafficThread = new Thread(new ParameterizedThreadStart(CheckStatus));
            
        }
        public Traffic(AGV_WPF.MainWindow.AGVStatus_TypStr[] agvArrayNew)
        {
            agvArray = agvArrayNew;
            TrafficAreaList = new List<TrafficArea>();
            UsageTrafficAreaList = new List<TrafficArea>();
            agvArrayOlde = new AGV_WPF.MainWindow.AGVStatus_TypStr[] { };
            TrafficAreaInit();
            //  TrafficThread = new Thread(new ParameterizedThreadStart(CheckStatus));

        }
        private  void TrafficAreaInit()
        {
            DAL.ZSql sql1 = new DAL.ZSql();
            //地标功能定义
            sql1.Open("select * from T_TrafficNew");

            if (sql1.rowcount > 0)
            {
                for (int i = 0; i < sql1.rowcount; i++)
                {
                    TrafficArea trafficArea = new TrafficArea();
                    trafficArea.Number =Convert.ToInt32( sql1.Rows[i][0]);
                    string[] pointAllArrStr = Convert.ToString(sql1.Rows[i][1]).Split(',');
                    string[] pointInsideArrStr = Convert.ToString(sql1.Rows[i][2]).Split(',');
                    string[] pointOutSideArrStr = Convert.ToString(sql1.Rows[i][3]).Split(',');
                    byte type = Convert.ToByte(sql1.Rows[i][4]);
                    trafficArea.PointArr = ToIntArray(pointAllArrStr);
                    trafficArea.PointArrInside = ToIntArray(pointInsideArrStr);
                    trafficArea.PointArrOut = ToIntArray(pointOutSideArrStr);
                    trafficArea.TypeTraffic = type;
                    TrafficAreaList.Add(trafficArea);
                }
                sql1.Close();
            }
            else
            {
               // MessageBox.Show("Warning: please set in the 'Settings' landmark function！");
            }
        }
               // private  void CheckStatus(object agvArray)
        public  void CheckStatus()
        {
            agvArrayOlde = new AGV_WPF.MainWindow.AGVStatus_TypStr[agvArray.Count()];
            while (true)
            {
                //赋值
              //  if (agvArrayOlde.Count() == 0 && agvArray.Count() > 0)
                {
                   
                    for (int i = 0; i < agvArray.Count(); i++)
                    {
                        agvArrayOlde[i].AgvNum = agvArray[i].AgvNum;
                        agvArrayOlde[i].Current = agvArray[i].Current;
                        agvArrayOlde[i].Direction = agvArray[i].Direction;
                        agvArrayOlde[i].LineNum = agvArray[i].LineNum;
                        agvArrayOlde[i].MarkFunction = agvArray[i].MarkFunction;
                        agvArrayOlde[i].MarkNum = agvArray[i].MarkNum;
                        agvArrayOlde[i].Speed = agvArray[i].Speed;
                        agvArrayOlde[i].Status = agvArray[i].Status;
                        agvArrayOlde[i].TrafficNum = agvArray[i].TrafficNum;
                        agvArrayOlde[i].Voltage = agvArray[i].Voltage;
                        agvArrayOlde[i].Wlink_Count = agvArray[i].Wlink_Count;
                        agvArrayOlde[i].WlLink = agvArray[i].WlLink;
                        agvArrayOlde[i].WorkLine = agvArray[i].WorkLine;
                    }
                }
                TrafficManager3();
                #region
              
                #endregion
                Thread.Sleep(20);
            }
        }

        private void TrafficManager(AGV_WPF.MainWindow.AGVStatus_TypStr agv)   //写入AGV的卡号和状态改变的事件中最好
        {
          //  for(int i=0;i<)
            bool flag1 = false;
            bool flag2 = false;
            #region
            if (UsageTrafficAreaList.Count > 0)
            {
                for (int n = 0; n < UsageTrafficAreaList.Count; n++)
                {
                    #region
                    if (UsageTrafficAreaList[n].OccupyAgv.AgvNum == agv.AgvNum)
                    {
                        
                        //判断agv是否出了区域
                        if (!UsageTrafficAreaList[n].PointArr.Contains(agv.MarkNum))
                        {
                            //出了管制区域
                            if (UsageTrafficAreaList[n].WaitAgv.Count() > 0)
                            {
                                AGV_WPF.MainWindow.AGVStatus_TypStr agv1 = EqualAgv(UsageTrafficAreaList[n].WaitAgv[0]);
                                UsageTrafficAreaList[n].OccupyAgv = agv1;
                                UsageTrafficAreaList[n].WaitAgv.RemoveAt(0);
                                continue;
                            }
                            else
                            {
                                UsageTrafficAreaList.RemoveAt(n);
                                n = - 1;
                            }
                        }
                        else
                        {
                           
                        }
                    }
                    else if (UsageTrafficAreaList[n].WaitAgv.Count > 0)
                    {
                        foreach (AGV_WPF.MainWindow.AGVStatus_TypStr agv1 in UsageTrafficAreaList[n].WaitAgv)
                        {
                            if (agv1.AgvNum == agv.AgvNum)
                            {
                                if (!UsageTrafficAreaList[n].PointArr.Contains(agv.MarkNum))
                                {
                                    UsageTrafficAreaList[n].WaitAgv.Remove(agv1);
                                    break;
                                }
                            }
                        }
                    }

                    #endregion
                }
            }
            #endregion
            #region
            if (TrafficAreaList.Count > 0)
            {
                for (int i = 0; i < TrafficAreaList.Count; i++)
                { 
                    # region 
                       if (TrafficAreaList[i].PointArr.Contains(agv.MarkNum))
                        //如果AGV的当前卡号在某个管制区域内
                        {
                            //判断该管制区域是否在激活的管制区域中
                            if (UsageTrafficAreaList.Count == 0)
                            {
                                //将该区域赋值给另一个区域再添加进激活的列表中
                                UsageTrafficAreaList.Add(Equal(TrafficAreaList[i]));
                                UsageTrafficAreaList[0].OccupyAgv = EqualAgv(agv);
                            }
                            #region
                            else if (UsageTrafficAreaList.Count > 0)
                            {
                                for (int m = 0; m < UsageTrafficAreaList.Count; m++)
                                {
                                    //如果当前的管制区域已经是激活的
                                    if (UsageTrafficAreaList[m].Number == TrafficAreaList[i].Number)
                                    {
                                        flag1 = true;
                                        //判断该激活的管制区域中的AGV数量、编号及主AGV的状态
                                        if (UsageTrafficAreaList[m].OccupyAgv.AgvNum == agv.AgvNum)
                                        {
                                           // flag2 = true;
                                            //判断该激活的管制区域中的AGV数量、编号及主AGV的状态
                                            //还在管制区域内  状态为停止时 //0x40运行，0x41暂停，0x42结束地标停止，0x40前的都为报警，0x43停止，0x44当作充电
                                            if (agv.Status == 0x40)
                                            {
                                                continue;
                                            }
                                            else if (agv.Status < 0x40)
                                            {
                                                //if (UsageTrafficAreaList[m].PointArrOut.Contains(agv.MarkNum))
                                                //{
                                                    
                                                //}
                                                continue;
                                            }
                                            else if (agv.Status > 0x40)
                                            {
                                                //判断agv当前点是不是中心点，如果 不是则切换管制区域内主机
                                                if (UsageTrafficAreaList[m].PointArrOut.Contains(agv.AgvNum)&& UsageTrafficAreaList[m].WaitAgv.Count > 0)
                                                {
                                                    UsageTrafficAreaList[m].OccupyAgv = EqualAgv(UsageTrafficAreaList[m].WaitAgv[0]);
                                                    UsageTrafficAreaList[m].WaitAgv.RemoveAt(0);
                                                    continue;
                                                }

                                            }
                                        }
                                        else
                                        {
                                            if (UsageTrafficAreaList[m].WaitAgv.Count > 0)
                                            {
                                                for (int t = 0; t < UsageTrafficAreaList[m].WaitAgv.Count; t++)
                                                {
                                                    if (UsageTrafficAreaList[m].WaitAgv[t].AgvNum == agv.AgvNum)
                                                    {
                                                        flag2 = true;
                                                        if (agv.Status == 0x40)
                                                        {
                                                            //本应该被管制但是没有被管制
                                                            //边缘区域且下一点不是管制区域内，则取消管制

                                                            continue;
                                                        }
                                                        else if (agv.Status > 0x40)
                                                        {
                                                            //在数组中删除该AGV
                                                            continue;
                                                        }
                                                    }
                                                }
                                                if (!flag2)
                                                {
                                                  //  UsageTrafficAreaList[m].WaitAgv.Add(agv);
                                                    AddAgvToWaitList(UsageTrafficAreaList[m].WaitAgv, agv, UsageTrafficAreaList[m].OccupyAgv);
                                                }
                                            }
                                            else   //等待区域没有AGV
                                            {
                                               // UsageTrafficAreaList[m].WaitAgv.Add(agv);
                                                AddAgvToWaitList(UsageTrafficAreaList[m].WaitAgv, agv, UsageTrafficAreaList[m].OccupyAgv);
                                            }
                                        }
                                    }

                                }
                                if (!flag1)   //表示agv所读的卡的区域再管制区域内，但是不在被激活的管制区域内
                                {
                                    TrafficArea trafficNew = Equal(TrafficAreaList[i]);
                                    trafficNew.OccupyAgv = EqualAgv(agv);
                                    UsageTrafficAreaList.Add(Equal(trafficNew));
                                    flag1 = false;
                                }
                            }
                            #endregion
                        }
                        #endregion
                    
                     
                }

            }
           
            #endregion
            
        }

        private void TrafficManager1()   //写入AGV的卡号和状态改变的事件中最好
        {
            AGV_WPF.MainWindow.AGVStatus_TypStr agv;
            lock (UsageTrafficLock)
            {
                for (int tt = 0; tt < agvArrayOlde.Count(); tt++)
                {
                    agv = agvArrayOlde[tt];
                    bool flag1 = false;
                    bool flag2 = false;
                    #region
                    if (UsageTrafficAreaList.Count > 0)
                    {
                        for (int n = 0; n < UsageTrafficAreaList.Count; n++)
                        {
                            #region
                            if (UsageTrafficAreaList[n].OccupyAgv.AgvNum == agv.AgvNum)
                            {
                                //判断车辆是否在线，如果不在线则删除
                                if (agv.WlLink == false)
                                {
                                    //出了管制区域
                                    if (UsageTrafficAreaList[n].WaitAgv.Count() > 0)
                                    {
                                        AGV_WPF.MainWindow.AGVStatus_TypStr agv1 = EqualAgv(UsageTrafficAreaList[n].WaitAgv[0]);
                                        UsageTrafficAreaList[n].OccupyAgv = agv1;
                                        UsageTrafficAreaList[n].WaitAgv.RemoveAt(0);
                                        break;
                                    }
                                    else
                                    {
                                        UsageTrafficAreaList.RemoveAt(n);
                                        n = -1;
                                        break;
                                    }
                                }

                                //判断agv是否出了区域
                                if (!UsageTrafficAreaList[n].PointArr.Contains(agv.MarkNum))
                                {
                                    //出了管制区域
                                    if (UsageTrafficAreaList[n].WaitAgv.Count() > 0)
                                    {
                                        AGV_WPF.MainWindow.AGVStatus_TypStr agv1 = EqualAgv(UsageTrafficAreaList[n].WaitAgv[0]);
                                        UsageTrafficAreaList[n].OccupyAgv = agv1;
                                        UsageTrafficAreaList[n].WaitAgv.RemoveAt(0);
                                        continue;
                                    }
                                    else
                                    {
                                        UsageTrafficAreaList.RemoveAt(n);
                                        n = -1;
                                    }
                                }
                                else
                                {

                                }
                            }
                            else if (UsageTrafficAreaList[n].WaitAgv.Count > 0)
                            {
                                foreach (AGV_WPF.MainWindow.AGVStatus_TypStr agv1 in UsageTrafficAreaList[n].WaitAgv)
                                {
                                    if (agv1.AgvNum == agv.AgvNum)
                                    {
                                        if (!UsageTrafficAreaList[n].PointArr.Contains(agv.MarkNum))
                                        {
                                            UsageTrafficAreaList[n].WaitAgv.Remove(agv1);
                                            break;
                                        }
                                    }
                                }
                            }

                            #endregion
                        }
                    }
                    #endregion
                    #region
                    if (TrafficAreaList.Count > 0)
                    {
                        for (int i = 0; i < TrafficAreaList.Count; i++)
                        {
                            # region
                            if (TrafficAreaList[i].PointArr.Contains(agv.MarkNum))
                            //如果AGV的当前卡号在某个管制区域内
                            {
                                //判断该管制区域是否在激活的管制区域中
                                if (UsageTrafficAreaList.Count == 0)
                                {
                                    //将该区域赋值给另一个区域再添加进激活的列表中
                                    UsageTrafficAreaList.Add(Equal(TrafficAreaList[i]));
                                    UsageTrafficAreaList[0].OccupyAgv = EqualAgv(agv);
                                }
                                #region
                                else if (UsageTrafficAreaList.Count > 0)
                                {
                                    for (int m = 0; m < UsageTrafficAreaList.Count; m++)
                                    {
                                        //如果当前的管制区域已经是激活的
                                        if (UsageTrafficAreaList[m].Number == TrafficAreaList[i].Number)
                                        {
                                            flag1 = true;
                                            //判断该激活的管制区域中的AGV数量、编号及主AGV的状态
                                            //防止出现自己管自己
                                            if (UsageTrafficAreaList[m].OccupyAgv.AgvNum == agv.AgvNum)
                                            {
                                                if (UsageTrafficAreaList[m].WaitAgv.Count > 0)
                                                {
                                                    for (int ii = 0; ii < UsageTrafficAreaList[m].WaitAgv.Count; ii++)
                                                    {
                                                        if (UsageTrafficAreaList[m].WaitAgv[ii].AgvNum == UsageTrafficAreaList[m].OccupyAgv.AgvNum)
                                                        {
                                                            UsageTrafficAreaList[m].WaitAgv.RemoveAt(ii);
                                                        }
                                                    }
                                                }
                                              //  for()
                                                // flag2 = true;
                                                //判断该激活的管制区域中的AGV数量、编号及主AGV的状态
                                                //还在管制区域内  状态为停止时 //0x40运行，0x41暂停，0x42结束地标停止，0x40前的都为报警，0x43停止，0x44当作充电
                                                if (agv.Status == 0x40)
                                                {
                                                    if (UsageTrafficAreaList[m].PointArrOut.Contains(agv.MarkNum))
                                                    {
                                                        if (UsageTrafficAreaList[m].WaitAgv.Count > 0)
                                                        {
                                                            for (int ii = 0; ii < UsageTrafficAreaList[m].WaitAgv.Count; ii++)
                                                            {
                                                                if (UsageTrafficAreaList[m].PointArrInside.Contains(UsageTrafficAreaList[m].WaitAgv[ii].MarkNum))
                                                                {
                                                                    //切换主机
                                                                   // UsageTrafficAreaList[m].WaitAgv.Add();
                                                                    AGV_WPF.MainWindow.AGVStatus_TypStr agvC =new AGV_WPF.MainWindow.AGVStatus_TypStr();
                                                                    agvC = EqualAgv(UsageTrafficAreaList[m].OccupyAgv);
                                                                    UsageTrafficAreaList[m].OccupyAgv = EqualAgv(UsageTrafficAreaList[m].WaitAgv[ii]);
                                                                    UsageTrafficAreaList[m].WaitAgv.RemoveAt(0);
                                                                    UsageTrafficAreaList[m].WaitAgv.Add(agvC);
                                                                    break; 

                                                                }
                                                            }
                                                        }
                                                    }
                                                    continue;
                                                }
                                                else if (agv.Status < 0x40)
                                                {
                                                   
                                                    continue;
                                                }
                                                else if (agv.Status > 0x40)
                                                {
                                                    //判断agv当前点是不是中心点，如果 不是则切换管制区域内主机
                                                    if (UsageTrafficAreaList[m].PointArrOut.Contains(agv.MarkNum) && UsageTrafficAreaList[m].WaitAgv.Count > 0)
                                                    {
                                                        UsageTrafficAreaList[m].OccupyAgv = EqualAgv(UsageTrafficAreaList[m].WaitAgv[0]);
                                                        UsageTrafficAreaList[m].WaitAgv.RemoveAt(0);
                                                        continue;
                                                    }

                                                }
                                            }
                                            else
                                            {
                                                if (UsageTrafficAreaList[m].WaitAgv.Count > 0)
                                                {
                                                    for (int t = 0; t < UsageTrafficAreaList[m].WaitAgv.Count; t++)
                                                    {
                                                        if (UsageTrafficAreaList[m].WaitAgv[t].AgvNum == agv.AgvNum)
                                                        {
                                                            flag2 = true;
                                                            if (agv.Status == 0x40)
                                                            {
                                                                //本应该被管制但是没有被管制
                                                                //边缘区域且下一点不是管制区域内，则取消管制

                                                                continue;
                                                            }
                                                            else if (agv.Status > 0x40)
                                                            {
                                                                //在数组中删除该AGV
                                                                continue;
                                                            }
                                                        }
                                                    }
                                                    if (!flag2)
                                                    {
                                                        //  UsageTrafficAreaList[m].WaitAgv.Add(agv);
                                                        AddAgvToWaitList(UsageTrafficAreaList[m].WaitAgv, agv, UsageTrafficAreaList[m].OccupyAgv);
                                                    }
                                                }
                                                else   //等待区域没有AGV
                                                {
                                                    // UsageTrafficAreaList[m].WaitAgv.Add(agv);
                                                    AddAgvToWaitList(UsageTrafficAreaList[m].WaitAgv, agv, UsageTrafficAreaList[m].OccupyAgv);
                                                }
                                            }
                                        }

                                    }
                                    if (!flag1)   //表示agv所读的卡的区域再管制区域内，但是不在被激活的管制区域内
                                    {
                                        TrafficArea trafficNew = Equal(TrafficAreaList[i]);
                                        trafficNew.OccupyAgv = EqualAgv(agv);
                                        UsageTrafficAreaList.Add(Equal(trafficNew));
                                        flag1 = false;
                                    }
                                }
                                #endregion
                            }
                            #endregion
                        }

                    }

                    #endregion
                }
            }
        }

        private void TrafficManager2()   //写入AGV的卡号和状态改变的事件中最好 ,2.25添加方向
        {
            AGV_WPF.MainWindow.AGVStatus_TypStr agv;
            lock (UsageTrafficLock)
            {
                for (int tt = 0; tt < agvArrayOlde.Count(); tt++)
                {
                    agv = agvArrayOlde[tt];
                    bool flag1 = false;
                    bool flag2 = false;
                    #region
                    if (UsageTrafficAreaList.Count > 0)
                    {
                        for (int n = 0; n < UsageTrafficAreaList.Count; n++)
                        {
                            if (UsageTrafficAreaList[n].OccupyAgv.AgvNum == 0)
                            {
                                if (UsageTrafficAreaList[n].WaitAgv.Count > 0)
                                {
                                    AGV_WPF.MainWindow.AGVStatus_TypStr agv1 = EqualAgv(UsageTrafficAreaList[n].WaitAgv[0]);
                                    UsageTrafficAreaList[n].OccupyAgv = agv1;
                                    UsageTrafficAreaList[n].WaitAgv.RemoveAt(0);
                                    continue;
                                }
                                else
                                {
                                    UsageTrafficAreaList.RemoveAt(n);
                                    n = -1;
                                    continue;
                                }
                            }
                            #region
                            if (UsageTrafficAreaList[n].OccupyAgv.AgvNum == agv.AgvNum)
                            {
                               
                                //判断车辆是否在线，如果不在线则删除
                                if (agv.WlLink == false)
                                {
                                    //出了管制区域
                                    if (UsageTrafficAreaList[n].WaitAgv.Count() > 0)
                                    {
                                        AGV_WPF.MainWindow.AGVStatus_TypStr agv1 = EqualAgv(UsageTrafficAreaList[n].WaitAgv[0]);
                                        UsageTrafficAreaList[n].OccupyAgv = agv1;
                                        UsageTrafficAreaList[n].WaitAgv.RemoveAt(0);
                                        continue;
                                    }
                                    else
                                    {
                                        UsageTrafficAreaList.RemoveAt(n);
                                        n = -1;
                                        continue;
                                    }
                                }

                                //判断agv是否出了区域
                                if (!UsageTrafficAreaList[n].PointArr.Contains(agv.MarkNum))
                                {
                                    //出了管制区域
                                    if (UsageTrafficAreaList[n].WaitAgv.Count() > 0)
                                    {
                                        AGV_WPF.MainWindow.AGVStatus_TypStr agv1 = EqualAgv(UsageTrafficAreaList[n].WaitAgv[0]);
                                        UsageTrafficAreaList[n].OccupyAgv = agv1;
                                        UsageTrafficAreaList[n].WaitAgv.RemoveAt(0);
                                        continue;
                                    }
                                    else
                                    {
                                        UsageTrafficAreaList.RemoveAt(n);
                                        n = -1;
                                        continue;
                                    }
                                }
                                else
                                {

                                }
                            }
                            else if (UsageTrafficAreaList[n].WaitAgv.Count > 0)
                            {
                                foreach (AGV_WPF.MainWindow.AGVStatus_TypStr agv1 in UsageTrafficAreaList[n].WaitAgv)
                                {
                                    if (agv1.AgvNum == agv.AgvNum)
                                    {
                                        if (!UsageTrafficAreaList[n].PointArr.Contains(agv.MarkNum))
                                        {
                                            UsageTrafficAreaList[n].WaitAgv.Remove(agv1);
                                            break;
                                        }
                                    }
                                }
                            }

                            #endregion
                        }
                    }
                    #endregion
                    #region
                    if (TrafficAreaList.Count > 0)
                    {
                        for (int i = 0; i < TrafficAreaList.Count; i++)
                        {
                           
                            if (TrafficAreaList[i].PointArr.Contains(agv.MarkNum))
                            //如果AGV的当前卡号在某个管制区域内
                            {
                                # region
                                //判断该管制区域是否在激活的管制区域中
                                if (UsageTrafficAreaList.Count == 0)
                                {
                                    //将该区域赋值给另一个区域再添加进激活的列表中
                                    UsageTrafficAreaList.Add(Equal(TrafficAreaList[i]));
                                    UsageTrafficAreaList[0].OccupyAgv = EqualAgv(agv);
                                }
                               
                                else if (UsageTrafficAreaList.Count > 0)
                                {
                                    flag1 = false;
                                    #region
                                    for (int m = 0; m < UsageTrafficAreaList.Count; m++)
                                    {
                                        //如果当前的管制区域已经是激活的
                                        if (UsageTrafficAreaList[m].Number == TrafficAreaList[i].Number)
                                        {
                                            flag1 = true;
                                            //判断该激活的管制区域中的AGV数量、编号及主AGV的状态
                                            //防止出现自己管自己
                                           
                                            if (UsageTrafficAreaList[m].OccupyAgv.AgvNum == agv.AgvNum)
                                            {
                                              #region

                                                if (UsageTrafficAreaList[m].WaitAgv.Count > 0)
                                                {
                                                    for (int ii = 0; ii < UsageTrafficAreaList[m].WaitAgv.Count; ii++)
                                                    {
                                                        if (UsageTrafficAreaList[m].WaitAgv[ii].AgvNum == UsageTrafficAreaList[m].OccupyAgv.AgvNum)
                                                        {
                                                            UsageTrafficAreaList[m].WaitAgv.RemoveAt(ii);
                                                        }
                                                    }
                                                }
                                                //  for()
                                                // flag2 = true;
                                                //判断该激活的管制区域中的AGV数量、编号及主AGV的状态
                                                //还在管制区域内  状态为停止时 //0x40运行，0x41暂停，0x42结束地标停止，0x40前的都为报警，0x43停止，0x44当作充电
                                                if (agv.Status == 0x40)
                                                {
                                                   
                                                    continue;
                                                }
                                                else if (agv.Status < 0x40)
                                                {
                                                    continue;
                                                }
                                                else if (agv.Status == 0x42||agv.Status==0x43||agv.Status==0x44)
                                                {
                                                    //判断agv当前点是不是中心点，如果 不是则切换管制区域内主机
                                                    if (UsageTrafficAreaList[m].PointArrOut.Contains(agv.MarkNum) && UsageTrafficAreaList[m].WaitAgv.Count > 0)
                                                    {
                                                        //UsageTrafficAreaList[m].OccupyAgv = EqualAgv(UsageTrafficAreaList[m].WaitAgv[0]);
                                                        //UsageTrafficAreaList[m].WaitAgv.RemoveAt(0);
                                                        AGV_WPF.MainWindow.AGVStatus_TypStr agvC = new AGV_WPF.MainWindow.AGVStatus_TypStr();
                                                        agvC = EqualAgv(UsageTrafficAreaList[m].OccupyAgv);
                                                        UsageTrafficAreaList[m].OccupyAgv = EqualAgv(UsageTrafficAreaList[m].WaitAgv[0]);
                                                        UsageTrafficAreaList[m].WaitAgv.RemoveAt(0);
                                                       // UsageTrafficAreaList[m].WaitAgv.Add
                                                        UsageTrafficAreaList[m].WaitAgv.Add(agvC);
                                                        continue;
                                                    }
                                                }
                                                else if (agv.Status == 0x41)
                                                {
                                                    //判断agv当前点是不是中心点，如果 不是则切换管制区域内主机
                                                    if (UsageTrafficAreaList[m].PointArrOut.Contains(agv.MarkNum) && UsageTrafficAreaList[m].WaitAgv.Count > 0)
                                                    {
                                                        for (int jjj = 0; jjj < UsageTrafficAreaList[m].WaitAgv.Count; jjj++)
                                                        {
                                                            if (!UsageTrafficAreaList[m].PointArrOut.Contains(UsageTrafficAreaList[m].WaitAgv[jjj].MarkNum)
                                                                && UsageTrafficAreaList[m].TypeTraffic!=4)
                                                            {
                                                                //UsageTrafficAreaList[m].OccupyAgv = EqualAgv(UsageTrafficAreaList[m].WaitAgv[0]);
                                                                //UsageTrafficAreaList[m].WaitAgv.RemoveAt(0);
                                                                AGV_WPF.MainWindow.AGVStatus_TypStr agvC = new AGV_WPF.MainWindow.AGVStatus_TypStr();
                                                                agvC = EqualAgv(UsageTrafficAreaList[m].OccupyAgv);
                                                                UsageTrafficAreaList[m].OccupyAgv = EqualAgv(UsageTrafficAreaList[m].WaitAgv[jjj]);
                                                                UsageTrafficAreaList[m].WaitAgv.RemoveAt(jjj);
                                                                // UsageTrafficAreaList[m].WaitAgv.Add
                                                                UsageTrafficAreaList[m].WaitAgv.Add(agvC);
                                                                break;
                                                            }
                                                        }
                                                    }

                                                }
                                               #endregion
                                            }
                                            else
                                            {
                                                if (UsageTrafficAreaList[m].WaitAgv.Count > 0)
                                                {
                                                    #region
                                                    for (int t = 0; t < UsageTrafficAreaList[m].WaitAgv.Count; t++)
                                                    {
                                                        if (UsageTrafficAreaList[m].WaitAgv[t].AgvNum == agv.AgvNum)
                                                        {
                                                            flag2 = true;
                                                            continue;
                                                        }
                                                    }
                                                    if (!flag2)
                                                    {
                                                       if (UsageTrafficAreaList[m].TypeTraffic == 1)
                                                        {
                                                           if(agv.Direction==0)
                                                            AddAgvToWaitList(UsageTrafficAreaList[m].WaitAgv, agv, UsageTrafficAreaList[m].OccupyAgv);
                                                        }
                                                        else if (UsageTrafficAreaList[m].TypeTraffic == 2)
                                                        {
                                                            if (agv.Direction == 1)
                                                            AddAgvToWaitList(UsageTrafficAreaList[m].WaitAgv, agv, UsageTrafficAreaList[m].OccupyAgv);
                                                        }
                                                        else
                                                        {
                                                            AddAgvToWaitList(UsageTrafficAreaList[m].WaitAgv, agv, UsageTrafficAreaList[m].OccupyAgv);
                                                        }
                                                       flag2 = false;

                                                    }
                                                    #endregion
                                                }
                                                else   //等待区域没有AGV
                                                {
                                                    #region
                                                    // UsageTrafficAreaList[m].WaitAgv.Add(agv);
                                                    //AddAgvToWaitList(UsageTrafficAreaList[m].WaitAgv, agv, UsageTrafficAreaList[m].OccupyAgv);
                                                    if (UsageTrafficAreaList[m].TypeTraffic == 1)
                                                    {
                                                        if (agv.Direction == 0)
                                                            AddAgvToWaitList(UsageTrafficAreaList[m].WaitAgv, agv, UsageTrafficAreaList[m].OccupyAgv);
                                                    }
                                                    else if (UsageTrafficAreaList[m].TypeTraffic == 2)
                                                    {
                                                        if (agv.Direction == 1)
                                                            AddAgvToWaitList(UsageTrafficAreaList[m].WaitAgv, agv, UsageTrafficAreaList[m].OccupyAgv);
                                                    }
                                                    else
                                                    {
                                                        AddAgvToWaitList(UsageTrafficAreaList[m].WaitAgv, agv, UsageTrafficAreaList[m].OccupyAgv);
                                                    }
                                                    #endregion
                                                }
                                            }
                                        }

                                    }
                                    if (!flag1)   //表示agv所读的卡的区域再管制区域内，但是不在被激活的管制区域内
                                    {
                                        TrafficArea trafficNew = Equal(TrafficAreaList[i]);
                                        trafficNew.OccupyAgv = EqualAgv(agv);
                                        UsageTrafficAreaList.Add(Equal(trafficNew));
                                        flag1 = false;
                                    }
                                    #endregion
                                }

                                #endregion
                            }
                        }
                    }

                    #endregion
                }
            }
        }


        private void TrafficManager3()   //写入AGV的卡号和状态改变的事件中最好 ,2.25添加方向  去掉防止出现后管前去掉掉线删除agv 
        {
            AGV_WPF.MainWindow.AGVStatus_TypStr agv;
            lock (UsageTrafficLock)
            {
                for (int tt = 0; tt < agvArrayOlde.Count(); tt++)
                {
                    agv = agvArrayOlde[tt];
                    bool flag1 = false;
                    bool flag2 = false;
                    #region  不断的轮询已经激活的管制区
                    if (UsageTrafficAreaList.Count > 0)
                    {
                        for (int n = 0; n < UsageTrafficAreaList.Count; n++)
                        {
                            if (UsageTrafficAreaList[n].OccupyAgv.AgvNum == 0)
                            {
                                #region  没有主机时更换主机
                                if (UsageTrafficAreaList[n].WaitAgv.Count > 0)
                                {
                                    AGV_WPF.MainWindow.AGVStatus_TypStr agv1 = EqualAgv(UsageTrafficAreaList[n].WaitAgv[0]);
                                    UsageTrafficAreaList[n].OccupyAgv = agv1;
                                    UsageTrafficAreaList[n].WaitAgv.RemoveAt(0);
                                    continue;
                                }
                                else
                                {
                                    UsageTrafficAreaList.RemoveAt(n);
                                    n = -1;
                                    continue;
                                }
                                #endregion
                            }
                            #region
                            else if (UsageTrafficAreaList[n].OccupyAgv.AgvNum == agv.AgvNum)//是该激活区域的主机
                            {
                                #region   判断agv是否出了区域
                                if (!UsageTrafficAreaList[n].PointArr.Contains(agv.MarkNum))//
                                {
                                    //出了管制区域
                                    #region 主机出了激活的管制区，从等待列表中更换主机
                                    if (UsageTrafficAreaList[n].WaitAgv.Count() > 0)
                                    {
                                        AGV_WPF.MainWindow.AGVStatus_TypStr agv1 = EqualAgv(UsageTrafficAreaList[n].WaitAgv[0]);
                                        UsageTrafficAreaList[n].OccupyAgv = agv1;
                                        UsageTrafficAreaList[n].WaitAgv.RemoveAt(0);
                                        continue;
                                    }
                                    else
                                    {
                                        UsageTrafficAreaList.RemoveAt(n);
                                        n = -1;
                                        continue;
                                    }
                                    #endregion
                                }
                                else
                                {

                                }
                                #endregion
                            }
                            else if (UsageTrafficAreaList[n].WaitAgv.Count > 0)
                            {
                                #region  以防出了激活管制区，但是还在等待列表中的agv
                                foreach (AGV_WPF.MainWindow.AGVStatus_TypStr agv1 in UsageTrafficAreaList[n].WaitAgv)
                                {
                                    if (agv1.AgvNum == agv.AgvNum)
                                    {
                                        if (!UsageTrafficAreaList[n].PointArr.Contains(agv.MarkNum))
                                        {
                                            UsageTrafficAreaList[n].WaitAgv.Remove(agv1);
                                            break;
                                        }
                                    }
                                }
                                #endregion
                            }

                            #endregion
                        }
                    }
                    #endregion
                    #region  遍历所有管制区,更新管制区的状态
                    if (TrafficAreaList.Count > 0)
                    {
                        for (int i = 0; i < TrafficAreaList.Count; i++)
                        {
                            if (TrafficAreaList[i].PointArr.Contains(agv.MarkNum)) //如果AGV的当前卡号在某个管制区域内                           
                            {
                                # region
                                //判断该管制区域是否在激活的管制区域中
                                if (UsageTrafficAreaList.Count == 0)
                                {
                                    #region 如果地标在管制区列表内，且没有激活的管制区，直接加进来。
                                    UsageTrafficAreaList.Add(Equal(TrafficAreaList[i]));
                                    UsageTrafficAreaList[0].OccupyAgv = EqualAgv(agv);
                                    #endregion
                                }
                                else if (UsageTrafficAreaList.Count > 0)
                                {
                                    flag1 = false;
                                    #region
                                    for (int m = 0; m < UsageTrafficAreaList.Count; m++)
                                    {
                                        //如果当前的管制区域已经是激活的
                                        if (UsageTrafficAreaList[m].Number == TrafficAreaList[i].Number)
                                        {
                                            flag1 = true;
                                            //判断该激活的管制区域中的AGV数量、编号及主AGV的状态
                                            //防止出现自己管自己
                                            if (UsageTrafficAreaList[m].OccupyAgv.AgvNum == agv.AgvNum)
                                            {
                                                #region 等待列表中有主机

                                                if (UsageTrafficAreaList[m].WaitAgv.Count > 0)
                                                {
                                                    #region 等待列表中有主机,出现自己管制自己则处理
                                                    for (int ii = 0; ii < UsageTrafficAreaList[m].WaitAgv.Count; ii++)
                                                    {
                                                        if (UsageTrafficAreaList[m].WaitAgv[ii].AgvNum == UsageTrafficAreaList[m].OccupyAgv.AgvNum)
                                                        {
                                                            UsageTrafficAreaList[m].WaitAgv.RemoveAt(ii);
                                                        }
                                                    }
                                                    #endregion

                                                    #region  添加类型5 该类型的作用是防止出现后管前   pointIn 里靠前的点的权限高 能管制后面的点 而后面的点不能管制前面的点
                                                    if (UsageTrafficAreaList[m].TypeTraffic == 5)
                                                    {
                                                        int occupyNum = 0xffff;
                                                        for (int iii = 0; iii < UsageTrafficAreaList[m].PointArrInside.Count(); iii++)
                                                        {
                                                            if (UsageTrafficAreaList[m].PointArrInside[iii] == UsageTrafficAreaList[m].OccupyAgv.MarkNum)
                                                            {
                                                                occupyNum = iii;
                                                                break;
                                                            }
                                                        }
                                                        for (int ii = 0; ii < UsageTrafficAreaList[m].WaitAgv.Count; ii++)
                                                        {
                                                            if (UsageTrafficAreaList[m].PointArrInside.Contains(UsageTrafficAreaList[m].WaitAgv[ii].MarkNum)
                                                                && UsageTrafficAreaList[m].PointArrInside.Contains(UsageTrafficAreaList[m].OccupyAgv.MarkNum))
                                                            {
                                                                
                                                                int waitNum = 0xffff;
                                                                for (int iii = 0; iii < UsageTrafficAreaList[m].PointArrInside.Count(); iii++)
                                                                {
                                                                    if (UsageTrafficAreaList[m].PointArrInside[iii] == UsageTrafficAreaList[m].WaitAgv[ii].MarkNum)
                                                                    {
                                                                        waitNum=iii;
                                                                        break;
                                                                    }
                                                                   
                                                                }
                                                                if (occupyNum > waitNum && occupyNum != 0xffff && waitNum != 0xffff)
                                                                {
                                                                    AGV_WPF.MainWindow.AGVStatus_TypStr agvC = new AGV_WPF.MainWindow.AGVStatus_TypStr();
                                                                    agvC = EqualAgv(UsageTrafficAreaList[m].OccupyAgv);
                                                                    UsageTrafficAreaList[m].OccupyAgv = EqualAgv(UsageTrafficAreaList[m].WaitAgv[ii]);
                                                                    UsageTrafficAreaList[m].WaitAgv.RemoveAt(ii);
                                                                    UsageTrafficAreaList[m].WaitAgv.Add(agvC);
                                                                    break;
                                                                }
                                                            }
                                                        }
                                                    }
                                                    #endregion
                                                }
                                                //  for()
                                                // flag2 = true;
                                                //判断该激活的管制区域中的AGV数量、编号及主AGV的状态
                                                //还在管制区域内  状态为停止时 //0x40运行，0x41暂停，0x42结束地标停止，0x40前的都为报警，0x43停止，0x44当作充电
                                                if (agv.Status == 0x40)
                                                {
                                                    continue;
                                                }
                                                else if (agv.Status < 0x40)
                                                {
                                                    continue;
                                                }
                                                //else if (agv.Status == 0x42 || agv.Status == 0x43 || agv.Status == 0x44)
                                                //{
                                                //    #region 判断agv当前点是不是中心点，如果 不是则切换管制区域内主机
                                                //    if (UsageTrafficAreaList[m].PointArrOut.Contains(agv.MarkNum) && UsageTrafficAreaList[m].WaitAgv.Count > 0)
                                                //    {
                                                //        AGV_WPF.MainWindow.AGVStatus_TypStr agvC = new AGV_WPF.MainWindow.AGVStatus_TypStr();
                                                //        agvC = EqualAgv(UsageTrafficAreaList[m].OccupyAgv);
                                                //        UsageTrafficAreaList[m].OccupyAgv = EqualAgv(UsageTrafficAreaList[m].WaitAgv[0]);
                                                //        UsageTrafficAreaList[m].WaitAgv.RemoveAt(0);
                                                //        UsageTrafficAreaList[m].WaitAgv.Add(agvC);
                                                //        continue;
                                                //    }
                                                //    #endregion
                                                //}
                                                //else if (agv.Status == 0x41)
                                                //{
                                                //    #region  判断agv当前点是不是中心点，如果 不是则切换管制区域内主机
                                                //    if (UsageTrafficAreaList[m].PointArrOut.Contains(agv.MarkNum) && UsageTrafficAreaList[m].WaitAgv.Count > 0)
                                                //    {
                                                //        for (int jjj = 0; jjj < UsageTrafficAreaList[m].WaitAgv.Count; jjj++)
                                                //        {
                                                //            if (!UsageTrafficAreaList[m].PointArrOut.Contains(UsageTrafficAreaList[m].WaitAgv[jjj].MarkNum)
                                                //                && UsageTrafficAreaList[m].TypeTraffic != 4)
                                                //            {
                                                //                AGV_WPF.MainWindow.AGVStatus_TypStr agvC = new AGV_WPF.MainWindow.AGVStatus_TypStr();
                                                //                agvC = EqualAgv(UsageTrafficAreaList[m].OccupyAgv);
                                                //                UsageTrafficAreaList[m].OccupyAgv = EqualAgv(UsageTrafficAreaList[m].WaitAgv[jjj]);
                                                //                UsageTrafficAreaList[m].WaitAgv.RemoveAt(jjj);
                                                //                UsageTrafficAreaList[m].WaitAgv.Add(agvC);
                                                //                break;
                                                //            }
                                                //        }
                                                //    }
                                                //    #endregion

                                                //}
                                                #endregion
                                            }
                                            else// 不是主机
                                            {
                                                #region  
                                                if (UsageTrafficAreaList[m].WaitAgv.Count > 0)
                                                {
                                                    #region  等待区域里有AGV
                                                    for (int t = 0; t < UsageTrafficAreaList[m].WaitAgv.Count; t++)
                                                    {
                                                        if (UsageTrafficAreaList[m].WaitAgv[t].AgvNum == agv.AgvNum)
                                                        {
                                                            flag2 = true;
                                                            break ;
                                                        }
                                                    }
                                                    if (!flag2)//当前agv不在该激活管制区的等待列表内
                                                    {
                                                        #region 当前agv不在该激活管制区的等待列表内
                                                        if (UsageTrafficAreaList[m].TypeTraffic == 1)
                                                        {
                                                            //if (agv.Direction == 0)
                                                            {
                                                                if (AddAgvToWaitList(UsageTrafficAreaList[m].WaitAgv, agv, UsageTrafficAreaList[m].OccupyAgv) == 2)
                                                                {
                                                                    //切换管制区域
                                                                    #region
                                                                    AGV_WPF.MainWindow.AGVStatus_TypStr agvM = new AGV_WPF.MainWindow.AGVStatus_TypStr();
                                                                    agvM = EqualAgv(UsageTrafficAreaList[m].OccupyAgv);
                                                                    UsageTrafficAreaList[m].OccupyAgv = EqualAgv(agv);
                                                                    if (UsageTrafficAreaList[m].WaitAgv.Count == 0)
                                                                    {
                                                                        UsageTrafficAreaList[m].WaitAgv.Add(agvM);
                                                                    }
                                                                    else if (UsageTrafficAreaList[m].WaitAgv.Count > 0)
                                                                    {
                                                                        AGV_WPF.MainWindow.AGVStatus_TypStr agvn = new AGV_WPF.MainWindow.AGVStatus_TypStr();
                                                                        UsageTrafficAreaList[m].WaitAgv.Add(agvn);
                                                                        if (UsageTrafficAreaList[m].WaitAgv.Count > 1)
                                                                        {
                                                                            for (int jjj = UsageTrafficAreaList[m].WaitAgv.Count - 2; jjj >= 0; jjj--)
                                                                            {

                                                                                UsageTrafficAreaList[m].WaitAgv[jjj + 1] = EqualAgv(UsageTrafficAreaList[m].WaitAgv[jjj]);
                                                                            }
                                                                            UsageTrafficAreaList[m].WaitAgv[0] = EqualAgv(agvM);
                                                                        }
                                                                    }
                                                                    #endregion
                                                                }

                                                            }
                                                        }
                                                        else if (UsageTrafficAreaList[m].TypeTraffic == 2)
                                                        {
                                                            if (agv.Direction == 1)
                                                            {
                                                                if (AddAgvToWaitList(UsageTrafficAreaList[m].WaitAgv, agv, UsageTrafficAreaList[m].OccupyAgv) == 2)
                                                                {
                                                                    //切换管制区域
                                                                    #region
                                                                    AGV_WPF.MainWindow.AGVStatus_TypStr agvM = new AGV_WPF.MainWindow.AGVStatus_TypStr();
                                                                    agvM = EqualAgv(UsageTrafficAreaList[m].OccupyAgv);
                                                                    UsageTrafficAreaList[m].OccupyAgv = EqualAgv(agv);
                                                                    if (UsageTrafficAreaList[m].WaitAgv.Count == 0)
                                                                    {
                                                                        UsageTrafficAreaList[m].WaitAgv.Add(agvM);
                                                                    }
                                                                    else if (UsageTrafficAreaList[m].WaitAgv.Count > 0)
                                                                    {
                                                                        AGV_WPF.MainWindow.AGVStatus_TypStr agvn = new AGV_WPF.MainWindow.AGVStatus_TypStr();
                                                                        UsageTrafficAreaList[m].WaitAgv.Add(agvn);
                                                                        if (UsageTrafficAreaList[m].WaitAgv.Count > 1)
                                                                        {
                                                                            for (int jjj = UsageTrafficAreaList[m].WaitAgv.Count - 2; jjj >= 0; jjj--)
                                                                            {

                                                                                UsageTrafficAreaList[m].WaitAgv[jjj + 1] = EqualAgv(UsageTrafficAreaList[m].WaitAgv[jjj]);
                                                                            }
                                                                            UsageTrafficAreaList[m].WaitAgv[0] = EqualAgv(agvM);
                                                                        }
                                                                    }
                                                                    #endregion
                                                                }

                                                            }
                                                        }
                                                        else
                                                        {
                                                            if (AddAgvToWaitList(UsageTrafficAreaList[m].WaitAgv, agv, UsageTrafficAreaList[m].OccupyAgv) == 2)
                                                            {
                                                                //切换管制区域
                                                                #region
                                                                AGV_WPF.MainWindow.AGVStatus_TypStr agvM = new AGV_WPF.MainWindow.AGVStatus_TypStr();
                                                                agvM = EqualAgv(UsageTrafficAreaList[m].OccupyAgv);
                                                                UsageTrafficAreaList[m].OccupyAgv = EqualAgv(agv);
                                                                if (UsageTrafficAreaList[m].WaitAgv.Count == 0)
                                                                {
                                                                    UsageTrafficAreaList[m].WaitAgv.Add(agvM);
                                                                }
                                                                else if (UsageTrafficAreaList[m].WaitAgv.Count > 0)
                                                                {
                                                                    AGV_WPF.MainWindow.AGVStatus_TypStr agvn = new AGV_WPF.MainWindow.AGVStatus_TypStr();
                                                                    UsageTrafficAreaList[m].WaitAgv.Add(agvn);
                                                                    if (UsageTrafficAreaList[m].WaitAgv.Count > 1)
                                                                    {
                                                                        for (int jjj = UsageTrafficAreaList[m].WaitAgv.Count - 2; jjj >= 0; jjj--)
                                                                        {

                                                                            UsageTrafficAreaList[m].WaitAgv[jjj + 1] = EqualAgv(UsageTrafficAreaList[m].WaitAgv[jjj]);
                                                                        }
                                                                        UsageTrafficAreaList[m].WaitAgv[0] = EqualAgv(agvM);
                                                                    }
                                                                }
                                                                #endregion
                                                            }

                                                        }
                                                        flag2 = false;
                                                        #endregion

                                                    }
                                                    #endregion
                                                }
                                                else   //等待区域没有AGV
                                                {
                                                    #region
                                                    // UsageTrafficAreaList[m].WaitAgv.Add(agv);
                                                    //AddAgvToWaitList(UsageTrafficAreaList[m].WaitAgv, agv, UsageTrafficAreaList[m].OccupyAgv);
                                                    if (UsageTrafficAreaList[m].TypeTraffic == 1)
                                                    {
                                                        //if (agv.Direction == 0)
                                                        {
                                                            if (AddAgvToWaitList(UsageTrafficAreaList[m].WaitAgv, agv, UsageTrafficAreaList[m].OccupyAgv) == 2)
                                                            {
                                                                //切换管制区域
                                                                #region
                                                                AGV_WPF.MainWindow.AGVStatus_TypStr agvM = new AGV_WPF.MainWindow.AGVStatus_TypStr();
                                                                agvM = EqualAgv(UsageTrafficAreaList[m].OccupyAgv);
                                                                UsageTrafficAreaList[m].OccupyAgv = EqualAgv(agv);
                                                                if (UsageTrafficAreaList[m].WaitAgv.Count == 0)
                                                                {
                                                                    UsageTrafficAreaList[m].WaitAgv.Add(agvM);
                                                                }
                                                                else if (UsageTrafficAreaList[m].WaitAgv.Count > 0)
                                                                {
                                                                    AGV_WPF.MainWindow.AGVStatus_TypStr agvn = new AGV_WPF.MainWindow.AGVStatus_TypStr();                                                                   
                                                                    UsageTrafficAreaList[m].WaitAgv.Add(agvn);
                                                                    if (UsageTrafficAreaList[m].WaitAgv.Count > 1)
                                                                    {
                                                                        for (int jjj = UsageTrafficAreaList[m].WaitAgv.Count - 2; jjj >= 0; jjj--)
                                                                        {

                                                                            UsageTrafficAreaList[m].WaitAgv[jjj + 1] = EqualAgv(UsageTrafficAreaList[m].WaitAgv[jjj]);
                                                                        }
                                                                        UsageTrafficAreaList[m].WaitAgv[0] = EqualAgv(agvM);
                                                                    }
                                                                }
                                                                #endregion
                                                            }

                                                        }
                                                    }
                                                    else if (UsageTrafficAreaList[m].TypeTraffic == 2)
                                                    {
                                                        if (agv.Direction == 1)
                                                        {
                                                            if (AddAgvToWaitList(UsageTrafficAreaList[m].WaitAgv, agv, UsageTrafficAreaList[m].OccupyAgv) == 2)
                                                            {
                                                                //切换管制区域
                                                                #region
                                                                AGV_WPF.MainWindow.AGVStatus_TypStr agvM = new AGV_WPF.MainWindow.AGVStatus_TypStr();
                                                                agvM = EqualAgv(UsageTrafficAreaList[m].OccupyAgv);
                                                                UsageTrafficAreaList[m].OccupyAgv = EqualAgv(agv);
                                                                if (UsageTrafficAreaList[m].WaitAgv.Count == 0)
                                                                {
                                                                    UsageTrafficAreaList[m].WaitAgv.Add(agvM);
                                                                }
                                                                else if (UsageTrafficAreaList[m].WaitAgv.Count > 0)
                                                                {
                                                                    AGV_WPF.MainWindow.AGVStatus_TypStr agvn = new AGV_WPF.MainWindow.AGVStatus_TypStr();
                                                                    UsageTrafficAreaList[m].WaitAgv.Add(agvn);
                                                                    if (UsageTrafficAreaList[m].WaitAgv.Count > 1)
                                                                    {
                                                                        for (int jjj = UsageTrafficAreaList[m].WaitAgv.Count - 2; jjj >= 0; jjj--)
                                                                        {

                                                                            UsageTrafficAreaList[m].WaitAgv[jjj + 1] = EqualAgv(UsageTrafficAreaList[m].WaitAgv[jjj]);
                                                                        }
                                                                        UsageTrafficAreaList[m].WaitAgv[0] = EqualAgv(agvM);
                                                                    }
                                                                }
                                                                #endregion
                                                            }

                                                        }
                                                    }
                                                    else
                                                    {
                                                        if (AddAgvToWaitList(UsageTrafficAreaList[m].WaitAgv, agv, UsageTrafficAreaList[m].OccupyAgv) == 2)
                                                        {
                                                            //切换管制区域
                                                               #region
                                                                AGV_WPF.MainWindow.AGVStatus_TypStr agvM = new AGV_WPF.MainWindow.AGVStatus_TypStr();
                                                                agvM = EqualAgv(UsageTrafficAreaList[m].OccupyAgv);
                                                                UsageTrafficAreaList[m].OccupyAgv = EqualAgv(agv);
                                                                if (UsageTrafficAreaList[m].WaitAgv.Count == 0)
                                                                {
                                                                    UsageTrafficAreaList[m].WaitAgv.Add(agvM);
                                                                }
                                                                else if (UsageTrafficAreaList[m].WaitAgv.Count > 0)
                                                                {
                                                                    AGV_WPF.MainWindow.AGVStatus_TypStr agvn = new AGV_WPF.MainWindow.AGVStatus_TypStr();                                                                   
                                                                    UsageTrafficAreaList[m].WaitAgv.Add(agvn);
                                                                    if (UsageTrafficAreaList[m].WaitAgv.Count > 1)
                                                                    {
                                                                        for (int jjj = UsageTrafficAreaList[m].WaitAgv.Count - 2; jjj >= 0; jjj--)
                                                                        {

                                                                            UsageTrafficAreaList[m].WaitAgv[jjj + 1] = EqualAgv(UsageTrafficAreaList[m].WaitAgv[jjj]);
                                                                        }
                                                                        UsageTrafficAreaList[m].WaitAgv[0] = EqualAgv(agvM);
                                                                    }
                                                                }
                                                                #endregion
                                                        }

                                                    }
                                                    #endregion
                                                }
                                                #endregion
                                            }
                                        }

                                    }
                                    if (!flag1)   //表示agv所读的卡的区域再管制区域内，但是不在被激活的管制区域内
                                    {
                                        TrafficArea trafficNew = Equal(TrafficAreaList[i]);
                                        trafficNew.OccupyAgv = EqualAgv(agv);
                                        UsageTrafficAreaList.Add(Equal(trafficNew));
                                        flag1 = false;
                                    }
                                    #endregion
                                }

                                #endregion
                            }
                        }
                    }

                    #endregion
                }
            }
        }
        /// <summary>
        /// 获取需要管制的agv列表
        /// </summary>
        /// <returns></returns>
        public List<byte> GetTrafficAgvNum()
        {

            List<byte> agvNumList = new List<byte>();
            lock (UsageTrafficLock)
            {
                if (UsageTrafficAreaList.Count > 0)
                {
                    for (int i = 0; i < UsageTrafficAreaList.Count; i++)
                    {
                        for (int j = 0; j < UsageTrafficAreaList[i].WaitAgv.Count; j++)
                        {
                            if (!agvNumList.Contains(UsageTrafficAreaList[i].WaitAgv[j].AgvNum))
                            {
                                agvNumList.Add(UsageTrafficAreaList[i].WaitAgv[j].AgvNum);

                            }
                        }
                    }
                }
            }
            return (agvNumList);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="waitList"></param>
        /// <param name="agv"></param>
        /// <param name="mainAgv"></param>
        /// <returns>0表示正确添加，1表示列表中存在相同的AGV，2表示互相管制</returns>
        private int AddAgvToWaitList(List<AGV_WPF.MainWindow.AGVStatus_TypStr> waitList,
            AGV_WPF.MainWindow.AGVStatus_TypStr agv, AGV_WPF.MainWindow.AGVStatus_TypStr mainAgv)
        {
            
            if (waitList.Count > 0)
            {
                for (int i = 0; i < waitList.Count; i++)
                {
                    if (waitList[i].AgvNum == agv.AgvNum)
                    {
                        waitList[i] = agv;
                        return (1);
                    }
                }
            }
            #region//多区域防止两台AGV互相管制

            for (int i = 0; i < UsageTrafficAreaList.Count; i++)
            {
                if (UsageTrafficAreaList[i].OccupyAgv.AgvNum == agv.AgvNum)
                {
                    if (UsageTrafficAreaList[i].WaitAgv.Count > 0)
                    {
                        for (int j = 0; j < UsageTrafficAreaList[i].WaitAgv.Count; j++)
                        {
                            if (UsageTrafficAreaList[i].WaitAgv[j].AgvNum == mainAgv.AgvNum)   //5.18修改BUG
                            {
                               
                                return(2);
                            }

                        }
                    }
                }
            }
            #endregion
            waitList.Add(agv);
            return(0);
        }

        private TrafficArea Equal(TrafficArea TrafficAreaOld)
        {
            TrafficArea TrafficAreaNew = new TrafficArea();
            TrafficAreaNew.Number = TrafficAreaOld.Number;
            TrafficAreaNew.OccupyAgv = TrafficAreaOld.OccupyAgv;
            TrafficAreaNew.PointArr = TrafficAreaOld.PointArr;
            TrafficAreaNew.PointArrOut = TrafficAreaOld.PointArrOut;
            TrafficAreaNew.PointArrInside = TrafficAreaOld.PointArrInside;
            TrafficAreaNew.TypeTraffic = TrafficAreaOld.TypeTraffic;
           // TrafficAreaNew.Status = true;
            return (TrafficAreaNew);
        }

        private AGV_WPF.MainWindow.AGVStatus_TypStr EqualAgv(AGV_WPF.MainWindow.AGVStatus_TypStr agvOld)
        {
            AGV_WPF.MainWindow.AGVStatus_TypStr agv1 = new AGV_WPF.MainWindow.AGVStatus_TypStr();
            agv1.LineNum = agvOld.LineNum;
            agv1.Current = agvOld.Current;
            agv1.Direction = agvOld.Direction;
            agv1.DockNum = agvOld.DockNum;
            agv1.AgvNum = agvOld.AgvNum;
            agv1.MarkNum = agvOld.MarkNum;
            agv1.Speed = agvOld.Speed;
            agv1.Status = agvOld.Status;
            agv1.TrafficNum = agvOld.TrafficNum;
            agv1.WlLink = agvOld.WlLink;
            agv1.Voltage = agvOld.Voltage;
            return (agv1);
        }

        private int[] ToIntArray(string[] stringArr)
        {
            
            int[] intArray = new int[stringArr.Count()];
            if (stringArr.Count() > 0)
            {
                for (int i = 0; i < stringArr.Count(); i++)
                {
                    intArray[i] = Convert.ToInt32(stringArr[i]);
                }
            }
            return (intArray);
        }


        public List< SAgvTraffic> GetTrafficAgv()
        {
            List<SAgvTraffic> agvTrafficList = new List< SAgvTraffic>();
            List<byte> agvNumList = new List<byte>();
            lock (UsageTrafficLock)
            {
                if (UsageTrafficAreaList.Count > 0)
                {
                    for (int i = 0; i < UsageTrafficAreaList.Count; i++)
                    {
                        for (int j = 0; j < UsageTrafficAreaList[i].WaitAgv.Count; j++)
                        {
                            if (!agvNumList.Contains(UsageTrafficAreaList[i].WaitAgv[j].AgvNum))
                            {
                                agvNumList.Add(UsageTrafficAreaList[i].WaitAgv[j].AgvNum);
                                SAgvTraffic trafficMsg = new SAgvTraffic();
                                trafficMsg.AGVNUM = UsageTrafficAreaList[i].WaitAgv[j].AgvNum;
                                trafficMsg.MIANAGVNUM = UsageTrafficAreaList[i].OccupyAgv.AgvNum;
                                trafficMsg.TRAFFICAREANUM = UsageTrafficAreaList[i].Number;
                            }
                        }
                    }
                }
            }

            return (agvTrafficList);
        }

    }

        public  struct SAgvTraffic
        {
           public  int AGVNUM;
           public int MIANAGVNUM ;
           public int TRAFFICAREANUM ;
        }
}