更新最新代码

wangxinhui

10 天以前 834294889ab62bafaf034b1b87c2ead961c33476

 ÏîÄ¿´úÂë/WCS/WCSServices/WIDESEAWCS_Server/Controllers/AGV/AGVController.cs

@@ -2,12 +2,16 @@
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System.Text;
using System.Text.RegularExpressions;
using WIDESEA_DTO.Agv;
using WIDESEA_External.Model;
using WIDESEAWCS_Common.APIEnum;
using WIDESEAWCS_Common.TaskEnum;
using WIDESEAWCS_Core;
using WIDESEAWCS_Core.Enums;
using WIDESEAWCS_Core.Helper;
using WIDESEAWCS_Core.LogHelper;
using WIDESEAWCS_DTO;
using WIDESEAWCS_DTO.Agv;
using WIDESEAWCS_IBasicInfoRepository;
using WIDESEAWCS_ITaskInfoRepository;
@@ -15,9 +19,13 @@
using WIDESEAWCS_Model.Models;
using WIDESEAWCS_QuartzJob;
using WIDESEAWCS_QuartzJob.DTO;
using WIDESEAWCS_QuartzJob.Models;
using WIDESEAWCS_QuartzJob.Repository;
using WIDESEAWCS_Tasks;
using WIDESEAWCS_Tasks.ConveyorLineJob;
using WIDESEAWCS_Tasks.DBNames;
using WIDESEAWCS_Tasks.StackPlateJob;
using static Dm.net.buffer.ByteArrayBuffer;

namespace WIDESEAWCS_Server.Controllers
{
@@ -28,12 +36,14 @@
        private readonly IStationMangerRepository _stationMangerRepository;
        private readonly ITaskService _taskService;
        private readonly ITaskRepository _taskRepository;
        private readonly IRouterRepository _routerRepository;

        public AGVController(IStationMangerRepository stationMangerRepository, ITaskService taskService, ITaskRepository taskRepository)
        public AGVController(IStationMangerRepository stationMangerRepository, ITaskService taskService, ITaskRepository taskRepository,IRouterRepository routerRepository)
        {
            _stationMangerRepository = stationMangerRepository;
            _taskService = taskService;
            _taskRepository = taskRepository;
            _routerRepository = routerRepository;
        }

        
@@ -51,24 +61,44 @@
            {
                var task = _taskRepository.QueryFirst(x => secureApplyModel.ReceiveTaskID.ObjToInt() == x.TaskNum);
                if (task == null) throw new Exception("未找到任务");
                if (task.TaskType == TaskTypeEnum.Outbound.ObjToInt())
                if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup)
                {
                    var content = TakeRequest(task.CurrentAddress);
                    if (!content.Status)
                    if (task.TaskState==TaskStatusEnum.AGV_Executing.ObjToInt())//出库取货请求
                    {
                        throw new Exception(content.Message);
                        var content = TakeRequest(secureApplyModel.WbCode);
                        if (!content.Status)
                        {
                            throw new Exception(content.Message);
                        }
                    }
                    else//出库放货请求
                    {
                        var content = PutRequest(task.NextAddress, task);
                        if (!content.Status)
                        {
                            throw new Exception(content.Message);
                        }
                    }
                }
                else
                {
                    var content = PutRequest(task.NextAddress, task.PalletType);
                    if (!content.Status)
                    if (task.TaskState == TaskStatusEnum.AGV_Executing.ObjToInt())//入库取货请求
                    {
                        throw new Exception(content.Message);
                        var content = TakeRequest(secureApplyModel.WbCode);
                        if (!content.Status)
                        {
                            throw new Exception(content.Message);
                        }
                    }
                    else//入库放货请求
                    {
                        var content = PutRequest(task.NextAddress, task);
                        if (!content.Status)
                        {
                            throw new Exception(content.Message);
                        }
                    }
                }
                task.TaskState = TaskStatusEnum.AGV_Puting.ObjToInt();
                var up = _taskRepository.UpdateData(task);
                agvResponse.OK("成功","0");
            }
            catch (Exception ex)
