1

huangxiaoqiang

3 天以前 ec9c9add38591d7c7a2708ac43ed6b3fce1a4063

 ÏîÄ¿´úÂë/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/RGVJob_FirstFloor/CommonRGV_FirstFloorJob.cs

@@ -44,10 +44,10 @@
using WIDESEAWCS_QuartzJob.Models;
using WIDESEAWCS_QuartzJob.Service;
using WIDESEAWCS_SignalR;
using WIDESEAWCS_TaskInfoRepository;
using WIDESEAWCS_Tasks.ConveyorLineJob;
using WIDESEAWCS_Tasks.RGVJob;
using WIDESEAWCS_Tasks.StackerCraneJob;
using static Microsoft.EntityFrameworkCore.DbLoggerCategory.Database;

namespace WIDESEAWCS_Tasks
{
@@ -55,6 +55,7 @@
    public class CommonRGV_FirstFloorJob : JobBase, IJob
    {
        private readonly ITaskService _taskService;
        private readonly ITask_HtyRepository _task_HtyRepository;
        private readonly ITaskRepository _taskRepository;
        private readonly ITaskExecuteDetailService _taskExecuteDetailService;
        private readonly IRouterService _routerService;
@@ -66,7 +67,7 @@
        private static List<string>? userTokenIds;
        private static List<int>? userIds;

        public CommonRGV_FirstFloorJob(ITaskService taskService, ITaskExecuteDetailService taskExecuteDetailService, IRouterService routerService, IDt_StationManagerService stationManagerService, IMapper mapper, WIDESEAWCS_Core.Caches.ICacheService cacheService, INoticeService noticeService, ITaskRepository taskRepository, IDt_StationManagerRepository stationManagerRepository)
        public CommonRGV_FirstFloorJob(ITaskService taskService, ITaskExecuteDetailService taskExecuteDetailService, IRouterService routerService, IDt_StationManagerService stationManagerService, IMapper mapper, WIDESEAWCS_Core.Caches.ICacheService cacheService, INoticeService noticeService, ITaskRepository taskRepository, IDt_StationManagerRepository stationManagerRepository, ITask_HtyRepository task_HtyRepository)
        {
            _taskService = taskService;
            _taskExecuteDetailService = taskExecuteDetailService;
@@ -77,6 +78,7 @@
            _noticeService = noticeService;
            _taskRepository = taskRepository;
            _stationManagerRepository = stationManagerRepository;
            _task_HtyRepository = task_HtyRepository;
        }

        public Task Execute(IJobExecutionContext context)
@@ -310,7 +312,7 @@
                    {
                        if (commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic) && !commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault))
                        {
                            var taskSecond = _taskRepository.QueryFirst(x => x.RGVName == "RGV02" && x.TaskNum == commonRGVSecond.GetValue<RGVDBName, short>(RGVDBName.RGVTaskNum));
                            var taskSecond = _taskRepository.QueryFirst(x => x.RGVName == "RGV02" && x.TaskNum == commonRGVSecond.GetValue<RGVDBName, short>(RGVDBName.RGVTaskNum) && ((x.TaskType == (int)TaskInboundTypeEnum.Inbound && x.TaskState < 230) || (x.TaskType == (int)TaskOutboundTypeEnum.Outbound)));
                            if (taskSecond != null)
                            {
                                if (taskSecond.TaskState == (int)TaskOutStatusEnum.RGV_Outdispatch || taskSecond.TaskState == (int)TaskOutStatusEnum.RGV_OutdispatchFinish || taskSecond.TaskState == (int)TaskInStatusEnum.RGV_Indispatch || taskSecond.TaskState == (int)TaskInStatusEnum.RGV_InAwaitWMS || taskSecond.TaskState == (int)TaskInStatusEnum.RGV_IndispatchFinish)
@@ -320,6 +322,7 @@
                                        if (task.TargetStation- taskSecond.SourceStation > 1 && task.TargetStation - taskSecond.TargetStation > 1)
                                        {
                                            LogAndWarn("执行调度任务控制", $"【{commonRGV.DeviceCode}工作模式：【{commonRGV.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】设备状态：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】【{commonRGVSecond.DeviceCode}】任务【{JsonConvert.SerializeObject(taskSecond)}】{commonRGVSecond.DeviceCode}返回任务：【{JsonConvert.SerializeObject(task)}】】");
                                            Thread.Sleep(1000);
                                            return task;
                                        }
                                    }
@@ -331,6 +334,7 @@
                                        if (task.TargetStation - taskSecond.TargetStation > 1)
                                        {
                                            LogAndWarn("执行调度任务控制", $"【{commonRGV.DeviceCode}工作模式：【{commonRGV.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】设备状态：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】【{commonRGVSecond.DeviceCode}】任务【{JsonConvert.SerializeObject(taskSecond)}】{commonRGVSecond.DeviceCode}返回任务：【{JsonConvert.SerializeObject(task)}】】");
                                            Thread.Sleep(1000);
                                            return task;
                                        }
                                    }
@@ -350,6 +354,7 @@
                                    SendCommand(commonRGVSecond, command);
                                }
                                LogAndWarn("执行调度任务控制", $"【{commonRGV.DeviceCode}工作模式：【{commonRGV.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】设备状态：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】【{commonRGVSecond.DeviceCode}】任务【{JsonConvert.SerializeObject(taskSecond)}】{commonRGVSecond.DeviceCode}返回任务：【{JsonConvert.SerializeObject(task)}】】");
                                Thread.Sleep(1000);
                                return task;
                            }
                        }
