YG-OPP-WCS/Projects/永冠OPP/WCS.Service/Works/RGV/RGVWorks.cs

using DBHelper;
using System;
using System.Collections.Generic;
using System.Linq;
using WCS.Core;
using WCS.Entity;
using WCS.Entity.Protocol;
using WCS.Entity.Protocol.RGV;
using WCS.Entity.Protocol.SRM;
using WCS.Service.Extensions;
using WCS.Service.Handlers;
using WCS.Service.Helpers;
using WCS.Service.Log;

namespace WCS.Service.Works.RGV
{
    [WorkTitle(typeof(RGVHandler), "直穿RGV")]
    public class 直穿RGV : DeviceWork<RGVDevice>
    {
        private readonly string ConvGroup_1030 = "G1030";
        private readonly string RGV8 = "RGV8";

        protected override void Do(RGVDevice rgv)
        {
            rgv.EX(rgv =>
            {
                //RGV是自动且空闲的
                if (rgv.Data2.WorkMode != RGVMode.自动) throw new DoException($"{rgv.Data2.WorkMode}");
                if (rgv.Data2.SystemStatus != RGVRunStatus.空闲) throw new DoException($"{rgv.Data2.SystemStatus}");
                if (rgv.Data.Trigger_1 != rgv.Data2.Trigger_1) throw new WarnException("凭证好不一致");
                if (rgv.Data2.Status_1.HasFlag(WCS.Entity.Protocol.RGVStatus.光电)) throw new DoException("RGV有光电，无法执行任务");

                //RGV状态为 RGV到站&&任务完成 时程序认为RGV当前不在取货点
                if (rgv.Data2.Status_1.HasFlag(WCS.Entity.Protocol.RGVStatus.RGV到站) && rgv.Data2.Status_1.HasFlag(WCS.Entity.Protocol.RGVStatus.任务完成))
                {
                    //下达一个目标为1030的移动任务
                    rgv.Data.TaskID_1 = 1030;
                    rgv.Data.DestPosition_1 = 1030;
                    rgv.Data.TaskType_1 = RGVTaskType.移动;
                    rgv.Data.Trigger_1++;
                }

                var obj = Device.Find(ConvGroup_1030).Create<StationDeviceGroup>();

                obj.WhetherToExecute();

                //筛选出有任务号和起始及目标地址的设备
                var dev = obj.RGVGetTaskedDevice() ?? throw new WarnException("无可用任务");
                var taskids = dev.Select(v => v.Data2.Tasknum);
                DB.Do(db =>
                {
                    var tasks = db.Default.Set<WCS_TASK>().Where(p => taskids.Contains(p.ID));
                    if (tasks.GroupBy(p => p.TaskGroupKey).Count() > 1)
                        throw new WarnException("任务组ID不一致");
                    if (!tasks.GroupBy(p => p.TaskGroupKey).Any())
                        throw new WarnException("无任务组ID");
                    var gw1 = obj.Items.ToArray()[0];
                    var gw2 = obj.Items.ToArray()[1];
                    if (gw1.Data2.Tasknum != 0 && gw2.Data2.Tasknum != 0)
                    {
                        if (gw1.Data2.Goodsend != gw2.Data2.Goodsend) throw new WarnException($"{obj.Entity.CODE}目标地址不一致");
                    }

                    rgv.Data.TaskID_1 = gw1.Data2.Tasknum;
                    rgv.Data.TaskID_2 = gw2.Data2.Tasknum;
                    if (gw1.Data2.Tasknum != 0)
                    {
                        rgv.Data.StartPosition_1 = gw1.Entity.CODE.ToShort();
                        rgv.Data.DestPosition_1 = gw1.Data2.Goodsend;
                    }
                    else
                    {
                        rgv.Data.StartPosition_1 = gw1.Entity.CODE.ToShort();
                        rgv.Data.DestPosition_1 = gw2.Data2.Goodsend;
                    }
                    rgv.Data.Trigger_1++;

                    foreach (var task in tasks)
                    {
                        task.CreateStatusLog(db, "RGV开始执行", this.GetType());
                    }
                    db.Default.SaveChanges();
                });
            });
        }

