出入库

huanghongfeng

2025-09-26 83f3c63f1cae6224320a8d19251e3bc0404da096

 ´úÂë¹ÜÀí/WCS/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/SpeStackerCraneJob/SpeStackerCraneJob.cs

@@ -3,6 +3,7 @@
using Microsoft.AspNetCore.Hosting;
using OfficeOpenXml.FormulaParsing.Excel.Functions.DateTime;
using OfficeOpenXml.FormulaParsing.Excel.Functions.RefAndLookup;
using OfficeOpenXml.FormulaParsing.Excel.Functions.Text;
using Quartz;
using System;
using System.Collections;
@@ -12,6 +13,7 @@
using System.Diagnostics.Eventing.Reader;
using System.Linq;
using System.Reflection.Metadata;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Common.Log;
@@ -56,9 +58,6 @@
            _agvStationService = agvStationService;
        }

        public string ziche001 = "RGV104";
        public string ziche002 = "RGV107";


        public Task Execute(IJobExecutionContext context)
        {
@@ -70,11 +69,11 @@
                    GetStackerObject getStackerObject = new GetStackerObject(speStackerCrane);

                    //读取设备完成信息
                    if (getStackerObject.StaclerkJobJobStatusValue == RgvJobCraneStatus.Completed && getStackerObject.CurrentRgvtaskid!=0)
                    if (getStackerObject.StaclerkJobJobStatusValue == RgvJobCraneStatus.Completed && getStackerObject.CurrentRgvtaskid != 0)
                    {
                        _taskService.UpdateTaskStatus(getStackerObject.CurrentRgvtaskid);
                        _taskService.UpdateTaskStatus(getStackerObject.CurrentRgvtaskid,2);
                    }
                    


                    if (getStackerObject.RgvCraneAutoStatusValue == RgvCraneAutoStatus.Automatic &&
                        getStackerObject.StaclerkJobJobStatusValue == RgvJobCraneStatus.Ready && getStackerObject.RgvCraneWorkStatusValue == RGVStepprocess.NoAction)
@@ -82,10 +81,8 @@

                        //下发RGV任务之前，先读取一下安全门状态



                        //查找RGV进行下发任务
                        Dt_Task task = GetTask(speStackerCrane.DeviceCode);
                        Dt_Task task = GetTask(speStackerCrane.DeviceCode,getStackerObject);
                        if (task != null)
                        {
                            //调取写入RGV小车任务
@@ -97,11 +94,19 @@
                                _taskService.UpdateTaskStatusToNext(task);
                            }
                        }
                        else
                        {
                            if(speStackerCrane.DeviceCode=="RGV101" || speStackerCrane.DeviceCode == "RGV101")
                            {
                                //当没任务的时候，则进行移动
                                Returnposition(speStackerCrane.DeviceCode, getStackerObject.RGVCurrentlocation);
                            }
                                
                        }
                        

                    }
                }


            }
            catch (Exception ex)
            {
@@ -110,361 +115,500 @@
            return Task.CompletedTask;
        }

        /// <summary>
        /// èŽ·å–任务（暂时方法if判断）
        /// </summary>
        /// <param name="DeviceCode"></param>
        /// <param name="RGVCurrentlocation"></param>
        /// <returns></returns>
        private Dt_Task? GetTask(string DeviceCode)
        private Dt_Task? GetTask(string DeviceCode, GetStackerObject getStackerObject)
        {
            Dt_Task task;
            task = _taskService.QueryStackerCraneTask(DeviceCode);
            if (task != null)
            // æ ¹æ®è®¾å¤‡åç§°ï¼ŒèŽ·å–到设备相关数据
            AGVStation RGVTaskdevice = _agvStationService.Corridorequipment(DeviceCode);   //根据设备获取到内容
            return RGVTaskdevice.Station_tasktype switch
            {
                //判断入库任务
                if(task.TaskType== (int)TaskInboundTypeEnum.Inbound)
                {
                    if(task.TaskState== (int)TaskInStatusEnum.RGV_InNew)
                    {
                        return task;
                    }else if(task.TaskState== (int)TaskInStatusEnum.RGV_InPickupFinish) //取货完成后，进行放货的流程
                    {
                        //判断该HCJ是否可放货
                        bool Currebool = QueryCurrentAdder(task); //判断HCJ是否可以放货
                        if (Currebool)
                        {
                            return task;
                        }
                        else { return null; }
                    }else if (task.TaskState == (int)TaskInStatusEnum.RGV_InReleaseFinish) //放货完成后，进行子车取货流程
                    {
                        //默认子车在取货的地方
                        return task;
                    }
                    else if (task.TaskState == (int)TaskInStatusEnum.RGV_InZicheFinish) //子车取货完成后，进行放货流程
                    {
                        //获取需要放货的站台
                        AGVStation aGVStation = _agvStationService.GetAllStationByDeviceCode(int.Parse(task.CurrentAddress));   //获取到过道站台放货信息
                        if (aGVStation.Station_Area == 1)   //表示在外测
                        {
                            bool muchebool=MotherCarMoves(task, aGVStation);
                            if (muchebool)
                            {
                                return task;
                            }else { return null; }
                        }
                        else if(aGVStation.Station_Area == 2)   //表示在内侧
                        {
                            bool muchebool = MotherCarMovesinside(task, aGVStation);
                            if (muchebool)
                            {
                                return task;
                            }
                            else { return null; }
                        }else if (aGVStation.Station_Area == 3)     //放在过道HCJ
                        {
                            bool muchebool = HCJMotherCarMovesinside(task, aGVStation);
                            if (muchebool)
                            {
                                return task;
                            }
                            else { return null; }
                        }
                    }else if (task.TaskState == (int)TaskInStatusEnum.RGV_InZicheReleaseFinish) //子车放货完成
                    {
                        AGVStation aGVStation = _agvStationService.GetAllStationByDeviceCode(int.Parse(task.CurrentAddress));
                        if(aGVStation.Station_Area == 1)
                        {
                            return task;
                            /*RgvCraneTaskCommand standardCommands = ConvertMotherCarTaskCommand(task, "1021");
                            bool sendFlag = SendCommand2(standardCommands, ziche001);
                            if (sendFlag)
                            {
                                //记录下发过母车移动任务
                                _taskService.UpdateTaskStatusToNext(task);
                            }*/
                        }
                        else if (aGVStation.Station_Area == 2)      
                        {
                            RgvCraneTaskCommand standardCommands = ConvertMotherCarTaskCommand(task, "1021");   //注意：：：：该子车需要待定去向
                            bool sendFlag = SendCommand2(standardCommands, ziche002);
                            if (sendFlag)
                            {
                                //记录下发过母车移动任务
                                _taskService.UpdateTaskStatusToNext(task);
                            }
                        }
                (int)RGVTasktype.Inbound => HandleInboundTask(RGVTaskdevice, getStackerObject),
                (int)RGVTasktype.Outbound => OutboundEquipmentTask(RGVTaskdevice, getStackerObject),
                _ => null
            };

                        //进行移动子车

                    }
                    else if(task.TaskState == (int)TaskInStatusEnum.RGV_InZichemoveFinish) //子车移动完成后，进行
                    {
                        //获取需要放货的站台
                        AGVStation aGVStation = _agvStationService.GetAllStationByDeviceCode(int.Parse(task.CurrentAddress));   //获取入库站台信息
                        if (aGVStation.Station_Area == 1)   //入库口区域的1表示写入固定的1号子车104
                        {
                            //判断子车在哪个位置
                            int zicheadder = GetZichelocation(task, ziche001);
                            if(zicheadder!= int.Parse(aGVStation.ZicheMotherinlaw))
                            {
                                return task;
                            }
                        }
                        else if(aGVStation.Station_Area == 2)      //入库口区域的1表示写入固定的1号子车107
                        {
                            int zicheadder = GetZichelocation(task, ziche002);
                            if (zicheadder != int.Parse(aGVStation.ZicheMotherinlaw))
                            {
                                return task;
                            }
                        }
                    }
                }
                else if(task.TaskType == (int)TaskOutboundTypeEnum.Outbound)
                {
                    if (task.TaskState == (int)TaskOutStatusEnum.OutNew)
                    {
                        return task;
                    }else if (task.TaskState == (int)TaskOutStatusEnum.RGV_OutMothercarFinish)
                    {
                        return task;
                    }
                    else if (task.TaskState == (int)TaskOutStatusEnum.RGV_OutZicheFinish)
                    {
                        return task;
                    }else if(task.TaskState == (int)TaskOutStatusEnum.RGV_OutZicheReleaseFinish)
                    {
                        return task;
                    }else if(task.TaskState == (int)TaskOutStatusEnum.RGV_OutPickupFinish && task.CurrentAddress != "")
                    {
                        return task;
                    }
                }
        }

        #region å…¥åº“方法
        private Dt_Task? HandleInboundTask(AGVStation RGVTaskdevice, GetStackerObject getStackerObject)
        {
            if(RGVTaskdevice.Station_material== (int)RGVEquipment.InRGVForklift && getStackerObject.RgvCraneStatusValue== RgvEquipmentStatus.NoCargo)
            {
                return _taskService.GetInkouFinhuoTask(RGVTaskdevice.ChildPosiDeviceCode, 1);
            }
            else if (RGVTaskdevice.Station_material == (int)RGVEquipment.InRGVForklift && getStackerObject.RgvCraneStatusValue == RgvEquipmentStatus.HasCargo)
            {
                return _taskService.GetInkouFinhuoTask(RGVTaskdevice.ChildPosiDeviceCode, 2);
            }else if (RGVTaskdevice.Station_material == (int)RGVEquipment.Corridorcar && getStackerObject.RgvCraneStatusValue == RgvEquipmentStatus.NoCargo)
            {
                return ZichePickUpAisle(RGVTaskdevice, getStackerObject);
            }else if (RGVTaskdevice.Station_material == (int)RGVEquipment.Corridorcar && getStackerObject.RgvCraneStatusValue == RgvEquipmentStatus.HasCargo)
            {
                return GoodsPlacedCorridor(RGVTaskdevice, getStackerObject);
            }
            else if (RGVTaskdevice.Station_material == (int)RGVEquipment.Corridorcar && getStackerObject.RgvCraneStatusValue == RgvEquipmentStatus.NoCargo)
            {
                return ZicheMobile(RGVTaskdevice, getStackerObject);
            }
            else if (RGVTaskdevice.Station_material == (int)RGVEquipment.Mothertrailer && getStackerObject.RgvCraneStatusValue == RgvEquipmentStatus.HasCargo)
            {
                return MotherVehicleMovement(RGVTaskdevice);
            }
            else { return null; }

        }


        #region è¿‡é“子车进行取货
        public Dt_Task? ZichePickUpAisle(AGVStation RGVTaskdevice, GetStackerObject getStackerObject)
        {
            //获取子车取货任务
            Dt_Task dt_Task = _taskService.GetInzicheTask(RGVTaskdevice.ChildPosiDeviceCode,1);
            if(dt_Task.CurrentAddress== getStackerObject.RGVCurrentlocation.ToString())
            {
                return dt_Task;
            }
            else
            {
                //如果不等于，则进行判断子车在哪个位置
                if (RGVTaskdevice.Station_Area == 1)
                {
                    // æ ¹æ®å­è½¦ä½ç½®å¤„理不同情况
                    switch (getStackerObject.RGVCurrentlocation)
                    {
                        case int Waddress when Waddress == RGVTaskdevice.MotherCarDeviceCode:
                            return dt_Task;
                        case int Naddress when Naddress == RGVTaskdevice.MotherCardeputy:
                            return HandleMedialCase(dt_Task, RGVTaskdevice.MotherCarDeviceCode);
                        case int HCJaddress when HCJaddress == RGVTaskdevice.HCJStorageaddress:
                            return HandleMedialCase2(dt_Task, RGVTaskdevice);
                        default: return null;
                    }
                }
                else
                {
                    //取HCJ位的料判断
                    switch (getStackerObject.RGVCurrentlocation)
                    {
                        case int Waddress when Waddress == RGVTaskdevice.MotherCarDeviceCode:
                            return dt_Task;
                        case int Naddress when Naddress == RGVTaskdevice.MotherCardeputy:
                            return HandleMedialCase(dt_Task, RGVTaskdevice.MotherCarDeviceCode);
                        default: return null;
                    }
                }

            }
        }
        /// <summary>
        /// åˆ¤æ–­å¤–侧母车是否在入口口
        /// </summary>
        /// <param name="task"></param>
        /// <param name="currentStation"></param>
        /// <returns></returns>
        private Dt_Task? HandleMedialCase(Dt_Task task, int currentStation)
        {
            AGVStation Muche = _agvStationService.GetMothervehicle(currentStation);
            int motherCarAddress = GetDeviceAddress.GetEquipmentlocation(Muche.ChildPosiDeviceCode);
            if (motherCarAddress == Muche.Motherinlaw) return task;
            RGVMovetask(Muche.Motherinlaw, Muche.ChildPosiDeviceCode);
            return null;
        }
        /// <summary>
        /// åˆ¤æ–­å†…外侧母车是否在入库口
        /// </summary>
        /// <param name="task"></param>
        /// <param name="currentStation"></param>
        /// <returns></returns>
        private Dt_Task? HandleMedialCase2(Dt_Task task, AGVStation currentStation)
        {
            AGVStation Muche = _agvStationService.GetMothervehicle(currentStation.MotherCarDeviceCode);  //外侧母车
            AGVStation Muche2 = _agvStationService.GetMothervehicle(currentStation.MotherCardeputy);    //内侧母车

            int motherCarAddress = GetDeviceAddress.GetEquipmentlocation(Muche.ChildPosiDeviceCode);
            int motherCarAddress2 = GetDeviceAddress.GetEquipmentlocation(Muche2.ChildPosiDeviceCode);
            if (motherCarAddress == 0 || motherCarAddress2 == 0) return null;
            // å¦‚果母车不在预期位置，下发移动任务
            if (motherCarAddress != Muche.Motherinlaw)
            {
                RGVMovetask(Muche.Motherinlaw, Muche.ChildPosiDeviceCode);
            }
            if (motherCarAddress2 != Muche2.Motherinlaw)
            {
                RGVMovetask(Muche2.Motherinlaw, Muche2.ChildPosiDeviceCode);
            }
            if (motherCarAddress == Muche.Motherinlaw && motherCarAddress2 == Muche2.Motherinlaw) return task;
            // æ¯è½¦å·²åœ¨æ­£ç¡®ä½ç½®
            return null;
        }


        #endregion

        #region è¿‡é“子车进行放货
        public Dt_Task? GoodsPlacedCorridor(AGVStation RGVTaskdevice, GetStackerObject getStackerObject)
        {
            Dt_Task task = _taskService.GetInzicheTask(RGVTaskdevice.ChildPosiDeviceCode, 2);
            int nexaddres = int.Parse(task.NextAddress);
            switch (nexaddres)
            {
                case int Whcjaddress when Whcjaddress == RGVTaskdevice.MotherCarDeviceCode:    //放货点在第一个过道点
                    return MotherCarMoves(task, RGVTaskdevice);
                case int Waddress when Waddress == RGVTaskdevice.MotherCardeputy:              //放货点在第二个过道点
                    return MotherCarMovesinside(task, RGVTaskdevice);
                case int HCJaddress when HCJaddress == RGVTaskdevice.HCJStorageaddress:        //放货点在HCJ上
                    return HCJMotherCarMovesinside(task, RGVTaskdevice);
                default: return null;
            }
        }


        //区域一判断母车是否到位，可立即放货
        private Dt_Task? MotherCarMoves(Dt_Task _Task, AGVStation aGVStation)
        {
            AGVStation Muche = _agvStationService.GetMothervehicle(aGVStation.ZicheMotherinlaw);
            
            int motherCarAddress = GetDeviceAddress.GetEquipmentInMuche(Muche.ChildPosiDeviceCode);
            if (motherCarAddress == Muche.ZicheMotherinlaw) return _Task;
            if(motherCarAddress!=0) RGVMovetask(Muche.ZicheMotherinlaw, aGVStation.ChildPosiDeviceCode);

            return null;
        }

        //判断外侧母车位置
        private bool MotherCarMoves(Dt_Task _Task, AGVStation aGVStation)
        /// <summary>
        /// åˆ¤æ–­æ”¾ç¬¬äºŒä¸ªæ¯è½¦ä½ç½®
        /// </summary>
        /// <param name="_Task"></param>
        /// <param name="aGVStation"></param>
        /// <returns></returns>
        private Dt_Task? MotherCarMovesinside(Dt_Task _Task, AGVStation aGVStation)
        {
            int mcadder = GetMothercarlocation(_Task, aGVStation.Motherinlaw);
            if(mcadder != 0)
            AGVStation Muche = _agvStationService.GetMothervehicle(aGVStation.MotherCarDeviceCode);  //外侧母车
            AGVStation Muche2 = _agvStationService.GetMothervehicle(aGVStation.MotherCardeputy);    //内侧母车

            int motherCarAddress = GetDeviceAddress.GetEquipmentInMuche(Muche.ChildPosiDeviceCode);
            int motherCarAddress2 = GetDeviceAddress.GetEquipmentInMuche(Muche2.ChildPosiDeviceCode);
            // å¦‚果母车不在预期位置，下发移动任务
            if (motherCarAddress != Muche.Motherinlaw && motherCarAddress != 0)
            {
                if (mcadder == int.Parse(_Task.CurrentAddress))       //判断子车要去的位置，母车是否在该位置
                RGVMovetask(Muche.Motherinlaw, Muche.ChildPosiDeviceCode);
            }
            if (motherCarAddress2 != Muche2.ZicheMotherinlaw && motherCarAddress2 != 0)
            {
                RGVMovetask(Muche2.ZicheMotherinlaw, Muche2.ChildPosiDeviceCode);
            }
            if (motherCarAddress == Muche.Motherinlaw && motherCarAddress2 == Muche2.ZicheMotherinlaw) return _Task;
            // æ¯è½¦å·²åœ¨æ­£ç¡®ä½ç½®
            return null;
        }
        /// <summary>
        /// åˆ¤æ–­æ”¾åœ¨HCJ上面
        /// </summary>
        /// <param name="_Task"></param>
        /// <param name="aGVStation"></param>
        /// <returns></returns>
        private Dt_Task? HCJMotherCarMovesinside(Dt_Task _Task, AGVStation aGVStation)
        {
            AGVStation Muche = _agvStationService.GetMothervehicle(aGVStation.MotherCarDeviceCode);  //外侧母车
            AGVStation Muche2 = _agvStationService.GetMothervehicle(aGVStation.MotherCardeputy);    //内侧母车
            AGVStation Ziche3 = _agvStationService.GetZicheDeep(aGVStation.HCJStorageaddress);    //内侧子车

            int motherCarAddress = GetDeviceAddress.GetEquipmentInMuche(Muche.ChildPosiDeviceCode);
            int motherCarAddress2 = GetDeviceAddress.GetEquipmentInMuche(Muche2.ChildPosiDeviceCode);
            int ZiCarAddress3 = GetDeviceAddress.GetEquipmentInMuche(Ziche3.ChildPosiDeviceCode);
            // å¦‚果母车不在预期位置，下发移动任务
            if (motherCarAddress != Muche.Motherinlaw && motherCarAddress != 0)
            {
                RGVMovetask(Muche.Motherinlaw, Muche.ChildPosiDeviceCode);
            }
            if (motherCarAddress2 != Muche2.Motherinlaw && motherCarAddress2 != 0)
            {
                RGVMovetask(Muche2.Motherinlaw, Muche2.ChildPosiDeviceCode);
            }
            if (ZiCarAddress3 == Ziche3.HCJStorageaddress && ZiCarAddress3!=0)
            {
                //判断目标站台是入库到几号堆垛机
                if (_Task.TargetAddress == "3")     //入库至3号堆垛机
                {
                    return true;
                }
                else
                {
                    //下发母车移动出来接货任务
                    RgvCraneTaskCommand standardCommands = ConvertMotherCarTaskCommand(_Task, _Task.CurrentAddress);
                    
                    bool sendFlag = SendCommand2(standardCommands, aGVStation.ChildPosiDeviceCode);
                    if (sendFlag)
                    //判断外侧母车位置（2区域）
                    AGVStation MucheN = _agvStationService.GetMothervehicle(Ziche3.MotherCarDeviceCode);  //外侧母车
                    int motNCarAddress = GetDeviceAddress.GetEquipmentInMuche(MucheN.ChildPosiDeviceCode); //获取到母车当前位置
                    if (motNCarAddress!=0)
                    {
                        //记录下发过母车移动任务
                        _taskService.UpdateTaskStatusToNext(_Task);
                        if (MucheN.ZicheMotherinlaw == motNCarAddress)
                        {
                            RGVMovetask(Ziche3.MotherCarDeviceCode, Ziche3.ChildPosiDeviceCode);
                        }
                        else
                        {
                            RGVMovetask(MucheN.ZicheMotherinlaw, MucheN.ChildPosiDeviceCode);
                        }
                    }
                }
                else if (_Task.TargetAddress == "4")    //入库至4号堆垛机
                {
                    //判断外侧母车位置（2区域）
                    AGVStation MucheN = _agvStationService.GetMothervehicle(Ziche3.MotherCarDeviceCode);  //外侧母车
                    int motNCarAddress = GetDeviceAddress.GetEquipmentInMuche(MucheN.ChildPosiDeviceCode); //获取到母车当前位置
                    if (MucheN.Motherinlaw != motNCarAddress && motNCarAddress!=0)
                    {
                        RGVMovetask(MucheN.Motherinlaw, MucheN.ChildPosiDeviceCode);
                    }
                    AGVStation MucheN2 = _agvStationService.GetMothervehicle(Ziche3.MotherCardeputy);  //外侧母车
                    int motNCarAddress2 = GetDeviceAddress.GetEquipmentInMuche(MucheN2.ChildPosiDeviceCode); //获取到母车当前位置
                    if (MucheN2.ZicheMotherinlaw != motNCarAddress2 && motNCarAddress2!=0)
                    {
                        RGVMovetask(MucheN2.ZicheMotherinlaw, MucheN2.ChildPosiDeviceCode);
                    }

                    if (MucheN.Motherinlaw == motNCarAddress && MucheN2.ZicheMotherinlaw == motNCarAddress2)
                    {
                        RGVMovetask(Ziche3.MotherCardeputy, Ziche3.ChildPosiDeviceCode);
                    }
                }
            }

            return false;
            if (motherCarAddress == Muche.Motherinlaw && motherCarAddress2 == Muche2.Motherinlaw && ZiCarAddress3 != Ziche3.HCJStorageaddress) return _Task;
            // æ¯è½¦å·²åœ¨æ­£ç¡®ä½ç½®
            return null;
        }
        #endregion

        #region å­è½¦ç§»åŠ¨ä»»åŠ¡(后续可能需要优化一下)
        public Dt_Task? ZicheMobile(AGVStation RGVTaskdevice, GetStackerObject getStackerObject)
        {
            Dt_Task task = _taskService.GetInzicheTaskMobile(RGVTaskdevice.ChildPosiDeviceCode, 1);
            return task;
        }
        #endregion

        #region æ¯è½¦ç§»åŠ¨ä»»åŠ¡
        public Dt_Task? MotherVehicleMovement(AGVStation RGVTaskdevice)
        {
            Dt_Task task = _taskService.GetInzicheTaskMobile(RGVTaskdevice.ChildPosiDeviceCode, 2);
            int curradder = int.Parse(task.CurrentAddress);
            AGVStation GdZiche = _agvStationService.GetMotheaisle(curradder);
            int motherCarAddress = GetDeviceAddress.GetEquipmentInformation(GdZiche.ChildPosiDeviceCode);
            if (motherCarAddress != curradder && motherCarAddress!=0) return task;
            RGVMovetask(GdZiche.Motherinlaw, GdZiche.ChildPosiDeviceCode);
            return null;
        }
        #endregion

        #endregion

        #region å‡ºåº“方法
        public Dt_Task? OutboundEquipmentTask(AGVStation RGVTaskdevice, GetStackerObject getStackerObject)
        {
            return (RGVTaskdevice.Station_material, getStackerObject.RgvCraneStatusValue) switch
            {
                ((int)RGVEquipment.Mothertrailer, RgvEquipmentStatus.HasCargo)
                    => Mothertaskdistribution(RGVTaskdevice),

                ((int)RGVEquipment.Corridorcar, RgvEquipmentStatus.NoCargo)
                    => ChildPickupAddres(RGVTaskdevice),

                ((int)RGVEquipment.Corridorcar, RgvEquipmentStatus.HasCargo)
                    => Findshippingtask(RGVTaskdevice),

                ((int)RGVEquipment.OutRGVForklift, RgvEquipmentStatus.NoCargo)
                    => _taskService.GetOutkouFinhuoTask(RGVTaskdevice.ChildPosiDeviceCode,
                       RGVTaskdevice.HCJStorageaddress.ToString(), 1),

                ((int)RGVEquipment.OutRGVForklift, RgvEquipmentStatus.HasCargo)
                    => _taskService.GetOutkouFinhuoTask(RGVTaskdevice.ChildPosiDeviceCode,
                       RGVTaskdevice.HCJStorageaddress.ToString(), 2),

                _ => null
            };
        }

        //判断内侧母车位置
        private bool MotherCarMovesinside(Dt_Task _Task, AGVStation aGVStation)
        {
            //获取外侧母车位置
            int mcadder = GetMothercarlocation(_Task, aGVStation.MotherCarDeviceCode);
            //获取内侧母车位置
            int ncadder = GetMothercarlocation(_Task, _Task.CurrentAddress);    //传入过道的地址
        #region ä¸‹å‘母车任务，需要判断当前行小车在哪个位子

            if (mcadder != int.Parse(aGVStation.MotherCarDeviceCode) && ncadder == aGVStation.Station_code)       //判断外侧母车位置
        private Dt_Task? Mothertaskdistribution(AGVStation GdZiche)
        {
            // æå‰æ£€æŸ¥æ— æ•ˆçš„Area值
            if (GdZiche.Station_Area < 1 || GdZiche.Station_Area > 4)
                return null;

            AGVStation ZicheinnerSide = _agvStationService.GetMotheaisle(GdZiche.ZicheMotherinlaw);
            int ZiCarAddress3 = GetDeviceAddress.GetEquipmentInformation(ZicheinnerSide.ChildPosiDeviceCode);

            // ä½¿ç”¨switch语句提高可读性
            return GdZiche.Station_Area switch
            {
                return true;
                4 when ZiCarAddress3 != GdZiche.ZicheMotherinlaw
                    => _taskService.QueryStackerCraneTask(GdZiche.ChildPosiDeviceCode),

                3 when ZiCarAddress3 == ZicheinnerSide.HCJStorageaddress
                    => _taskService.QueryStackerCraneTask(GdZiche.ChildPosiDeviceCode),

                2 when ZiCarAddress3 != GdZiche.MotherCardeputy && ZiCarAddress3 != GdZiche.HCJStorageaddress
                    => _taskService.QueryStackerCraneTask(GdZiche.ChildPosiDeviceCode),

                1 when ZiCarAddress3 == ZicheinnerSide.HCJStorageaddress
                    => _taskService.QueryStackerCraneTask(GdZiche.ChildPosiDeviceCode),

                _ => null
            };
        }
        #endregion

        #region åˆ¤æ–­å·²ç§»åŠ¨å‡ºæ¥çš„母车，再判断小车位置
        public Dt_Task? ChildPickupAddres(AGVStation GdZiche)
        {
            if (GdZiche.Station_Area == 5)
                return _taskService.ChildVehicleMission(GdZiche);

            var task = _taskService.ChildVehicleMission(GdZiche);

            // å¿«é€Ÿè¿”回条件检查
            if (task.CurrentAddress != GdZiche.HCJStorageaddress.ToString())
                return task;

            var innerStation = _agvStationService.GetZicheDeep(GdZiche.HCJStorageaddress);
            if (GetDeviceAddress.GetEquipmentInformation(innerStation.ChildPosiDeviceCode) != innerStation.HCJStorageaddress)
                return task;

            var motherStation = _agvStationService.GetMothervehicle(innerStation.MotherCarDeviceCode);
            if (GetDeviceAddress.ReturnCurrentStatus(motherStation.ChildPosiDeviceCode))
                RGVMovetask(innerStation.MotherCarDeviceCode, innerStation.ChildPosiDeviceCode);

            return null;
        }
        #endregion

        #region æŸ¥æ‰¾å­è½¦æ”¾è´§ä»»åŠ¡
        public Dt_Task? Findshippingtask(AGVStation GdZiche)
        {
            Dt_Task task = _taskService.GetFinhuoTask(GdZiche.ChildPosiDeviceCode);
            if (GetDeviceAddress.HCJIsstock(task.NextAddress)) return task;
            return null;
        }
        #endregion

        #endregion

        #region å‡ºåº“小车移动任务下发
        public void Returnposition(string DeviceCode, int RGVCurrentlocation)
        {
            int HCJGoodsplatform = 1170;    //定义的放货站台
                                            //判断母车是否需要进行移动
            AGVStation GdZiche = _agvStationService.Corridorequipment(DeviceCode);
            if (GdZiche.Station_Area == 1)
            {
                switch (RGVCurrentlocation)
                {
                    case int Whcjaddress when Whcjaddress == GdZiche.MotherCarDeviceCode:    //在第一个母车上
                        RGVMovetask(HCJGoodsplatform, GdZiche.ChildPosiDeviceCode);
                        break;
                    case int Waddress when Waddress == GdZiche.MotherCardeputy:              //在第二个母车上
                        OutNMotherCar(GdZiche.MotherCarDeviceCode);
                        break;
                    case int HCJaddress when HCJaddress == GdZiche.HCJStorageaddress:        //在HCJ站台上
                        OutHCJMotherCar(GdZiche);
                        break;
                    default: break;
                }
            }
            else
            {
                if (mcadder == int.Parse(aGVStation.MotherCarDeviceCode))    //外侧母车需要移动
                switch (RGVCurrentlocation)
                {
                    //下发母车往里面走的任务
                    AGVStation aGVSta = _agvStationService.GetMothercarCode(aGVStation.MotherCarDeviceCode);    //堆垛机入库口

                    RgvCraneTaskCommand standardCommands = ConvertMotherCarTaskCommand(_Task, aGVSta.Station_code.ToString()); //下发母车移动至入库站台位
                    bool sendFlag = SendCommand2(standardCommands, aGVSta.ChildPosiDeviceCode);
                    if (sendFlag)
                    {
                        //记录下发过母车移动任务
                        _taskService.UpdateTaskStatusToNext(_Task);
                    }
                }

                if (ncadder != aGVStation.Station_code)    //下发母车
                {
                    RgvCraneTaskCommand standardCommands = ConvertMotherCarTaskCommand(_Task, aGVStation.Station_code.ToString());
                    bool sendFlag = SendCommand2(standardCommands, aGVStation.ChildPosiDeviceCode);
                    if (sendFlag)
                    {
                        //记录下发过母车移动任务
                        _taskService.UpdateTaskStatusToNext(_Task);
                    }
                    case int Whcjaddress when Whcjaddress == GdZiche.MotherCarDeviceCode:    //在第一个母车上，需要判断外侧子车是否在HCJ上
                        OutinnerSideNMotherCar(GdZiche);
                        break;
                    case int Waddress when Waddress == GdZiche.MotherCardeputy:              //在第二个母车上，需要判断子车与外侧母车是否在过道上
                        OutinnerSideMotherCar(GdZiche);
                        break;
                    default: break;
                }
            }
            return false;
        }
        private bool HCJMotherCarMovesinside(Dt_Task _Task, AGVStation aGVStation)  //传进来的站台为HCJ
        {
            //获取外侧母车位置
            int mcadder = GetMothercarlocation(_Task, aGVStation.MotherCarDeviceCode);
            //获取内侧母车位置
            int ncadder = GetMothercarlocation(_Task, aGVStation.MotherCardeputy);   

            if (mcadder != int.Parse(aGVStation.MotherCarDeviceCode) && ncadder != int.Parse(aGVStation.MotherCardeputy))       //判断外侧母车位置
        #region å¤–侧小车回归到起始点位
        /// <summary>
        /// åˆ¤æ–­æ”¾ç¬¬äºŒä¸ªæ¯è½¦ä½ç½®
        /// </summary>
        /// <param name="_Task"></param>
        /// <param name="aGVStation"></param>
        /// <returns></returns>
        private void OutNMotherCar(int MotherCarDeviceCode)
        {
            AGVStation Muche = _agvStationService.GetMothervehicle(MotherCarDeviceCode);  //外侧母车
            int motherCarAddress = GetDeviceAddress.GetEquipmentlocation(Muche.ChildPosiDeviceCode);
            if (motherCarAddress != Muche.Motherinlaw)
            {
                return true;
                RGVMovetask(Muche.Motherinlaw, Muche.ChildPosiDeviceCode);
            }
        }
        private void OutHCJMotherCar(AGVStation aGVStation)
        {
            AGVStation Muche = _agvStationService.GetMothervehicle(aGVStation.MotherCarDeviceCode);  //外侧母车
            AGVStation Muche2 = _agvStationService.GetMothervehicle(aGVStation.MotherCardeputy);    //内侧母车
            int motherCarAddress = GetDeviceAddress.GetEquipmentlocation(Muche.ChildPosiDeviceCode);
            int motherCarAddress2 = GetDeviceAddress.GetEquipmentlocation(Muche2.ChildPosiDeviceCode);
            // å¦‚果母车不在预期位置，下发移动任务
            if (motherCarAddress != Muche.Motherinlaw)
            {
                RGVMovetask(Muche.Motherinlaw, Muche.ChildPosiDeviceCode);
            }
            if (motherCarAddress2 != Muche2.Motherinlaw)
            {
                RGVMovetask(Muche2.Motherinlaw, Muche2.ChildPosiDeviceCode);
            }
        }
        #endregion

        #region å¤–侧小车回归到起始点位
        /// <summary>
        /// åœ¨ç¬¬ä¸€ä¸ªä½ç½®ï¼Œåˆ™åˆ¤æ–­å¤–侧子车是否在HCJ站台下面
        /// </summary>
        /// <param name="_Task"></param>
        /// <param name="aGVStation"></param>
        /// <returns></returns>
        private void OutinnerSideNMotherCar(AGVStation aGVStation)
        {
            AGVStation Ziche3 = _agvStationService.GetZicheOuterSide(aGVStation.HCJStorageaddress);    //外侧子车
            int ZiCarAddress3 = GetDeviceAddress.GetEquipmentlocation(Ziche3.ChildPosiDeviceCode);
            if (ZiCarAddress3 == Ziche3.HCJStorageaddress)
            {
                OutHCJMotherCar(Ziche3);
            }
            else
            {
                if (mcadder == int.Parse(aGVStation.MotherCarDeviceCode))    //外侧母车需要移动
                {
                    //下发母车往里面走的任务
                    AGVStation aGVSta = _agvStationService.GetMothercarCode(aGVStation.MotherCarDeviceCode);    //堆垛机入库口

                    RgvCraneTaskCommand standardCommands = ConvertMotherCarTaskCommand(_Task, aGVSta.Station_code.ToString()); //下发母车移动至入库站台位
                    bool sendFlag = SendCommand2(standardCommands, aGVSta.ChildPosiDeviceCode);
                    if (sendFlag)
                    {
                        //记录下发过母车移动任务
                        _taskService.UpdateTaskStatusToNext(_Task);
                    }
                }

                if (ncadder == int.Parse(aGVStation.MotherCardeputy))    //下发母车
                {
                    //下发母车往里面走的任务
                    AGVStation aGVSta = _agvStationService.GetMothercarCode(aGVStation.MotherCardeputy);    //堆垛机入库口

                    RgvCraneTaskCommand standardCommands = ConvertMotherCarTaskCommand(_Task, aGVSta.Station_code.ToString()); //下发母车移动至入库站台位
                    bool sendFlag = SendCommand2(standardCommands, aGVSta.ChildPosiDeviceCode);
                    if (sendFlag)
                    {
                        //记录下发过母车移动任务
                        _taskService.UpdateTaskStatusToNext(_Task);
                    }
                }
                RGVMovetask(aGVStation.HCJStorageaddress, aGVStation.ChildPosiDeviceCode);
            }
            return false;
        }

        

        public bool QueryCurrentAdder(Dt_Task task)
        private void OutinnerSideMotherCar(AGVStation aGVStation)
        {
            try
            AGVStation Muche = _agvStationService.GetMothervehicle(aGVStation.MotherCarDeviceCode);  //外侧母车
            int motherCarAddress = GetDeviceAddress.GetEquipmentlocation(Muche.ChildPosiDeviceCode);
            // å¦‚果母车不在预期位置，下发移动任务
            if (motherCarAddress != Muche.Motherinlaw)
            {
                //获取需要区分是否去入库与去不合格载货台任务
                IDevice? device = Storage.Devices.FirstOrDefault(x => x.DeviceCode == "HCJ2000");
                CommonStackerCrane Commonstacker = (CommonStackerCrane)device;
                DeviceProDTO? deviceProDTO = GetDeviceProDTO(Commonstacker, task.CurrentAddress, "HCJ_GoodsStatus");
                int HCJGStatus = GetLine(Commonstacker, deviceProDTO.DeviceProAddress);
                if (HCJGStatus == 0)    //为无货
                {
                    return true;
                }
                RGVMovetask(Muche.Motherinlaw, Muche.ChildPosiDeviceCode);
            }
            catch (Exception ex)
            {
                //记录异常情况
                _taskService.UpdateTaskExceptionMessage(task.TaskNum,$"判断HCJ站台是否有货信息出错，出错信息：{ex.Message}");
                throw;
            }
            OutinnerSideNMotherCar(aGVStation);

            return false;
        }
        #endregion

        //判断是否
        public bool GetMotherCarCurrentAdder(Dt_Task task)
        {
            try
            {
                IDevice? device = Storage.Devices.FirstOrDefault(x => x.DeviceCode == "HCJ2000");
                CommonStackerCrane Commonstacker = (CommonStackerCrane)device;
                DeviceProDTO? deviceProDTO = GetDeviceProDTO(Commonstacker, task.CurrentAddress, "HCJ_GoodsStatus");
                int HCJGStatus = GetLine(Commonstacker, deviceProDTO.DeviceProAddress);
                if (HCJGStatus == 0)    //为无货
                {
                    return true;
                }
            }
            catch (Exception ex)
            {
                //记录异常情况
                _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"判断HCJ站台是否有货信息出错，出错信息：{ex.Message}");
                throw;
            }

            return false;
        }

        #endregion


        /// <summary>
        /// ä¼ å…¥è¿‡é“地址，获取母车位置
        /// å­æ¯è½¦ç§»åŠ¨ä»»åŠ¡
        /// </summary>
        /// <param name="task"></param>
        /// <param name="MotherCarDeviceCode">过道地址</param>
        /// <param name="RGVAdders">目标地址</param>
        /// <param name="ChildPosiDeviceCode">设备编号</param>
        /// <returns></returns>
        public int GetMothercarlocation(Dt_Task task,string MotherCarDeviceCode)
        private bool RGVMovetask(int RGVAdders, string ChildPosiDeviceCode)
        {
            try
            {
                //利用入库站台地址获取母车plc
                AGVStation aGVStation =_agvStationService.GetMothercarCode(MotherCarDeviceCode);
                IDevice? device = Storage.Devices.FirstOrDefault(x => x.DeviceCode == aGVStation.ChildPosiDeviceCode);
                CommonStackerCrane Commonstacker = (CommonStackerCrane)device;
                DeviceProDTO? deviceProDTO = GetDeviceProDTO(Commonstacker, aGVStation.ChildPosiDeviceCode, "RGVCurrentlocation");
                int HCJGStatus = GetLine(Commonstacker, deviceProDTO.DeviceProAddress);
                return HCJGStatus;
            }
            catch (Exception ex)
            {
                //记录异常情况
                _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"判断母车位置信息出错，出错信息：{ex.Message}");
                throw;
            }
            RgvCraneTaskCommand standardCommands = ConvertMotherCarTaskCommand(RGVAdders);
            bool sendFlag = SendCommand2(standardCommands, ChildPosiDeviceCode);
            return sendFlag;
        }


        /// <summary>
        /// ä¼ å…¥è¿‡é“地址，获取子车车位置
        /// </summary>
        /// <param name="task"></param>
        /// <param name="MotherCarDeviceCode">入库站台地址</param>
        /// <returns></returns>
        public int GetZichelocation(Dt_Task task, string ChildPosiDeviceCode)
        {
            try
            {
                IDevice? device = Storage.Devices.FirstOrDefault(x => x.DeviceCode == ChildPosiDeviceCode);
                CommonStackerCrane Commonstacker = (CommonStackerCrane)device;
                DeviceProDTO? deviceProDTO = GetDeviceProDTO(Commonstacker, ChildPosiDeviceCode, "RGVCurrentlocation");
                int HCJGStatus = GetLine(Commonstacker, deviceProDTO.DeviceProAddress);
                return HCJGStatus;
            }
            catch (Exception ex)
            {
                //记录异常情况
                _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"判断子车位置信息出错，出错信息：{ex.Message}");
                throw;
            }
        }




        /// <summary>
        /// ä»»åŠ¡å®žä½“转换成命令Model
        /// </summary>