@@ -364,7 +369,7 @@
                        
                        if (commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic) && !commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault))
                        {
                            var taskSecond = _taskRepository.QueryFirst(x => x.RGVName == "RGV01" && x.TaskNum == commonRGVFirst.GetValue<RGVDBName, short>(RGVDBName.RGVTaskNum));
                            var taskSecond = _taskRepository.QueryFirst(x => x.RGVName == "RGV01" && x.TaskNum == commonRGVFirst.GetValue<RGVDBName, short>(RGVDBName.RGVTaskNum)&&((x.TaskType==(int)TaskInboundTypeEnum.Inbound&&x.TaskState<230)||(x.TaskType == (int)TaskOutboundTypeEnum.Outbound)));
                            if (taskSecond != null)
                            {

@@ -375,6 +380,7 @@
                                        if (taskSecond.SourceStation - task.TargetStation > 1 && taskSecond.TargetStation - task.TargetStation > 1)
                                        {
                                            LogAndWarn("执行调度任务控制", $"【{commonRGV.DeviceCode}工作模式：【{commonRGV.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】设备状态：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】【{commonRGVFirst.DeviceCode}】任务【{JsonConvert.SerializeObject(taskSecond)}】{commonRGVFirst.DeviceCode}返回任务：【{JsonConvert.SerializeObject(task)}】】");
                                            Thread.Sleep(1000);
                                            return task;
                                        }
                                    }
@@ -386,6 +392,7 @@
                                        if (taskSecond.TargetStation-task.TargetStation >1 )
                                        {
                                            LogAndWarn("执行调度任务控制", $"【{commonRGV.DeviceCode}工作模式：【{commonRGV.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】设备状态：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】【{commonRGVFirst.DeviceCode}】任务【{JsonConvert.SerializeObject(taskSecond)}】{commonRGVFirst.DeviceCode}返回任务：【{JsonConvert.SerializeObject(task)}】】");
                                            Thread.Sleep(1000);
                                            return task;
                                        }
                                    }
@@ -405,6 +412,7 @@
                                    SendCommand(commonRGVFirst, command);
                                }
                                LogAndWarn("执行调度任务控制", $"【{commonRGV.DeviceCode}工作模式：【{commonRGV.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】设备状态：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】【{commonRGVFirst.DeviceCode}】任务【{JsonConvert.SerializeObject(taskSecond)}】{commonRGVFirst.DeviceCode}返回任务：【{JsonConvert.SerializeObject(task)}】】");
                                Thread.Sleep(1000);
                                return task;
                            }
                        }