@@ -200,17 +230,31 @@
                if (task == null) throw new Exception($"未找到任务,任务号【{agvUpdateModel.ReceiveTaskID}】");
                switch (agvUpdateModel.GoodsState)
                {
                    //case 1://出库根据这个信号判断取货完成
                    //    if (task.TaskType == TaskTypeEnum.Outbound.ObjToInt())
                    //    {
                    //        var content = TakeFinish(task.CurrentAddress);
                    //        if (!content.Status) throw new Exception(content.Message);
                    //        task.TaskState = TaskStatusEnum.AGV_Finish.ObjToInt();
                    //        var up = _taskRepository.DeleteAndMoveIntoHty(task, OperateTypeEnum.自动完成);
                    //        _taskService.TaskCompleted(task.TaskNum);
                    //    }
                    //    break;
                    case 2://入库根据这个信号判断放货完成
                    case "1"://出库根据这个信号判断取货完成

                        //更新任务状态
                        _taskService.UpdateTask(task, TaskStatusEnum.AGV_TakeFinish);
                        if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup)
                        {
                            var content = TakeFinish(task.CurrentAddress);
                            if (!content.Status) 
                            {
                                throw new Exception(content.Message);
                            };
                        }
                        else
                        {
                            if (task.TaskType == TaskTypeEnum.PrintYLInbound.ObjToInt() || task.TaskType == TaskTypeEnum.PrintYLBackInbound.ObjToInt())
                            {
                                var content = TakeFinish(task.CurrentAddress);
                                if (!content.Status)
                                {
                                    throw new Exception(content.Message);
                                };
                            }
                        }
                        return agvResponse.OK("成功", "0");
                    case "2"://入库根据这个信号判断放货完成
                        if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.InboundGroup)
                        {
                            Dt_StationManger dt_Station = _stationMangerRepository.QueryFirst(x => x.StationCode == task.NextAddress);
@@ -218,14 +262,41 @@
                            {
                                throw new Exception($"{task.NextAddress}AGV站台未定义");
                            }
                            task.CurrentAddress = dt_Station.StationCode;
                            task.NextAddress = "";
                            task.TaskState = TaskStatusEnum.AGV_Finish.ObjToInt();
                            task.DeviceCode = dt_Station.StationDeviceCode;
                            var up = _taskRepository.UpdateData(task);
                            if (task.TaskType == TaskTypeEnum.PrintYLInbound.ObjToInt() || task.TaskType == TaskTypeEnum.PrintYLBackInbound.ObjToInt())
                            {
                                List<Dt_Router> routers = _routerRepository.QueryData(x => x.InOutType == task.TaskType && task.NextAddress == x.StartPosi);
                                Dt_Router router = routers.FirstOrDefault();
                                if (router == null)
                                {
                                    throw new Exception($"任务号:{task.TaskNum}未找到路由配置信息");
                                }
                                string oldAddress = task.NextAddress;
                                //更新任务状态
                                task.CurrentAddress = router.NextPosi;
                                task.NextAddress = "";
                                task.DeviceCode = router.ChildPosiDeviceCode;
                                _taskService.UpdateTask(task, TaskStatusEnum.AGV_Finish);
                                PutFinish(oldAddress, task.TaskNum);
                            }
                            else
                            {
                                task.CurrentAddress = dt_Station.StationCode;
                                task.NextAddress = "";
                                task.TaskState = TaskStatusEnum.AGV_Finish.ObjToInt();
                                task.DeviceCode = dt_Station.StationDeviceCode;
                                _taskRepository.UpdateData(task);
                            }
                            return agvResponse.OK("成功","0");
                        }
                        break;
                        else
                        {
                            _taskService.TaskCompleted(task.TaskNum);
                            if (task.TaskType==TaskTypeEnum.PrintYLOutbound.ObjToInt() || task.TaskType == TaskTypeEnum.OutCarton.ObjToInt())
                            {
                                PutFinish(task.NextAddress);
                            }
                            return agvResponse.OK("成功", "0");
                        }
                    default:
                        throw new Exception($"未定义方法名【{agvUpdateModel.TaskState}】");
                }
@@ -235,7 +306,6 @@
                agvResponse.Error(ex.Message);
            }
            return agvResponse;
            //return _taskService.AgvUpdateTask(agvUpdateModel);
        }

        /// <summary>