        protected override bool SelectDevice(WCS_DEVICE dev)
        {
            return dev.CODE == RGV8;
        }
    }

    [WorkTitle(typeof(RGVHandler), "涂布环穿")]
    public class 涂布环穿 : DeviceWork<RGVDevice>
    {
        protected override void Do(RGVDevice obj)
        {
            //11号站台是取货点，但不是待命点，如需取货，从九号站台调车
            //2号站台是一个待命点，但是为了保证入库取货效率，所有后面会跟一个车
            //如果3号站台的小车拦住了后一个小车的放货任务，检测一次最近的空车距离值，如果大于或等于618500并且小于被拦住小车的位置值再进行调车，用于避免无效空跑
            obj.EX(rgvDevice =>
            {
                //状态上抛
                DeciceStateHelper.StatusCheck(obj.Entity.CODE, obj.Data2.WorkMode.ToString());
                if (rgvDevice.Data2.Trigger_1 != rgvDevice.Data.Trigger_1) throw new WarnException($"等待执行任务{rgvDevice.Data2.TaskID_1}--{rgvDevice.Data2.TaskID_2}");
                if (rgvDevice.Data2.WorkMode != RGVMode.自动) throw new DoException(rgvDevice.Data2.WorkMode.ToString());
                if (rgvDevice.Data2.SystemStatus != RGVRunStatus.空闲) throw new DoException(rgvDevice.Data2.SystemStatus.ToString());
                rgvDevice.End();
                //RGV当前是否刚刚完成取货任务，等待放货
                if (rgvDevice.IsPut())
                {
                    if (!rgvDevice.Data2.Status_1.HasFlag(WCS.Entity.Protocol.RGVStatus.光电)) throw new WarnException("RGV无光电，无法放货，请检查实际情况");
                    var taskids = new List<int>() { rgvDevice.Data2.TaskID_1, rgvDevice.Data2.TaskID_2 };
                    List<WCS_TASK> tasks = new List<WCS_TASK>();
                    //取小车上的任务
                    DB.Do(db =>
                    {
                        tasks = db.Default.Set<WCS_TASK>().Where(p => taskids.Contains(p.ID)).ToList();
                    });

                    if (tasks.GroupBy(p => p.TaskGroupKey).Count() > 1)
                        throw new WarnException("任务组ID不一致");
                    if (!tasks.GroupBy(p => p.TaskGroupKey).Any())
                        throw new WarnException("无任务组ID");
                    var destStation = Device.Find(tasks.FirstOrDefault()!.ADDRNEXT).Create<StationDeviceGroup>();
                    rgvDevice.Put(destStation, rgvDevice.Data2.TaskID_1, rgvDevice.Data2.TaskID_2);
                    rgvDevice.Add();
                    return;
                }
                //当前有rgv的取货站台
                var pickStation = rgvDevice.CurrentStation();
                //RGV是否在任何一个站台
                if (pickStation != null)
                {
                    //是否是取货站台
                    if (pickStation.Entity.Is(DF.涂布RGV取货设备组))
                    {
                        // 筛选出有任务号和起始及目标地址的设备
                        var devise = pickStation.RGVGetTaskedDevice();

                        //是否需要取货
                        if (devise is { Count: > 0 } && pickStation.IsPickUp(rgvDevice))
                        {
                            if (rgvDevice.Data.TaskID_1 != pickStation.Entity.CODE.Replace("G", "").ToShort()) throw new WarnException($"目标站台{rgvDevice.Data.TaskID_1}与当前站台{pickStation.Entity.CODE.Replace("G", "").ToShort()}不一致");
                            if (rgvDevice.Data2.TaskType_1 != RGVTaskType.移动) throw new WarnException($"RGV正在执行{rgvDevice.Data2.TaskType_1}");
                            if (rgvDevice.Data2.Status_1.HasFlag(WCS.Entity.Protocol.RGVStatus.光电)) throw new WarnException("RGV有光电，无法取货，请检查实际情况");
                            if (!rgvDevice.Data2.Status_1.HasFlag(WCS.Entity.Protocol.RGVStatus.RGV到站)) throw new WarnException("RGV无到站状态，请检查RGV实际状态");
                            var taskids = devise.Select(v => v.Data2.Tasknum);
                            List<WCS_TASK> tasks = new List<WCS_TASK>();
                            //开始下达取货任务
                            DB.Do(db =>
                            {
                                tasks = db.Default.Set<WCS_TASK>().Where(p => taskids.Contains(p.ID)).ToList();
                            });
                            if (tasks.GroupBy(p => p.TaskGroupKey).Count() > 1)
                                throw new WarnException("任务组ID不一致");
                            if (!tasks.GroupBy(p => p.TaskGroupKey).Any())
                                throw new WarnException("无任务组ID");
                            var gw1 = pickStation.Items.ToArray()[0];
                            var gw2 = pickStation.Items.ToArray()[1];
                            if (gw1.Data2.Tasknum != 0 && gw2.Data2.Tasknum != 0)
                            {
                                if (gw1.Data2.Goodsend != gw2.Data2.Goodsend) throw new WarnException($"{rgvDevice.Entity.CODE}目标地址不一致");
                            }

                            InfoLog.INFO_RGVINFO($"[{rgvDevice.Entity.CODE}]--写入RGV取货任务-开始:{rgvDevice.Data.TaskID_1},{rgvDevice.Data.TaskID_2},{rgvDevice.Data.TaskType_1},{rgvDevice.Data.DestPosition_1},{rgvDevice.Data.Trigger_1}");
                            rgvDevice.Data.TaskID_1 = gw1.Data2.Tasknum;
                            rgvDevice.Data.TaskID_2 = gw2.Data2.Tasknum;
                            rgvDevice.Data.TaskType_1 = RGVTaskType.取货;
                            rgvDevice.Data.DestPosition_1 = pickStation.Entity.CODE.Replace("G", "").ToShort();
                            InfoLog.INFO_RGVINFO($"[{rgvDevice.Entity.CODE}]--写入RGV取货任务-结束:{rgvDevice.Data.TaskID_1},{rgvDevice.Data.TaskID_2},{rgvDevice.Data.TaskType_1},{rgvDevice.Data.DestPosition_1},{rgvDevice.Data.Trigger_1}");
                            rgvDevice.Data.Trigger_1++;
                            DB.Do(db =>
                            {
                                foreach (var task in tasks)
                                {
                                    task.CreateStatusLog(db, $"取货任务下达至{rgvDevice.Entity.CODE}", this.GetType());
                                }
                                db.Default.SaveChanges();
                            });
                            rgvDevice.Add();
                            return;
                        }

                        if (rgvDevice.RGVList.Count + 1 != 6)//有小车进入维修站时启用该逻辑，避免在正常使用时影响效率，RGVList把自身排除在外了所以需要+1
                        {
                            //var stationList = rgvDevice.LocationList.Where(v => v.Entity.Is(DF.涂布RGV取货设备组)).Where(v => v.RGVGetTaskedDevice().Any())
                            //    .Where(v =>
                            //    {
                            //        if (v.CurrentRGV() == null) return true;
                            //        return false;
                            //    });
                            //if (stationList != null)
                            //{
                            //    var station11 = stationList.MinBy(rgvDevice.Distance);
                            //    //该站台到当前小车的范围中没有车
                            //    if (rgvDevice.RGVList.Any(v => station11!.Position <= v.Position && rgvDevice.Position > v.Position))
                            //    {
                            //        rgvDevice.Move(station11);
                            //        return;
                            //    }
                            //}
                        }
                        if (pickStation.Entity.CODE == "G9")
                        {
                            //九站台的小车需要额外检测一下11站台是否需要取货
                            var station11 = Device.Find("G11").Create<StationDeviceGroup>();
                            var station11Dev = station11.RGVGetTaskedDevice();
                            if (station11Dev != null && station11Dev.Count > 0)
                            {
                                rgvDevice.Move(station11);
                                rgvDevice.Add();
                                return;
                            }
                        }

                        //找到自己的后一个小车
                        var afterRgv = rgvDevice.After();

                        //自己是否阻挡了该小车
                        if (afterRgv.Data2.WorkMode == RGVMode.自动 && afterRgv.Data2.SystemStatus != RGVRunStatus.空闲 && rgvDevice.StopedByMe(afterRgv))
                        {
                            switch (pickStation.Entity.CODE)
                            {
                                case "G2":
                                    {
                                        if (rgvDevice.RGVList.Count + 1 != 6) break;
                                        //此站台因需要进行排队，因此是否需要赶车取决于是否拦住了两个小车的任务
                                        var afterRgv1 = afterRgv.After();
                                        //如果是空闲或者没有拦住他，就不执行赶车
                                        if (afterRgv1.Data2.WorkMode == RGVMode.自动 && (afterRgv1.Data2.SystemStatus == RGVRunStatus.空闲 || !afterRgv.StopedByMe(afterRgv1))) return;
                                        break;
                                    }
                                case "G3":
                                    {
                                        if (rgvDevice.RGVList.Count + 1 != 6) break;
                                        //为了减少空跑，需要被阻拦的小车后面的小车任务类型为移动并且位置值要大于618500小于被阻拦小车的位置值
                                        var afterRgv1 = afterRgv.After();
                                        if (afterRgv1.Data2.WorkMode == RGVMode.自动 && afterRgv.Data2.TaskType_1 != RGVTaskType.移动 && !(afterRgv1.Position < afterRgv.Position && afterRgv1.Position > 618500)) return;
                                        break;
                                    }
                            }
                            //找到当前所在站台的下一个取货点
                            var beforeStation = Device.Where(v => v.Is(DF.涂布RGV取货设备组) && v.CODE != pickStation.Entity.CODE)
                                .Select(v => v.Create<StationDeviceGroup>()).MinBy(v => pickStation.Distance(v));

                            //写入移动任务
                            rgvDevice.Move(beforeStation);
                            rgvDevice.Add();
                            return;
                        }

                        if (pickStation.Entity.CODE == "G11")
                        {
                            rgvDevice.Move(Device.Find("G2").Create<StationDeviceGroup>());
                            rgvDevice.Add();
                            return;
                        }
                    }

                    //是否在一个放货站台
                    if (pickStation.Entity.Is(DF.涂布RGV放货设备组))
                    {
                        pickStation = rgvDevice.BeforeStation();
                        rgvDevice.Move(pickStation);
                        rgvDevice.Add();
                        return;
                    }
                }

                //此时RGV即没有等待执行的放货任务，也不在任何一个取货点,因此需要调往最近的一个取货点
                //找到距离这个RGV最近的一个取货点
                //必须所有RGV都是空闲状态时才可以进行初始化
                if (rgvDevice.RGVList.Any(v => v.Data2.SystemStatus != RGVRunStatus.空闲)) return;
                pickStation = rgvDevice.BeforeStation();
                rgvDevice.Move(pickStation);
                rgvDevice.Add();
            });
        }