@@ -441,28 +449,35 @@
                            {
                                if (taskSecond.TaskState == (int)TaskOutStatusEnum.RGV_Outdispatch || taskSecond.TaskState == (int)TaskOutStatusEnum.RGV_OutdispatchFinish || taskSecond.TaskState == (int)TaskInStatusEnum.RGV_Indispatch || taskSecond.TaskState == (int)TaskInStatusEnum.RGV_InAwaitWMS || taskSecond.TaskState == (int)TaskInStatusEnum.RGV_IndispatchFinish)
                                {
                                    //task = tasks.FirstOrDefault(x =>x.SourceStation- taskSecond.TargetStation > 1  && x.TargetStation - taskSecond.SourceStation > 1 && x.SourceStation - taskSecond.SourceStation > 1 && x.TargetStation - taskSecond.TargetStation> 1);

                                    task = tasks.FirstOrDefault(x =>(x.SourceStation- taskSecond.TargetStation > 1 && x.SourceStation - taskSecond.SourceStation > 1&&x.TaskType==(int)TaskInboundTypeEnum.Inbound) ||(x.SourceStation - taskSecond.TargetStation > 1 && x.TargetStation - taskSecond.SourceStation > 1 && x.SourceStation - taskSecond.SourceStation > 1 && x.TargetStation - taskSecond.TargetStation > 1&&x.TaskType== (int)TaskOutboundTypeEnum.Outbound));
                                    if (task == null)
                                    {
                                        task = tasks.FirstOrDefault(x => (x.SourceStation - taskSecond.TargetStation > 1 && x.SourceStation - taskSecond.SourceStation > 1 && x.TaskType == (int)TaskInboundTypeEnum.Inbound) || (x.SourceStation - taskSecond.TargetStation > 1 && x.TargetStation - taskSecond.SourceStation > 1 && x.SourceStation - taskSecond.SourceStation > 1 && x.TargetStation - taskSecond.TargetStation > 1 && x.TaskType == (int)TaskOutboundTypeEnum.Outbound));
                                    }
                                    LogAndWarn("执行调度任务控制", $"【{commonRGVSecond.DeviceCode}工作模式：【{commonRGV.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】设备状态：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】【{commonRGVSecond.DeviceCode}】任务【{JsonConvert.SerializeObject(taskSecond)}】{commonRGVSecond.DeviceCode}返回任务：【{JsonConvert.SerializeObject(task.TaskNum)}】】");


                                    LogAndWarn("执行调度任务控制", $"【{commonRGVSecond.DeviceCode}工作模式：【{commonRGV.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】设备状态：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】【{commonRGVSecond.DeviceCode}】任务【{JsonConvert.SerializeObject(taskSecond)}】{commonRGVSecond.DeviceCode}返回任务：【{JsonConvert.SerializeObject(task)}】】");


                                    Thread.Sleep(1000);
                                    return task;
                                }
                                else if (taskSecond.TaskState == (int)TaskOutStatusEnum.RGV_OutExecuting || taskSecond.TaskState == (int)TaskInStatusEnum.RGV_InExecuting)
                                {
                                    task = tasks.FirstOrDefault(x => x.SourceStation - taskSecond.TargetStation> 1 &&x.TargetStation - taskSecond.TargetStation > 1);

                                    LogAndWarn("执行调度任务控制", $"【{commonRGV.DeviceCode}工作模式：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】设备状态：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】【{commonRGVSecond.DeviceCode}】任务【{JsonConvert.SerializeObject(taskSecond)}】{commonRGVSecond.DeviceCode}返回任务：【{JsonConvert.SerializeObject(task)}】】");

                                    LogAndWarn("执行调度任务控制", $"【{commonRGV.DeviceCode}工作模式：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】设备状态：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】【{commonRGVSecond.DeviceCode}】任务【{JsonConvert.SerializeObject(taskSecond)}】{commonRGVSecond.DeviceCode}返回任务：【{JsonConvert.SerializeObject(task.TaskNum)}】】");
                                    Thread.Sleep(1000);
                                    return task;
                                }
                                return null;
                            }
                            else
                            {
                                var taskNews = tasks.Where(x => (x.TaskType == (int)TaskInboundTypeEnum.Inbound && Convert.ToInt32(x.SourceAddress) < 1015) || (x.TaskType == (int)TaskOutboundTypeEnum.Outbound && (x.Roadway == "SC01" || x.Roadway == "SC02" || x.Roadway == "SC03"))).ToList();
                                if (taskNews.Count== 0)
                                {
                                    return null;
                                }

                                if (commonRGVSecond.GetValue<RGVDBName, int>(RGVDBName.LevelPoint) > 35000)
                                {
                                    RGVTaskCommand command = new RGVTaskCommand()
@@ -475,13 +490,15 @@
                                }
                                if (tasks.FirstOrDefault(x => x.RGVName == "RGV01") != null)
                                {
                                    LogAndWarn("调度任务控制", $"【{commonRGVSecond.DeviceCode}工作模式：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】作业状态：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Running)}】设备状态：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】是否有货：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.InStock)}】返回任务：【{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV01"))}】】");
                                    return tasks.FirstOrDefault(x => x.RGVName == "RGV01");
                                    LogAndWarn("调度任务控制", $"【{commonRGVSecond.DeviceCode}工作模式：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】作业状态：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Running)}】设备状态：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】是否有货：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.InStock)}】返回任务：【{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV01").TaskNum)}】】");
                                    Thread.Sleep(1000);
                                    return taskNews.FirstOrDefault(x => x.RGVName == "RGV01");
                                }
                                else
                                {
                                    LogAndWarn("调度任务控制", $"【{commonRGVSecond.DeviceCode}工作模式：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】作业状态：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Running)}】设备状态：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】是否有货：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.InStock)}】返回任务：【{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName != "RGV02"))}】】");
                                    return tasks.FirstOrDefault(x => x.RGVName != "RGV02");
                                    LogAndWarn("调度任务控制", $"【{commonRGVSecond.DeviceCode}工作模式：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】作业状态：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Running)}】设备状态：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】是否有货：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.InStock)}】返回任务：【{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName != "RGV02").TaskNum)}】】");
                                    Thread.Sleep(1000);
                                    return taskNews.FirstOrDefault(x => x.RGVName != "RGV02");
                                }
                            }
                        }