@@ -474,10 +618,19 @@
        public RgvCraneTaskCommand? ConvertToStackerCraneTaskCommand([NotNull] Dt_Task task)
        {
            RgvCraneTaskCommand stackerCraneTaskCommand = new RgvCraneTaskCommand();
            stackerCraneTaskCommand.RGV_RGVTasklocation = short.Parse(task.CurrentAddress);
            stackerCraneTaskCommand.RGV_RGVtasktype = 2;
            stackerCraneTaskCommand.RGV_Rgvtaskid = 1;          //rgv任务号
            stackerCraneTaskCommand.RGV_Lanjiantaskid = 0;      //兰剑任务id
            short locaticurr = task.RGVTaskType switch
            {
                _ when task.RGVTaskType == (short)RGVTaskTypeEnum.PickingUp ||
                       (task.RGVTaskType == (short)RGVTaskTypeEnum.TravelingOnly && task.TaskType != (int)TaskInStatusEnum.RGV_InZichemoveFinish)
                    => short.Parse(task.CurrentAddress),
                _ when task.RGVTaskType == (short)RGVTaskTypeEnum.Placing || (task.RGVTaskType == (short)RGVTaskTypeEnum.TravelingOnly && task.TaskType== (int)TaskInStatusEnum.RGV_InZichemoveFinish)
                    => short.Parse(task.NextAddress),
                _ => (short)0
            };
            stackerCraneTaskCommand.RGV_RGVTasklocation = locaticurr;
            stackerCraneTaskCommand.RGV_RGVtasktype = (short)task.RGVTaskType;
            stackerCraneTaskCommand.RGV_Rgvtaskid = (short)task.TaskNum;
            stackerCraneTaskCommand.RGV_Lanjiantaskid = (short)task.TaskNum;
            return stackerCraneTaskCommand;
        }