        protected override bool SelectDevice(WCS_DEVICE dev)
        {
            return dev.Is(DF.涂布RGV);
        }
    }

    [WorkTitle(typeof(RGVHandler), "BOPP环穿")]
    public class BOPP环穿 : DeviceWork<RGVDevice>
    {
        protected override void Do(RGVDevice obj)
        {
            obj.EX(obj =>
            {
                //状态上抛
                DeciceStateHelper.StatusCheck(obj.Entity.CODE, obj.Data2.WorkMode.ToString());
                if (obj.Data2.Trigger_1 != obj.Data.Trigger_1) throw new WarnException($"等待执行任务{obj.Data2.TaskID_1}--{obj.Data2.TaskID_2}");
                if (obj.Data2.WorkMode != RGVMode.自动) throw new DoException(obj.Data2.WorkMode.ToString());
                if (obj.Data2.SystemStatus != RGVRunStatus.空闲) throw new DoException(obj.Data2.SystemStatus.ToString());

                #region 取货完成小车直接移动至12号站台

                if (obj.IsPut())//RGV当前是否刚刚完成取货任务，等待放货移动
                {
                    if (obj.Data.TaskType_1 != RGVTaskType.取货) throw new WarnException($"当前任务类型必须为取货任务");
                    if (obj.Data2.WorkMode != RGVMode.自动) throw new WarnException($"RGV状态{obj.Data2.WorkMode},无法执行放货移动任务");
                    if (obj.Data2.SystemStatus != RGVRunStatus.空闲) throw new WarnException($"rgv状态为{obj.Data2.SystemStatus},无法执行放货移动任务");
                    if (!obj.Data2.Status_1.HasFlag(WCS.Entity.Protocol.RGVStatus.光电)) throw new WarnException("RGV无光电，无法执行放货移动任务");
                    var addr = Device.Find("G12").Create<StationDeviceGroup>();
                    if (obj.Data2.TaskID_1 == addr.Entity.CODE.GetShortCode() && obj.Data.TaskType_1 == RGVTaskType.移动)
                    {
                        InfoLog.INFO_RGVINFO($"{obj.Entity.CODE}]--已有目标地址相同的移动任务");
                        return;
                    }
                    InfoLog.INFO_RGVINFO($"[{obj.Entity.CODE}]--写入RGV放货移动任务-开始:{obj.Data.TaskID_1},{obj.Data.TaskType_1},{obj.Data.DestPosition_1},{obj.Data.Trigger_1}");

                    obj.Data.TaskType_1 = RGVTaskType.移动;
                    obj.Data.DestPosition_1 = addr.Entity.CODE.GetShortCode();
                    obj.Data.Trigger_1++;
                    InfoLog.INFO_RGVINFO($"[{obj.Entity.CODE}]--写入RGV移动任务-结束:{obj.Data.TaskID_1},{obj.Data.TaskType_1},{obj.Data.DestPosition_1},{obj.Data.Trigger_1}");
                    return;
                }

                #endregion 取货完成小车直接移动至12号站台

                var pickStation = obj.CurrentStation();
                //RGV是否在任何一个站台
                if (pickStation != null)
                {
                    //是否是取货站台
                    if (pickStation.Entity.Is(DF.BOPPRGV取货设备组))
                    {
                        // var a = Items.Where(v => v.Data2.Status.HasFlag(IstationStatus.光电状态) && v.Data2.Tasknum > 10000)
                        // .Where(v => v.Entity.CODE.ToShort() != v.Data2.Goodsend && v.Data2.Goodsend != 0)
                        //.ToList();
                        if (pickStation.Entity.CODE == "G19")
                        {
                            var pickStations = Device.Find("G23").Create<StationDeviceGroup>().Items.Where(v => v.Data2.Status.HasFlag(IstationStatus.光电状态) && v.Data2.Tasknum > 10000).ToList();
                            if (pickStations != null && pickStations.Any())
                            {
                                obj.Move(Device.Find("G23").Create<StationDeviceGroup>());
                                return;
                            }
                        }
                        // 筛选出有任务号和起始及目标地址的设备
                        var devs = pickStation.Items.Where(v => v.Data2.Status.HasFlag(IstationStatus.光电状态) && v.Data2.Tasknum > 10000).ToList();

                        //是否需要取货
                        if (devs != null && devs.Count() > 0)
                        {
                            if (devs.Count != devs[0].Data2.Goodsnum) throw new WarnException($"取货位货物数量不一致");
                            if (obj.Data2.TaskType_1 != RGVTaskType.移动) throw new WarnException($"RGV正在执行{obj.Data2.TaskType_1}");
                            if (obj.Data2.Status_1.HasFlag(WCS.Entity.Protocol.RGVStatus.光电)) throw new WarnException("RGV有光电，无法取货，请检查实际情况");
                            if (!obj.Data2.Status_1.HasFlag(WCS.Entity.Protocol.RGVStatus.RGV到站)) throw new WarnException("RGV无到站状态，请检查RGV实际状态");
                            var taskids = devs.Select(v => v.Data2.Tasknum);
                            //开始下达取货任务
                            DB.Do(db =>
                            {
                                var tasks = db.Default.Set<WCS_TASK>().Where(p => taskids.Contains(p.ID));
                                if (tasks.GroupBy(p => p.TaskGroupKey).Count() > 1)
                                    throw new WarnException("任务组ID不一致");
                                if (!tasks.GroupBy(p => p.TaskGroupKey).Any())
                                    throw new WarnException("无任务组ID");
                                var gw1 = pickStation.Items.ToArray()[0];
                                var gw2 = pickStation.Items.ToArray()[1];
                                //if (gw1.Data2.Tasknum != 0 && gw2.Data2.Tasknum != 0)
                                //{
                                //    if (gw1.Data2.Goodsend != gw2.Data2.Goodsend) throw new WarnException($"{obj.Entity.CODE}目标地址不一致");
                                //}
                                obj.Pick(pickStation, gw1.Data2.Tasknum, gw2.Data2.Tasknum);

                                foreach (var task in tasks)
                                {
                                    task.CreateStatusLog(db, $"取货任务下达至{obj.Entity.CODE}", this.GetType());
                                }
                            });
                            return;
                        }
                        bool needToMove = obj.RGVList.Any(v => v.Data2.TaskType_1 == RGVTaskType.移动
                                                              && (v.Data2.Status_1.HasFlag(WCS.Entity.Protocol.RGVStatus.光电) || v.Data2.Status_2.HasFlag(WCS.Entity.Protocol.RGVStatus.光电))
                                                              && v.Position > StationLocation.ALLlocations.FirstOrDefault(v => v.Station == "G19").Location
                                                              && v.Position < StationLocation.ALLlocations.FirstOrDefault(v => v.Station == "G23").Location);
                        if (pickStation.Entity.CODE == "G23" && needToMove)
                        {
                            var devList = Device.Find("1155", "1154", "1163", "1162", "1152", "1153", "1157", "1158").Select(v => v.Create<StationDevice>());
                            if (!devList.Any(v => v.Data2.Status.HasFlag(IstationStatus.光电状态) || v.Data2.Tasknum > 10000))
                            {
                                obj.Move(Device.Find("G19").Create<StationDeviceGroup>());
                                return;
                            }
                        }
                        //计算当前RGV拦住小车的数量
                        var max = obj.RGVList.Count(v => v.Data2.WorkMode == RGVMode.自动 && v.Data2.SystemStatus != RGVRunStatus.空闲 && obj.StopedByMe(v));
                        if (pickStation.Entity.CODE == "G19" && max >= 2)
                        {
                            obj.Move(Device.Find("G23").Create<StationDeviceGroup>());
                        }
                    }
                    //是否在一个放货站台
                    if (pickStation.Entity.Is(DF.BOPPRGV放货设备组))
                    {
                        #region 12站台

                        if (pickStation.Entity.CODE == "G12")
                        {
                            #region 上一个任务为移动

                            if (obj.Data.TaskType_1 == RGVTaskType.移动)
                            {
                                if (obj.Data2.WorkMode != RGVMode.自动) throw new WarnException($"RGV状态{obj.Data2.WorkMode},无法分配巷道");
                                if (obj.Data2.SystemStatus != RGVRunStatus.空闲) throw new WarnException($"rgv状态为{obj.Data2.SystemStatus},无法分配巷道");
                                if (!obj.Data2.Status_1.HasFlag(WCS.Entity.Protocol.RGVStatus.光电)) throw new WarnException("RGV无光电，无法分配巷道");

                                #region 开始分配巷道

                                var taskIds = new List<int>() { obj.Data2.TaskID_1, obj.Data2.TaskID_2 };
                                taskIds = taskIds.Where(v => v > 10000).ToList(); //筛选出有效的任务

                                DB.Do(db =>
                                {
                                    var taskList = db.Default.Set<WCS_TASK>().Where(v => taskIds.Contains(v.ID)).ToList();
                                    var task = taskList.FirstOrDefault() ?? throw new WarnException($"RGV无可分配巷道任务"); ;
                                    var taskCount = db.Default.Set<WCS_TASK>().Count(v => v.TaskGroupKey == task.TaskGroupKey && v.TYPE == TaskType.入库);
                                    //开始检查任务数是否匹配
                                    if (taskList.Count != taskCount) throw new WarnException($"可执行数{taskList.Count},任务组任务数{taskCount},数量不匹配,{task.ID}-{task.TaskGroupKey}");
                                    var res = WMS.GetTunnelList(taskList.Select(v => v.WMSTASK.ToString()).ToList(), obj.Entity.CODE);
                                    if (string.IsNullOrEmpty(res.TunnelNum)) throw new WarnException($"WMS未返回巷道");
                                    var tunnelNo = res.TunnelNum.Split(',').Select(v => "TY" + v).ToList();
                                    var tunnels = Device.Where(v => tunnelNo.Contains(v.CODE)).ToList();
                                    var tunnelInfos = new List<TunnelInfo>();

                                    foreach (var item in tunnels)
                                    {
                                        //获得RGV的交货点
                                        StationDeviceGroup rgvDeliveryPoint = null;
                                        if (item.CODE == "TY1")
                                        {
                                            var deviceGroup = Device.Find("G16").Create<StationDeviceGroup>();
                                            if (deviceGroup.Items.Count(v => v.Data3.Status.HasFlag(StationStatus.自动)) == 2) //设备组中两个设备都是自动状态时表示当前设备可用
                                            {
                                                rgvDeliveryPoint = deviceGroup;
                                            }
                                        }
                                        else
                                        {
                                            StationDeviceGroup deviceGroup = null;

                                            #region 根据巷道获取放货设备组编号

                                            if (item.CODE == "TY2")
                                            {
                                                deviceGroup = Device.Find("G15").Create<StationDeviceGroup>();
                                            }
                                            else if (item.CODE is "TY3" or "TY4")
                                            {
                                                deviceGroup = Device.Find("G14").Create<StationDeviceGroup>();
                                            }
                                            else if (item.CODE is "TY5" or "TY6")
                                            {
                                                deviceGroup = Device.Find("G13").Create<StationDeviceGroup>();
                                            }
                                            else if (item.CODE is "TY7" or "TY8")
                                            {
                                                deviceGroup = Device.Find("G12").Create<StationDeviceGroup>();
                                            }

                                            #endregion 根据巷道获取放货设备组编号

                                            if (deviceGroup != null && deviceGroup.Items.Count(v => !v.Data3.Status.HasFlag(StationStatus.运行状态位)
                                                                                                 && !v.Data2.Status.HasFlag(IstationStatus.光电状态)
                                                                                                 && v.Data2.Tasknum < 10000
                                                                                                 && v.Data3.Status.HasFlag(StationStatus.自动)) == 2) // 设备组中两个设备都可用
                                            {
                                                rgvDeliveryPoint = deviceGroup;
                                            }
                                        }
                                        if (rgvDeliveryPoint == null) continue;

                                        //只能有一组任务的下一个地址是交货点
                                        //if (db.Default.Set<WCS_TASK>().Any(v => v.ADDRNEXT == rgvDeliveryPoint.Entity.CODE && v.STATUS < TaskStatus.已完成)) continue;
                                        //RGV是否有正在前往这个地址的任务
                                        var rgvList = Device.Where(v => v.Is(DF.BOPPRGV)).Select(v => v.Create<RGVDevice>());

                                        var rgvTaskCount = ProtocolProxy.YGWMS150Redis.Get("BoppRgvTaskCount").ToInt();
                                        if (rgvList.Count(v => (!v.Data2.SystemStatus.HasFlag(WCS.Entity.Protocol.RGV.RGVRunStatus.空闲) || !v.Data2.WorkMode.HasFlag(WCS.Entity.Protocol.RGV.RGVMode.自动))
                                                              && v.Data2.TaskType_1 == WCS.Entity.Protocol.RGV.RGVTaskType.放货
                                                              && v.Data2.DestPosition_1 == rgvDeliveryPoint.Entity.CODE.Replace("G", "").ToShort()) >= rgvTaskCount) continue;
                                        tunnelInfos.Add(new TunnelInfo
                                        {
                                            Tunnel = item,
                                            taskIN = rgvDeliveryPoint.Entity, //找到放货点设备所在组
                                            SRM = Device.Where(p => p.IsSC()).FirstOrDefault(p => item.ROUTES.Any(d => d.NEXT.CODE == p.CODE)).Create<SRMDevice>()
                                        });
                                    }

                                    //筛选出优先级最高的可用巷道
                                    var tunnelInfo = tunnelInfos.Where(v =>
                                    {
                                        try
                                        {
                                            return (v.SRM.Data3.SCAlarm == 0 && v.SRM.Data2.SRMMode == SCMode.远程) || v.SRM.Entity.CODE == "SRM1";
                                        }
                                        catch
                                        {
                                            return false;
                                        }
                                    }).MinBy(v => tunnelNo.IndexOf(v.Tunnel.CODE));

                                    if (tunnelInfo == null) throw new WarnException("无可用巷道");

                                    //开始变更任务信息
                                    foreach (var item in taskIds)
                                    {
                                        var task1 = taskList.FirstOrDefault(p => p.ID == item);
                                        if (task == null) throw new WarnException($"WCS无该任务{item}--{obj.Entity.CODE}");

                                        task1.DEVICE = tunnelInfo.SRM.Entity.CODE;
                                        task1.TUNNEL = tunnelInfo.Tunnel.CODE;
                                        task1.ADDRNEXT = tunnelInfo.taskIN.CODE;
                                        task1.TaskGroupKey = res.WMSTaskGroupKey;
                                        task1.ADDRTO = task1.DEVICE;

                                        var msg = $"下达从G12移动至{tunnelInfo.taskIN.CODE}的PLC指令。同时将任务分配至[{task1.TUNNEL}]-[{task1.DEVICE}]";
                                        task1.CreateStatusLog(db, msg, this.GetType());
                                    }
                                    db.Default.SaveChanges();
                                    obj.Data.TaskType_1 = RGVTaskType.放货;
                                    obj.Data.DestPosition_1 = tunnelInfo.taskIN.CODE.Replace("G", "").ToShort();
                                    obj.Data.Trigger_1++;
                                });

                                #endregion 开始分配巷道
                            }

                            #endregion 上一个任务为移动

                            #region 上一个任务为放货

                            else if (obj.Data.TaskType_1 == RGVTaskType.放货)
                            {
                                obj.Move(Device.Find("G19").Create<StationDeviceGroup>());
                            }

                            #endregion 上一个任务为放货

                            return;
                        }

                        #endregion 12站台

                        #region 非12站台

                        obj.Move(Device.Find("G19").Create<StationDeviceGroup>());

                        #endregion 非12站台
                    }
                    return;
                }

                //此时RGV即没有等待执行的放货任务，也不在任何一个取货点,因此需要调往最近的一个取货点
                //找到距离这个RGV最近的一个取货点
                //必须所有RGV都是空闲状态时才可以进行初始化
                if (obj.RGVList.Any(v => v.Data2.SystemStatus != RGVRunStatus.空闲 || v.Data2.WorkMode != RGVMode.自动)) return;
                obj.Move(Device.Find("G19").Create<StationDeviceGroup>());
            });
        }

        protected override bool SelectDevice(WCS_DEVICE dev)
        {
            return dev.Is(DF.BOPPRGV);
        }
    }
}