@@ -489,12 +506,14 @@
                        {
                            if (tasks.FirstOrDefault(x => x.RGVName == "RGV01") != null)
                            {
                                LogAndWarn("调度任务控制", $"【{commonRGVSecond.DeviceCode}工作模式：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】作业状态：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Running)}】设备状态：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】是否有货：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.InStock)}】返回任务：【{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV01"))}】】");
                                LogAndWarn("调度任务控制", $"【{commonRGVSecond.DeviceCode}工作模式：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】作业状态：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Running)}】设备状态：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】是否有货：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.InStock)}】返回任务：【{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV01").TaskNum)}】】");
                                Thread.Sleep(1000);
                                return tasks.FirstOrDefault(x => x.RGVName == "RGV01");
                            }
                            else
                            {
                                LogAndWarn("调度任务控制", $"【{commonRGVSecond.DeviceCode}工作模式：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】作业状态：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Running)}】设备状态：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】是否有货：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.InStock)}】返回任务：【{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName != "RGV02"))}】】");
                                LogAndWarn("调度任务控制", $"【{commonRGVSecond.DeviceCode}工作模式：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】作业状态：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Running)}】设备状态：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】是否有货：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.InStock)}】返回任务：【{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName != "RGV02").TaskNum)}】】");
                                Thread.Sleep(1000);
                                return tasks.FirstOrDefault(x => x.RGVName != "RGV02");
                            }
                        }