@@ -245,7 +315,7 @@
        /// <param name="palletType"></param>
        /// <returns></returns>
        [HttpPost, HttpGet, Route("PutRequest"), AllowAnonymous]
        public WebResponseContent PutRequest(string code, int palletType)
        public WebResponseContent PutRequest(string code, Dt_Task task)
        {
            WebResponseContent content = new WebResponseContent();
            try
@@ -255,22 +325,130 @@
                {
                    return content.Error($"未找到站台配置");
                }
                #region todo:临时逻辑
                if (stationManger.StationDeviceCode=="MES")
                {
                    
                    RequestAGVArriveDTO requestAGVArriveDTO =new RequestAGVArriveDTO()
                    {
                        SD_WorkCentreAgvArriveNoticeInfo=new List<AgvArriveNotice> { new AgvArriveNotice()
                        {
                            DispatchPlanMaterialId=task.DispatchPlanId,
                            WorkCentreCode=task.WorkCentreCode,
                            LocationCode=code,
                            CallId=Guid.NewGuid().ToString().Replace("-","")
                        } }
                    };
                    MESResponse response = _taskService.MESAvgArriveNotice(requestAGVArriveDTO).DeserializeObject<MESResponse>() ?? throw new Exception("未获取到返回信息");
                    if (!response.Result)
                    {
                        throw new Exception($"调用MES小车允许放货报错,MES返回信息"+ Regex.Replace(response.Msg, @"\\u([0-9a-fA-F]{4})", match => {
                            return ((char)Convert.ToInt32(match.Groups[1].Value, 16)).ToString();
                        }));
                    }
                    if (response.Obj)
                    {
                        return content.Error($"允许取料");
                    }
                    else
                    {
                        return content.Error($"禁止放料");
                    }
                    
                }
                #endregion
                IDevice? device = Storage.Devices.FirstOrDefault(x => x.DeviceCode == stationManger.StationDeviceCode);
                if (device == null)
                {
                    return content.Error($"未找到对应设备");
                }

                OtherDevice otherDevice = (OtherDevice)device;

                short Command = otherDevice.GetValue<R_ConveyorLineCPDB, short>(R_ConveyorLineCPDB.Command, stationManger.StationCode);
                if (Command == 3)
                if (device.DeviceCode.Contains("Plate"))
                {
                    content.OK("允许放料");
                    CommonConveyorLine commonConveyorLine = (CommonConveyorLine)device;
                    StackPlateTaskCommandCommand command = commonConveyorLine.ReadCustomer<StackPlateTaskCommandCommand>(device.DeviceCode);

                    if (command != null && command.State == 2 && command.InteractiveSignal == 1)
                    {
                        return content.OK("允许放料");
                    }
                    else
                    {
                        return content.Error("禁止放料");
                    }
                }
                else
                {
                    return content.Error("禁止放料");

                    OtherDevice otherDevice = (OtherDevice)device;

                    if (device.DeviceCode.Contains("CP"))//成品输送线
                    {
                        short Command = otherDevice.GetValue<R_ConveyorLineCPDB, short>(R_ConveyorLineCPDB.Command, stationManger.StationCode);
                        if (Command == 3)
                        {
                            content.OK("允许放料");
                        }
                        else
                        {
                            return content.Error("禁止放料");
                        }
                    }
                    else if (device.DeviceCode.Contains("Coveryor"))//接驳台
                    {
                        bool RequestPut = otherDevice.GetValue<CoveryorDB, bool>(CoveryorDB.C_RequestPut, stationManger.StationDeviceCode);
                        if (!RequestPut)
                        {
                            otherDevice.SetValue(CoveryorDB.C_InTaskNum, task.TaskNum, stationManger.StationDeviceCode);
                            otherDevice.SetValue(CoveryorDB.C_RequestPut, true, stationManger.StationDeviceCode);
                            Thread.Sleep(1000);
                        }
                        bool AllowFinish = otherDevice.GetValue<CoveryorDB, bool>(CoveryorDB.C_AllowFinish, stationManger.StationDeviceCode);
                        if (AllowFinish)
                        {
                            content.OK("允许放料");
                        }
                        else
                        {
                            return content.Error("禁止放料");
                        }
                    }
                    else if (device.DeviceCode.Contains("Retract"))//伸缩货叉
                    {
                        bool RequestPut = otherDevice.GetValue<RetractDB, bool>(RetractDB.Ret_RequestPut, stationManger.StationDeviceCode);
                        if (!RequestPut)
                        {
                            otherDevice.SetValue(RetractDB.Ret_TargetAddress, Convert.ToInt16(stationManger.StationCode), stationManger.StationDeviceCode);
                            otherDevice.SetValue(RetractDB.Ret_RequestPut, true, stationManger.StationDeviceCode);
                            Thread.Sleep(1000);
                        }
                        bool AllowFinish = otherDevice.GetValue<RetractDB, bool>(RetractDB.Ret_AllowFinish, stationManger.StationDeviceCode);
                        if (AllowFinish)
                        {
                            content.OK("允许放料");
                        }
                        else
                        {
                            return content.Error("禁止放料");
                        }
                    }
                    else if (device.DeviceCode.Contains("TrussCarton"))//桁架
                    {
                        bool RequestPut = otherDevice.GetValue<W_TrussCartonDB, bool>(GetCartonRequest(stationManger.StackerCraneStationCode), stationManger.StationDeviceCode);
                        if (!RequestPut)
                        {
                            otherDevice.SetValue(GetCartonRequest(stationManger.StackerCraneStationCode), true, stationManger.StationDeviceCode);
                            Thread.Sleep(1000);
                        }
                        bool AllowFinish = otherDevice.GetValue<R_TrussCartonDB, bool>(GetCarton(stationManger.StackerCraneStationCode), stationManger.StationDeviceCode);
                        if (AllowFinish)
                        {
                            content.OK("允许放料");
                        }
                        else
                        {
                            return content.Error("禁止放料");
                        }
                    }
                }
                return content;
            }