@@ -488,58 +641,26 @@
        /// <param name="task">任务实体</param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public RgvCraneTaskCommand? ConvertMotherCarTaskCommand([NotNull] Dt_Task task,string CurrentAddress)
        public RgvCraneTaskCommand? ConvertMotherCarTaskCommand(int RGVAddress)
        {
            RgvCraneTaskCommand stackerCraneTaskCommand = new RgvCraneTaskCommand();
            stackerCraneTaskCommand.RGV_RGVTasklocation = short.Parse(CurrentAddress);
            stackerCraneTaskCommand.RGV_RGVTasklocation = (short)RGVAddress;
            stackerCraneTaskCommand.RGV_RGVtasktype = 3;
            stackerCraneTaskCommand.RGV_Rgvtaskid = 999;          //rgv任务号
            stackerCraneTaskCommand.RGV_Lanjiantaskid = 999;      //兰剑任务id
            return stackerCraneTaskCommand;
        }


        public void wcsWriteLog(string SCLLinStack, string Logtype, string Magessadd)
        {
            WriteLog.Write_Log("RGV", SCLLinStack + "号RGV", Logtype, new { ä¿¡æ¯ = Magessadd });
        }



        //===========================================================HCJ协议读写查=============================================================================
        /// <summary>
        /// æŸ¥è¯¢å…·ä½“地址
        /// </summary>
        /// <param name="Commonstacker"></param>
        /// <param name="SCAddress"></param>
        /// <param name="Interactivet"></param>
        /// <returns></returns>
        public DeviceProDTO? GetDeviceProDTO(CommonStackerCrane Commonstacker, string SCAddress, string Interactivet)
        {
            return Commonstacker.DeviceProDTOs.FirstOrDefault(x => x.DeviceChildCode == SCAddress && x.DeviceProParamName == Interactivet && x.DeviceProParamType== "ReadDeviceCommand");
        }
        /// <summary>
        /// æ ¹åœ°å€è¯»å–输送线信息
        /// </summary>
        /// <param name="conveyorLine"></param>
        /// <param name="DeviceProDataBlock"></param>
        /// <returns></returns>
        public int GetLine(CommonStackerCrane Commonstacker, string DeviceProDataBlock)
        {
            return Commonstacker.Communicator.Read<short>(DeviceProDataBlock);
        }
        //===========================================================HCJ协议读写查===============================================================================


        public bool SendCommand2(RgvCraneTaskCommand command, string DeviceCode)
        {
            try
            {
                IDevice? device = Storage.Devices.FirstOrDefault(x => x.DeviceCode == DeviceCode);
                CommonStackerCrane Commonstacker = (CommonStackerCrane)device;
                SpeStackerCrane Commonstacker = (SpeStackerCrane)device;

                DeviceProDTO? deviceProDTO =  GetDeviceProDTO(Commonstacker, DeviceCode, "RGV_Rgvtaskstutas");
                int MCGStatus = GetLine(Commonstacker, deviceProDTO.DeviceProAddress);
                DeviceProDTO? deviceProDTO = GetDeviceAddress.GetRGVDeviceProDTO(Commonstacker, DeviceCode, "RGV_Rgvtaskstutas");
                int MCGStatus = GetDeviceAddress.RGVGetLine(Commonstacker, deviceProDTO.DeviceProAddress);


                if (Commonstacker.IsConnected)
                {
                    if (MCGStatus == (int)RgvJobCraneStatus.Ready)