@@ -503,12 +522,14 @@
                    {
                        if (tasks.FirstOrDefault(x => x.RGVName == "RGV01") != null)
                        {
                            LogAndWarn("调度任务控制", $"【{commonRGVSecond.DeviceCode}工作模式：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】作业状态：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Running)}】设备状态：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】是否有货：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.InStock)}】返回任务：【{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV01"))}】】");
                            LogAndWarn("调度任务控制", $"【未找到RGV02设备信息】返回任务：【{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV01").TaskNum)}】】");
                            Thread.Sleep(1000);
                            return tasks.FirstOrDefault(x => x.RGVName == "RGV01");
                        }
                        else
                        {
                            LogAndWarn("调度任务控制", $"【{commonRGVSecond.DeviceCode}工作模式：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】作业状态：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Running)}】设备状态：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】是否有货：【{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.InStock)}】返回任务：【{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName != "RGV02"))}】】");
                            LogAndWarn("调度任务控制", $"【未找到RGV02设备信息】返回任务：【{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName != "RGV02").TaskNum)}】】");
                            Thread.Sleep(1000);
                            return tasks.FirstOrDefault(x => x.RGVName != "RGV02");
                        }
                    }
@@ -525,11 +546,11 @@
                            {
                                if (taskFirst.TaskState == (int)TaskOutStatusEnum.RGV_Outdispatch || taskFirst.TaskState == (int)TaskOutStatusEnum.RGV_OutdispatchFinish || taskFirst.TaskState == (int)TaskInStatusEnum.RGV_Indispatch || taskFirst.TaskState == (int)TaskInStatusEnum.RGV_InAwaitWMS || taskFirst.TaskState == (int)TaskInStatusEnum.RGV_IndispatchFinish)
                                {
                                    //task = tasks.FirstOrDefault(x =>taskFirst.TargetStation - x.SourceStation > 1 && taskFirst.SourceStation - x.TargetStation > 1 && taskFirst.SourceStation - x.SourceStation > 1 && taskFirst.TargetStation - x.TargetStation > 1);

                                    task = tasks.FirstOrDefault(x => (x.SourceStation - taskFirst.TargetStation > 1 && x.SourceStation - taskFirst.SourceStation > 1 && x.TaskType == (int)TaskInboundTypeEnum.Inbound) || (x.SourceStation - taskFirst.TargetStation > 1 && x.TargetStation - taskFirst.SourceStation > 1 && x.SourceStation - taskFirst.SourceStation > 1 && x.TargetStation - taskFirst.TargetStation > 1 && x.TaskType == (int)TaskOutboundTypeEnum.Outbound));

                                    LogAndWarn("执行调度任务控制", $"【{commonRGVFirst.DeviceCode}工作模式：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】设备状态：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】【{commonRGVFirst.DeviceCode}】任务【{JsonConvert.SerializeObject(taskFirst)}】{commonRGVFirst.DeviceCode}返回任务：【{JsonConvert.SerializeObject(task)}】】");
                                    LogAndWarn("执行调度任务控制", $"【{commonRGVFirst.DeviceCode}工作模式：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】设备状态：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】【{commonRGVFirst.DeviceCode}】任务【{JsonConvert.SerializeObject(taskFirst)}】{commonRGVFirst.DeviceCode}返回任务：【{JsonConvert.SerializeObject(task.TaskNum)}】】");
                                    Thread.Sleep(1000);

                                    return task;
                                }
@@ -537,14 +558,19 @@
                                {
                                    task = tasks.FirstOrDefault(x => taskFirst.TargetStation - x.SourceStation > 1 && taskFirst.TargetStation - x.TargetStation > 1);

                                    LogAndWarn("执行调度任务控制", $"【{commonRGVFirst.DeviceCode}工作模式：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】设备状态：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】【{commonRGVFirst.DeviceCode}】任务【{JsonConvert.SerializeObject(taskFirst)}】{commonRGVFirst.DeviceCode}返回任务：【{JsonConvert.SerializeObject(task)}】】");

                                    LogAndWarn("执行调度任务控制", $"【{commonRGVFirst.DeviceCode}工作模式：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】设备状态：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】【{commonRGVFirst.DeviceCode}】任务【{JsonConvert.SerializeObject(taskFirst)}】{commonRGVFirst.DeviceCode}返回任务：【{JsonConvert.SerializeObject(task.TaskNum)}】】");
                                    Thread.Sleep(1000);
                                    return task;
                                }
                                return null;
                            }
                            else
                            {
                                var taskNews = tasks.Where(x => (x.TaskType == (int)TaskInboundTypeEnum.Inbound && Convert.ToInt32(x.SourceAddress) > 1015) || (x.TaskType == (int)TaskOutboundTypeEnum.Outbound && (x.Roadway == "SC04" || x.Roadway == "SC05" || x.Roadway == "SC06"))).ToList();
                                if (taskNews.Count == 0)
                                {
                                    return null;
                                }
                                if (commonRGVFirst.GetValue<RGVDBName, int>(RGVDBName.LevelPoint) < 420000)
                                {
                                    RGVTaskCommand command = new RGVTaskCommand()
@@ -557,14 +583,16 @@
                                }
                                if (tasks.FirstOrDefault(x => x.RGVName == "RGV02") != null)
                                {
                                    LogAndWarn("调度任务控制", $"【{commonRGVFirst.DeviceCode}工作模式：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】作业状态：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Running)}】设备状态：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】是否有货：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.InStock)}】返回任务：【{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV02"))}】】");
                                    LogAndWarn("调度任务控制", $"【{commonRGVFirst.DeviceCode}工作模式：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】作业状态：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Running)}】设备状态：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】是否有货：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.InStock)}】返回任务：【{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV02").TaskNum)}】】");

                                    Thread.Sleep(1000);
                                    return tasks.FirstOrDefault(x => x.RGVName == "RGV02");
                                }
                                else
                                {
                                    LogAndWarn("调度任务控制", $"【{commonRGVFirst.DeviceCode}工作模式：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】作业状态：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Running)}】设备状态：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】是否有货：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.InStock)}】返回任务：【{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName != "RGV01"))}】】");
                                    LogAndWarn("调度任务控制", $"【{commonRGVFirst.DeviceCode}工作模式：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】作业状态：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Running)}】设备状态：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】是否有货：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.InStock)}】返回任务：【{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName != "RGV01").TaskNum)}】】");

                                    Thread.Sleep(1000);
                                    return tasks.FirstOrDefault(x => x.RGVName != "RGV01");
                                }
                            }