@@ -287,11 +465,11 @@
        /// <param name="code"></param>
        /// <returns></returns>
        [HttpPost, HttpGet, Route("PutFinish"), AllowAnonymous]
        public WebResponseContent PutFinish(string code)
        public WebResponseContent PutFinish(string code,int taskNum=0)
        {
            try
            {
                Dt_StationManger stationManger = _stationMangerRepository.QueryFirst(x => x.AGVStationCode == code);
                Dt_StationManger stationManger = _stationMangerRepository.QueryFirst(x => x.StationCode == code);
                if (stationManger == null)
                {
                    return WebResponseContent.Instance.Error($"未找到站台配置");
@@ -301,14 +479,103 @@
                {
                    return WebResponseContent.Instance.Error($"未找到对应设备");
                }

                OtherDevice otherDevice = (OtherDevice)device;
                otherDevice.SetValue(GroundStationDBName.W_PutFinish, true, stationManger.StationCode);
                if (device.DeviceCode.Contains("Plate"))
                {
                    CommonConveyorLine commonConveyorLine = (CommonConveyorLine)device;
                    commonConveyorLine.SetValue(StackPlateDBName.WriteInteractiveSignal, Convert.ToInt16(1), device.DeviceCode);
                    return WebResponseContent.Instance.OK();
                }
                else
                {
                    OtherDevice otherDevice = (OtherDevice)device;
                    if (device.DeviceCode.Contains("Coveryor"))//接驳台
                    {
                        otherDevice.SetValue(CoveryorDB.C_PutFinish, true, stationManger.StationDeviceCode);
                    }
                    else if (device.DeviceCode.Contains("Retract"))//伸缩货叉
                    {
                        otherDevice.SetValue(RetractDB.Ret_PutFinish, true, stationManger.StationDeviceCode);
                    }
                    else if (device.DeviceCode.Contains("TrussCarton"))//纸箱桁架
                    {
                        otherDevice.SetValue(GetCartonPut(stationManger.StackerCraneStationCode), true, stationManger.StationDeviceCode);
                    }
                }
                return WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }
        /// <summary>
        /// èŽ·å–桁架放料信号
        /// </summary>
        public W_TrussCartonDB GetCartonPut(string StationCode)
        {
            switch (StationCode)
            {
                case "1":
                    return W_TrussCartonDB.W_CartonPut1;
                case "2":
                    return W_TrussCartonDB.W_CartonPut2;
                case "3":
                    return W_TrussCartonDB.W_CartonPut3;
                case "4":
                    return W_TrussCartonDB.W_CartonPut4;
                case "5":
                    return W_TrussCartonDB.W_CartonPut5;
                case "6":
                    return W_TrussCartonDB.W_CartonPut6;
                default:
                    throw new Exception("未定义工位");
            }
        }
        /// <summary>
        /// èŽ·å–桁架请求信号
        /// </summary>
        public W_TrussCartonDB GetCartonRequest(string StationCode)
        {
            switch (StationCode)
            {
                case "1":
                    return W_TrussCartonDB.W_CartonRequest1;
                case "2":
                    return W_TrussCartonDB.W_CartonRequest2;
                case "3":
                    return W_TrussCartonDB.W_CartonRequest3;
                case "4":
                    return W_TrussCartonDB.W_CartonRequest4;
                case "5":
                    return W_TrussCartonDB.W_CartonRequest5;
                case "6":
                    return W_TrussCartonDB.W_CartonRequest6;
                default:
                    throw new Exception("未定义工位");
            }
        }

        /// <summary>
        /// èŽ·å–桁架进入信号
        /// </summary>
        public R_TrussCartonDB GetCarton(string StationCode)
        {
            switch (StationCode)
            {
                case "1":
                    return R_TrussCartonDB.R_CartonAllow1;
                case "2":
                    return R_TrussCartonDB.R_CartonAllow2;
                case "3":
                    return R_TrussCartonDB.R_CartonAllow3;
                case "4":
                    return R_TrussCartonDB.R_CartonAllow4;
                case "5":
                    return R_TrussCartonDB.R_CartonAllow5;
                case "6":
                    return R_TrussCartonDB.R_CartonAllow6;
                default:
                    throw new Exception("未定义工位");
            }
        }

@@ -321,49 +588,82 @@
        [HttpPost, HttpGet, Route("TakeRequest"), AllowAnonymous]
        public WebResponseContent TakeRequest(string code)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                Dt_StationManger stationManger = _stationMangerRepository.QueryFirst(x => x.AGVStationCode == code);
                if (stationManger == null)
                {
                    return WebResponseContent.Instance.Error($"未找到站台配置");
                    return WebResponseContent.Instance.Error($"未找到站台配置{code}");
                }
                IDevice? device = Storage.Devices.FirstOrDefault(x => x.DeviceCode == stationManger.StationDeviceCode);
                if (device == null)
                {
                    return WebResponseContent.Instance.Error($"未找到对应设备");
                    return WebResponseContent.Instance.Error($"未找到对应设备{stationManger.StationDeviceCode}");
                }

                OtherDevice otherDevice = (OtherDevice)device;

                bool canPut = otherDevice.GetValue<GroundStationDBName, bool>(GroundStationDBName.R_IsCanTake, stationManger.StationCode);
                if (canPut)
                if (device.DeviceCode.Contains("Plate"))
                {
                    otherDevice.SetValue(GroundStationDBName.W_TakeRequest, true, stationManger.StationCode);
                    return WebResponseContent.Instance.OK();
                }
                else
                {
                    otherDevice.SetValue(GroundStationDBName.W_TakeRequest, true, stationManger.StationCode);
                    Thread.Sleep(1000);
                    canPut = otherDevice.GetValue<GroundStationDBName, bool>(GroundStationDBName.R_IsCanTake, stationManger.StationCode);
                    if (canPut)
                    CommonConveyorLine commonConveyorLine = (CommonConveyorLine)device;
                    StackPlateTaskCommandCommand command = commonConveyorLine.ReadCustomer<StackPlateTaskCommandCommand>(device.DeviceCode);
                    
                    if (command != null&&command.State == 2 && command.InteractiveSignal == 2)
                    {
                        return WebResponseContent.Instance.OK();
                        return content.OK("允许取料");
                    }
                    else
                    {
                        return WebResponseContent.Instance.Error($"取货申请中");
                        return content.Error("禁止取料");
                    }
                }
                else
                {
                    OtherDevice otherDevice = (OtherDevice)device;

                    if (otherDevice.DeviceCode.Contains("CP"))//成品输送线
                    {
                        short Command = otherDevice.GetValue<R_ConveyorLineCPDB, short>(R_ConveyorLineCPDB.Command, stationManger.StationCode);
                        if (Command == 2)
                        {
                            content.OK("允许取料");
                        }
                        else
                        {
                            return content.Error("禁止取料");
                        }
                    }
                    else if (device.DeviceCode.Contains("Coveryor"))//接驳台
                    {
                        bool AllowTake = otherDevice.GetValue<CoveryorDB, bool>(CoveryorDB.C_AllowTake, stationManger.StationDeviceCode);
                        if (AllowTake)
                        {
                            content.OK("允许取料");
                        }
                        else
                        {
                            return content.Error("禁止取料");
                        }
                    }
                    else if (device.DeviceCode.Contains("Retract"))//伸缩货叉
                    {
                        bool AllowTake = otherDevice.GetValue<RetractDB, bool>(RetractDB.Ret_AllowTake, stationManger.StationDeviceCode);
                        if (AllowTake)
                        {
                            content.OK("允许取料");
                        }
                        else
                        {
                            return content.Error("禁止取料");
                        }
                    }
                }
                return content;
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error(ex.Message);
                return content.Error(ex.Message);
            }
        }

        //[HttpPost, HttpGet, Route("TakeFinish"), AllowAnonymous]
        /// <summary>
        /// å–货完成
        /// </summary>