@@ -573,14 +601,15 @@
                        {
                            if (tasks.FirstOrDefault(x => x.RGVName == "RGV02") != null)
                            {
                                LogAndWarn("调度任务控制", $"【{commonRGVFirst.DeviceCode}工作模式：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】作业状态：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Running)}】设备状态：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】是否有货：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.InStock)}】返回任务：【{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV02"))}】】");

                                LogAndWarn("调度任务控制", $"【{commonRGVFirst.DeviceCode}工作模式：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】作业状态：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Running)}】设备状态：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】是否有货：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.InStock)}】返回任务：【{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV02").TaskNum)}】】");
                                Thread.Sleep(1000);
                                return tasks.FirstOrDefault(x => x.RGVName == "RGV02");
                            }
                            else
                            {
                                LogAndWarn("调度任务控制", $"【{commonRGVFirst.DeviceCode}工作模式：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】作业状态：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Running)}】设备状态：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】是否有货：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.InStock)}】返回任务：【{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName != "RGV01"))}】】");
                                LogAndWarn("调度任务控制", $"【{commonRGVFirst.DeviceCode}工作模式：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】作业状态：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Running)}】设备状态：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】是否有货：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.InStock)}】返回任务：【{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName != "RGV01").TaskNum)}】】");

                                Thread.Sleep(1000);
                                return tasks.FirstOrDefault(x => x.RGVName != "RGV01");
                            }
                        }
@@ -589,14 +618,16 @@
                    {
                        if (tasks.FirstOrDefault(x => x.RGVName == "RGV02") != null)
                        {
                            LogAndWarn("调度任务控制", $"【{commonRGVFirst.DeviceCode}工作模式：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】作业状态：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Running)}】设备状态：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】是否有货：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.InStock)}】返回任务：【{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV02"))}】】");
                            LogAndWarn("调度任务控制", $"【未找到RGV01设备信息】 è¿”回任务：【{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV02").TaskNum)}】】");

                            Thread.Sleep(1000);
                            return tasks.FirstOrDefault(x => x.RGVName == "RGV02");
                        }
                        else
                        {
                            LogAndWarn("调度任务控制", $"【{commonRGVFirst.DeviceCode}工作模式：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}】作业状态：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Running)}】设备状态：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}】是否有货：【{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.InStock)}】返回任务：【{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName != "RGV01"))}】】");
                            LogAndWarn("调度任务控制", $"【未找到RGV01设备信息】返回任务：【{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName != "RGV01").TaskNum)}】】");

                            Thread.Sleep(1000);
                            return tasks.FirstOrDefault(x => x.RGVName != "RGV01");
                        }
                    }
@@ -618,24 +649,10 @@
        {
            if (commonRGV != null)
            {
                WriteInfo("RGV任务完成", $"{commonRGV.DeviceName}完成任务号{TaskNum}");
                var task = _taskRepository.QueryFirst(x => x.TaskNum == TaskNum);
                if (task != null)
                {
                    if (task.TaskState == (int)TaskInStatusEnum.InRetuen)
                    {
                        Dt_StationManager stationManager = _stationManagerRepository.QueryFirst(x => x.stationChildCode == task.SourceAddress);
                        if (stationManager != null)
                        {
                            IDevice? device = Storage.Devices.FirstOrDefault(x => x.DeviceCode == stationManager.stationPLC);
                            if (device != null)
                            {
                                CommonConveyorLine conveyorLine = (CommonConveyorLine)device;
                                commonRGV.SetValue(StackerCraneDBName.TaskType, Convert.ToSByte(4));

                                var content = _taskService.RGVTaskCompleted(TaskNum);
                            }
                        }
                    }
                    if (task.TaskState == (int)TaskInStatusEnum.RGV_Indispatch)
                    {
                        Dt_StationManager stationManager = _stationManagerRepository.QueryFirst(x => x.stationChildCode == task.SourceAddress);
@@ -648,17 +665,24 @@
                                Thread.Sleep(100);
                                DeviceProDTO? devicePro = conveyorLine.DeviceProDTOs.Where(x => x.DeviceChildCode == stationManager.stationChildCode && x.DeviceProParamName == "ConveyorLineBarcode").FirstOrDefault();

                                var x = conveyorLine.Communicator.Read(devicePro.DeviceProAddress, 7);
                                var x = conveyorLine.Communicator.Read(devicePro.DeviceProAddress, 10);

                                string Barcode = Encoding.UTF8.GetString(x);

                                if (Barcode == null || Barcode == "")
                                if (Barcode == null || Barcode == ""|| Barcode.Trim().Contains("\0"))
                                {
                                    conveyorLine.SetValue(ConveyorLineDBName.WriteInteractiveSignal, Convert.ToSByte(3), stationManager.stationChildCode);
                                    commonRGV.SetValue(StackerCraneDBName.PutcargoLocation, Convert.ToSByte(stationManager.stationRemark));
                                    commonRGV.SetValue(StackerCraneDBName.TaskNum, Convert.ToInt16(task.TaskNum));
                                    task.TaskState = (int)TaskInStatusEnum.InRetuen;
                                    _taskRepository.UpdateData(task);
                                    commonRGV.SetValue(StackerCraneDBName.TaskType, Convert.ToSByte(4));

                                    task.ModifyDate = DateTime.Now;
                                    task.Modifier = "System";

                                    Dt_Task_Hty task_Hty = _mapper.Map<Dt_Task_Hty>(task);
                                    task_Hty.TaskId = 0;

                                    _taskRepository.DeleteData(task);
                                    _task_HtyRepository.AddData(task_Hty);
                                    return;
                                }
                                var content = _taskService.RGVTaskCompleted(TaskNum, Barcode);
@@ -719,8 +743,6 @@
            rgvTaskCommand.TaskNum = Convert.ToInt16(task.TaskNum);
            if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.InboundGroup)//判断是否是入库任务
            {
                //rgvTaskCommand.TaskType = (byte)Convert.ToSByte(16);
                //rgvTaskCommand.TaskType = (byte)Convert.ToSByte(64);   é€€å›ž
                if (task.TaskState == (int)TaskInStatusEnum.InNew)
                {
                    Dt_StationManager stationManager = _stationManagerRepository.QueryFirst(x => x.stationChildCode == task.SourceAddress);