@@ -374,7 +674,7 @@
        {
            try
            {
                Dt_StationManger stationManger = _stationMangerRepository.QueryFirst(x => x.AGVStationCode == code);
                Dt_StationManger stationManger = _stationMangerRepository.QueryFirst(x => x.StationCode == code);
                if (stationManger == null)
                {
                    return WebResponseContent.Instance.Error($"未找到站台配置");
@@ -384,11 +684,103 @@
                {
                    return WebResponseContent.Instance.Error($"未找到对应设备");
                }
                if (device.DeviceCode.Contains("Plate"))
                {
                    CommonConveyorLine commonConveyorLine = (CommonConveyorLine)device;
                    commonConveyorLine.SetValue(StackPlateDBName.WriteInteractiveSignal, Convert.ToInt16(2), device.DeviceCode);
                    return WebResponseContent.Instance.OK();
                }
                else
                {
                    OtherDevice otherDevice = (OtherDevice)device;
                    if (device.DeviceCode.Contains("CP"))
                    {
                        otherDevice.SetValue(W_ConveyorLineCPDB.W_Command, 2, stationManger.StationCode);
                    }
                    else if (device.DeviceCode.Contains("Coveryor"))
                    {
                        otherDevice.SetValue(CoveryorDB.C_TakeFinish, true, stationManger.StationDeviceCode);
                    }
                    else if (device.DeviceCode.Contains("Retract"))//伸缩货叉
                    {
                        otherDevice.SetValue(RetractDB.Ret_TakeFinish, true, stationManger.StationDeviceCode);
                    }
                }

                OtherDevice otherDevice = (OtherDevice)device;
                otherDevice.SetValue(GroundStationDBName.W_TakeFinish, true, stationManger.StationCode);
                Thread.Sleep(1000);
                otherDevice.SetValue(GroundStationDBName.W_TakeFinish, false, stationManger.StationCode);
                return WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }
        /// <summary>
        /// AGV确认完成接口(取放)
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        [HttpPost, HttpGet, Route("AGVFinish"), AllowAnonymous]
        public WebResponseContent AGVFinish(string address,int taskNum)
        {
            try
            {
                Dt_Task task = _taskRepository.QueryFirst(x=>x.TaskNum==taskNum && x.DeviceCode=="AGV");
                if (task==null)
                {
                    return WebResponseContent.Instance.Error($"{taskNum}AGV任务不存在");
                }
                //获取对应的坐标点
                Dt_StationManger stationManger = _stationMangerRepository.QueryFirst(x=>x.AGVStationCode== address);
                if (stationManger==null)
                {
                    return WebResponseContent.Instance.Error($"{address}AGV地址编号不存在");
                }
                if (task.TaskState == TaskStatusEnum.AGV_Executing.ObjToInt())//取货
                {
                    if (task.CurrentAddress != stationManger.StationCode)
                    {
                        return WebResponseContent.Instance.Error($"{taskNum}AGV任务取货地址编号不是{address}");
                    }
                    AgvFinishDTO agvFinishDTO = new AgvFinishDTO()
                    {
                        ReceiveTaskID = task.TaskNum.ToString(),
                        Variables = new List<PointDetail>()
                        {
                            new PointDetail()
                            {
                                Code="isPick",
                                Value="true"
                            }
                        }
                    };
                    //发送AGV完成通知
                    WebResponseContent content = _taskService.AGVFinish(agvFinishDTO);
                    if (!content.Status)
                        throw new Exception(content.Message);
                }
                else//放货
                {
                    if (task.NextAddress != stationManger.StationCode)
                    {
                        return WebResponseContent.Instance.Error($"{taskNum}AGV任务放货地址编号不是{address}");
                    }
                    AgvFinishDTO agvFinishDTO = new AgvFinishDTO()
                    {
                        ReceiveTaskID = task.TaskNum.ToString(),
                        Variables = new List<PointDetail>()
                        {
                            new PointDetail()
                            {
                                Code="isDown",
                                Value="true"
                            }
                        }
                    };
                    //发送AGV完成通知
                    WebResponseContent content = _taskService.AGVFinish(agvFinishDTO);
                    if (!content.Status)
                        throw new Exception(content.Message);
                }
                return WebResponseContent.Instance.OK();
            }
            catch (Exception ex)