忽略文件

huangxiaoqiang

8 天以前 2d5cf3b7ed3be90f1d25d3adda26013cc9575be9

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

@@ -104,44 +104,47 @@
                    }
                    if (FirstRgv.GetValue<RGVDBName, bool>(RGVDBName.Automatic) && !FirstRgv.GetValue<RGVDBName, bool>(RGVDBName.Fault) && !FirstRgv.GetValue<RGVDBName, bool>(RGVDBName.Running))
                    {
                        Dt_Task? task = GetTask(FirstRgv, FirstRgv.GetValue<RGVDBName, bool>(RGVDBName.InStock));
                        if (task != null)
                        if (FirstRgv.GetValue<RGVDBName, bool>(RGVDBName.InStock))
                        {
                            var IsExecutingTask = DispatchExecutingTask(FirstRgv, task);
                            if (IsExecutingTask != null)
                            Dt_Task? task = GetTask(FirstRgv, FirstRgv.GetValue<RGVDBName, bool>(RGVDBName.InStock));
                            if (task != null)
                            {
                                RGVTaskCommand? rgvTaskCommand = ConvertToRGVTaskCommand(IsExecutingTask);
                                if (rgvTaskCommand != null)
                                var IsExecutingTask = DispatchExecutingTask(FirstRgv, task);
                                if (IsExecutingTask != null)
                                {
                                    Thread.Sleep(1000);
                                    bool sendFlag = SendCommand(FirstRgv, rgvTaskCommand);
                                    if (sendFlag)
                                    RGVTaskCommand? rgvTaskCommand = ConvertToRGVTaskCommand(IsExecutingTask);
                                    if (rgvTaskCommand != null)
                                    {
                                        if (IsExecutingTask.Remark != null)
                                        Thread.Sleep(1000);
                                        bool sendFlag = SendCommand(FirstRgv, rgvTaskCommand);
                                        if (sendFlag)
                                        {
                                            IsExecutingTask.RGVName = "RGV02";
                                            IsExecutingTask.CurrentAddress = IsExecutingTask.Remark;
                                            IsExecutingTask.Remark = "";
                                            Dt_StationManager station = _stationManagerRepository.QueryFirst(x => x.stationChildCode == IsExecutingTask.NextAddress);
                                            IsExecutingTask.SourceStation = IsExecutingTask.CurrentAddress=="1025"?10:7;
                                            if (IsExecutingTask.TaskType == (int)TaskInboundTypeEnum.Inbound)
                                            if (IsExecutingTask.Remark != null)
                                            {
                                                IsExecutingTask.TargetStation = station.stationRemark;
                                                IsExecutingTask.RGVName = "RGV02";
                                                IsExecutingTask.CurrentAddress = IsExecutingTask.Remark;
                                                IsExecutingTask.Remark = "";
                                                Dt_StationManager station = _stationManagerRepository.QueryFirst(x => x.stationChildCode == IsExecutingTask.NextAddress);
                                                IsExecutingTask.SourceStation = IsExecutingTask.CurrentAddress == "1025" ? 10 : 7;
                                                if (IsExecutingTask.TaskType == (int)TaskInboundTypeEnum.Inbound)
                                                {
                                                    IsExecutingTask.TargetStation = station.stationRemark;
                                                }
                                                else
                                                {
                                                    IsExecutingTask.TargetStation = station.remark;
                                                }
                                                IsExecutingTask.TaskState = (int)TaskInStatusEnum.RGV_TransFer;
                                                _taskRepository.UpdateData(IsExecutingTask);
                                                Thread.Sleep(1000);
                                            }
                                            else
                                            {
                                                IsExecutingTask.TargetStation = station.remark;
                                                IsExecutingTask.RGVName = FirstRgv.DeviceCode;
                                                _taskRepository.UpdateData(IsExecutingTask);
                                                _taskService.UpdateTaskStatusToNext(IsExecutingTask.TaskNum);
                                                Thread.Sleep(1000);
                                            }
                                                IsExecutingTask.TaskState = (int)TaskInStatusEnum.RGV_TransFer;
                                            _taskRepository.UpdateData(IsExecutingTask);
                                            Thread.Sleep(1000);
                                        }
                                        else
                                        {
                                            IsExecutingTask.RGVName = FirstRgv.DeviceCode;
                                            _taskRepository.UpdateData(IsExecutingTask);
                                            _taskService.UpdateTaskStatusToNext(IsExecutingTask.TaskNum);
                                            Thread.Sleep(1000);
                                        }
                                    }
                                }
@@ -265,34 +268,48 @@
                    }
                    if (SecondRgv.GetValue<RGVDBName, bool>(RGVDBName.Automatic) && !SecondRgv.GetValue<RGVDBName, bool>(RGVDBName.Fault) && !SecondRgv.GetValue<RGVDBName, bool>(RGVDBName.Running))
                    {
                        Dt_Task? task = GetTask(SecondRgv, SecondRgv.GetValue<RGVDBName, bool>(RGVDBName.InStock));
                        if (task != null)
                        if (SecondRgv.GetValue<RGVDBName, bool>(RGVDBName.InStock))
                        {
                            var IsExecutingTask = DispatchExecutingTask(SecondRgv, task);
                            if (IsExecutingTask != null)
                            Dt_Task? task = GetTask(SecondRgv, SecondRgv.GetValue<RGVDBName, bool>(RGVDBName.InStock));
                            if (task != null)
                            {
                                RGVTaskCommand? rgvTaskCommand = ConvertToRGVTaskCommand(IsExecutingTask);
                                if (rgvTaskCommand != null)
                                var IsExecutingTask = DispatchExecutingTask(SecondRgv, task);
                                if (IsExecutingTask != null)
                                {
                                    Thread.Sleep(1000);
                                    bool sendFlag = SendCommand(SecondRgv, rgvTaskCommand);
                                    if (sendFlag)
                                    RGVTaskCommand? rgvTaskCommand = ConvertToRGVTaskCommand(IsExecutingTask);
                                    if (rgvTaskCommand != null)
                                    {
                                        if (IsExecutingTask.Remark != null)
                                        Thread.Sleep(1000);
                                        bool sendFlag = SendCommand(SecondRgv, rgvTaskCommand);
                                        if (sendFlag)
                                        {
                                            IsExecutingTask.RGVName = "RGV01";
                                            IsExecutingTask.CurrentAddress = IsExecutingTask.Remark;
                                            IsExecutingTask.Remark = "";
                                            IsExecutingTask.TaskState = (int)TaskInStatusEnum.RGV_TransFer;
                                            _taskRepository.UpdateData(IsExecutingTask);
                                            Thread.Sleep(1000);
                                        }
                                        else
                                        {
                                            IsExecutingTask.RGVName = SecondRgv.DeviceCode;
                                            _taskRepository.UpdateData(IsExecutingTask);
                                            _taskService.UpdateTaskStatusToNext(IsExecutingTask.TaskNum);
                                            Thread.Sleep(1000);
                                            if (IsExecutingTask.Remark != null)
                                            {
                                                IsExecutingTask.RGVName = "RGV01";
                                                IsExecutingTask.CurrentAddress = IsExecutingTask.Remark;
                                                IsExecutingTask.Remark = "";
                                                IsExecutingTask.TaskState = (int)TaskInStatusEnum.RGV_TransFer;
                                                Dt_StationManager station = _stationManagerRepository.QueryFirst(x => x.stationChildCode == IsExecutingTask.NextAddress);
                                                IsExecutingTask.SourceStation = IsExecutingTask.CurrentAddress == "1025" ? 10 : 7;
                                                if (IsExecutingTask.TaskType == (int)TaskInboundTypeEnum.Inbound)
                                                {
                                                    IsExecutingTask.TargetStation = station.stationRemark;
                                                }
                                                else
                                                {
                                                    IsExecutingTask.TargetStation = station.remark;
                                                }

                                                _taskRepository.UpdateData(IsExecutingTask);
                                                Thread.Sleep(1000);
                                            }
                                            else
                                            {
                                                IsExecutingTask.RGVName = SecondRgv.DeviceCode;
                                                _taskRepository.UpdateData(IsExecutingTask);
                                                _taskService.UpdateTaskStatusToNext(IsExecutingTask.TaskNum);
                                                Thread.Sleep(1000);
                                            }
                                        }
                                    }
                                }
@@ -416,6 +433,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) && ((x.TaskType == (int)TaskInboundTypeEnum.Inbound && x.TaskState < 230) || (x.TaskType == (int)TaskOutboundTypeEnum.Outbound)));
                            if (taskSecond != null)
                            {
@@ -423,14 +441,15 @@
                                {
                                    if (task.TaskState == (int)TaskOutStatusEnum.RGV_OutdispatchFinish || task.TaskState == (int)TaskInStatusEnum.RGV_IndispatchFinish)
                                    {
                                        if (task.TargetStation- taskSecond.SourceStation > 1 && task.TargetStation - taskSecond.TargetStation > 1)
                                        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.TaskNum)}】】");

                                            Thread.Sleep(1000);

                                            if (task.Remark != null)
                                            {
                                                return GetDispatchExecutingTask(taskSecond);
                                                return GetDispatchExecutingTask(task);
                                            }

                                            return task;
@@ -447,7 +466,7 @@
                                            Thread.Sleep(1000);
                                            if (task.Remark != null)
                                            {
                                                return GetDispatchExecutingTask(taskSecond);
                                                return GetDispatchExecutingTask(task);
                                            }
                                            return task;
                                        }
@@ -457,17 +476,25 @@
                            }
                            else
                            {
                                if (commonRGVSecond.GetValue<StackerCraneDBName, bool>(StackerCraneDBName.WorkCompleted))
                                {
                                    RGVTaskFinish(commonRGVSecond, commonRGVSecond.GetValue<RGVDBName, short>(RGVDBName.RGVTaskNum));
                                }
                                if (commonRGVSecond.GetValue<RGVDBName, int>(RGVDBName.LevelPoint) > 35000)
                                {
                                    RGVTaskCommand command = new RGVTaskCommand()
                                    {
                                        PickupLocation = (byte)Convert.ToSByte(15),
                                        TaskNum = Convert.ToInt16(1000),
                                        TaskNum = Convert.ToInt16(1),
                                        TaskType = (byte)Convert.ToSByte(1)
                                    };
                                    SendCommand(commonRGVSecond, command);
                                    Thread.Sleep(1000);
                                    if (!commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Running))
                                    {
                                        return null;
                                    }
                                }
                                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.TaskNum)}】】");
                                Thread.Sleep(1000);
                                return task;
                            }
@@ -480,13 +507,11 @@
                    CommonRGV_FirstFloor? commonRGVFirst = Storage.Devices.FirstOrDefault(x => x.DeviceCode == "RGV01") as CommonRGV_FirstFloor;
                    if (commonRGVFirst != null)
                    {
                        
                        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)&&((x.TaskType==(int)TaskInboundTypeEnum.Inbound&&x.TaskState<230)||(x.TaskType == (int)TaskOutboundTypeEnum.Outbound)));
                            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)
                            {

                                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)
                                {
                                    if (task.TaskState == (int)TaskOutStatusEnum.RGV_OutdispatchFinish || task.TaskState == (int)TaskInStatusEnum.RGV_IndispatchFinish)
@@ -498,7 +523,7 @@

                                            if (task.Remark != null)
                                            {
                                                return GetDispatchExecutingTask(taskSecond);
                                                return GetDispatchExecutingTask(task);
                                            }
                                            return task;
                                        }
@@ -515,7 +540,7 @@

                                            if (task.Remark != null)
                                            {
                                                return GetDispatchExecutingTask(taskSecond);
                                                return GetDispatchExecutingTask(task);
                                            }
                                            return task;
                                        }
@@ -525,17 +550,25 @@
                            }
                            else
                            {
                                if (commonRGVFirst.GetValue<StackerCraneDBName, bool>(StackerCraneDBName.WorkCompleted))
                                {
                                    RGVTaskFinish(commonRGVFirst, commonRGVFirst.GetValue<RGVDBName, short>(RGVDBName.RGVTaskNum));
                                }
                                if (commonRGVFirst.GetValue<RGVDBName, int>(RGVDBName.LevelPoint) < 420000)
                                {
                                    RGVTaskCommand command = new RGVTaskCommand()
                                    {
                                        PickupLocation = (byte)Convert.ToSByte(26),
                                        TaskNum = Convert.ToInt16(1000),
                                        TaskNum = Convert.ToInt16(1),
                                        TaskType = (byte)Convert.ToSByte(1)
                                    };
                                    SendCommand(commonRGVFirst, command);
                                    Thread.Sleep(1000);
                                    if (!commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Running))
                                    {
                                        return null;
                                    }
                                }
                                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.TaskNum)}】】");
                                Thread.Sleep(1000);
                                return task;
                            }
@@ -568,90 +601,53 @@
                    {
                        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)
                            {
                                #region
                                //if (taskSecond.TaskState == (int)TaskOutStatusEnum.RGV_Outdispatch || taskSecond.TaskState == (int)TaskOutStatusEnum.RGV_OutdispatchFinish || taskSecond.TaskState == (int)TaskInStatusEnum.RGV_IndispatchFinish)
                                //{

                                //    //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));
                                //    //}

                                //    task = GetDispatchTask(tasks, taskSecond);

                                //    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)}】】");

                                //    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.TaskNum)}】】");
                                //    Thread.Sleep(1000);
                                //    return task;
                                //}
                                //return null;
                                #endregion

                                task = GetDispatchTask(tasks, taskSecond);

                                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)}】】");
                                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;
                            }
                            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")) || x.RGVName == "RGV01").ToList();
                        if (taskNews.Count == 0)
                        {
                            return null;
                        }
                        if (commonRGVSecond.GetValue<StackerCraneDBName, bool>(StackerCraneDBName.WorkCompleted))
                        {
                            RGVTaskFinish(commonRGVSecond, commonRGVSecond.GetValue<RGVDBName, short>(RGVDBName.RGVTaskNum));
                        }
                        if (commonRGVSecond.GetValue<RGVDBName, int>(RGVDBName.LevelPoint) > 35000)
                        {
                            RGVTaskCommand command = new RGVTaskCommand()
                            {
                                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"))||x.RGVName=="RGV01").ToList();
                                if (taskNews.Count== 0)
                                {
                                    return null;
                                }

                                if (commonRGVSecond.GetValue<RGVDBName, int>(RGVDBName.LevelPoint) > 35000)
                                {
                                    RGVTaskCommand command = new RGVTaskCommand()
                                    {
                                        PickupLocation = (byte)Convert.ToSByte(15),
                                        TaskNum = Convert.ToInt16(1000),
                                        TaskType = (byte)Convert.ToSByte(1)
                                    };
                                    SendCommand(commonRGVSecond, command);
                                }
                                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").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").TaskNum)}】】");
                                    Thread.Sleep(1000);
                                    return taskNews.FirstOrDefault(x => x.RGVName != "RGV02");
                                }
                                PickupLocation = (byte)Convert.ToSByte(15),
                                TaskNum = Convert.ToInt16(1),
                                TaskType = (byte)Convert.ToSByte(1)
                            };
                            SendCommand(commonRGVSecond, command);
                            Thread.Sleep(1000);
                            if (!commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Running))
                            {
                                return null;
                            }
                        }

                        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(taskNews.FirstOrDefault(x => x.RGVName == "RGV01").TaskNum)}】】");
                            Thread.Sleep(1000);
                            return taskNews.FirstOrDefault(x => x.RGVName == "RGV01");
                        }
                        else
                        {
                            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").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").TaskNum)}】】");
                                Thread.Sleep(1000);
                                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(taskNews.FirstOrDefault(x => x.RGVName != "RGV02").TaskNum)}】】");
                            Thread.Sleep(1000);
                            return taskNews.FirstOrDefault(x => x.RGVName != "RGV02");
                        }
                    }
                    else
@@ -677,33 +673,10 @@
                    {
                        if (commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic) && !commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault))
                        {
                            var taskFirst = _taskRepository.QueryFirst(x => x.RGVName == "RGV01" && x.TaskNum == commonRGVFirst.GetValue<RGVDBName, short>(RGVDBName.RGVTaskNum));

                            var taskFirst = _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 (taskFirst != null)
                            {
                                #region
                                //if (taskFirst.TaskState == (int)TaskOutStatusEnum.RGV_Outdispatch || taskFirst.TaskState == (int)TaskOutStatusEnum.RGV_OutdispatchFinish  || taskFirst.TaskState == (int)TaskInStatusEnum.RGV_IndispatchFinish)
                                //{

                                //    //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));

                                //    task = GetDispatchTask(tasks, taskFirst);

                                //    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;
                                //}
                                //else if (taskFirst.TaskState == (int)TaskOutStatusEnum.RGV_OutExecuting || taskFirst.TaskState == (int)TaskInStatusEnum.RGV_InExecuting)
                                //{
                                //    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.TaskNum)}】】");
                                //    Thread.Sleep(1000);
                                //    return task;
                                //}
                                //return null;
                                #endregion

                                task = GetDispatchTask(tasks, taskFirst);

                                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)}】】");
@@ -711,54 +684,45 @@

                                return task;
                            }
                            else

                        }
                        var taskNews = tasks.Where(x => (x.TaskType == (int)TaskInboundTypeEnum.Inbound && Convert.ToInt32(x.SourceAddress) > 1014) || (x.TaskType == (int)TaskOutboundTypeEnum.Outbound && (x.Roadway == "SC04" || x.Roadway == "SC05" || x.Roadway == "SC06")) || x.RGVName == "RGV02").ToList();
                        if (taskNews.Count == 0)
                        {
                            return null;
                        }
                        if (commonRGVFirst.GetValue<StackerCraneDBName, bool>(StackerCraneDBName.WorkCompleted))
                        {
                            RGVTaskFinish(commonRGVFirst, commonRGVFirst.GetValue<RGVDBName, short>(RGVDBName.RGVTaskNum));
                        }
                        if (commonRGVFirst.GetValue<RGVDBName, int>(RGVDBName.LevelPoint) < 420000)
                        {
                            RGVTaskCommand command = new RGVTaskCommand()
                            {
                                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"))||x.RGVName=="RGV02").ToList();
                                if (taskNews.Count == 0)
                                {
                                    return null;
                                }
                                if (commonRGVFirst.GetValue<RGVDBName, int>(RGVDBName.LevelPoint) < 420000)
                                {
                                    RGVTaskCommand command = new RGVTaskCommand()
                                    {
                                        PickupLocation = (byte)Convert.ToSByte(26),
                                        TaskNum = Convert.ToInt16(1000),
                                        TaskType = (byte)Convert.ToSByte(1)
                                    };
                                    SendCommand(commonRGVFirst, command);
                                }
                                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").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").TaskNum)}】】");

                                    Thread.Sleep(1000);
                                    return tasks.FirstOrDefault(x => x.RGVName != "RGV01");
                                }
                                PickupLocation = (byte)Convert.ToSByte(26),
                                TaskNum = Convert.ToInt16(1),
                                TaskType = (byte)Convert.ToSByte(1)
                            };
                            SendCommand(commonRGVFirst, command);
                            Thread.Sleep(1000);
                            if (!commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Running))
                            {
                                return null;
                            }
                        }

                        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(taskNews.FirstOrDefault(x => x.RGVName == "RGV02").TaskNum)}】】");
                            Thread.Sleep(1000);
                            return taskNews.FirstOrDefault(x => x.RGVName == "RGV02");
                        }
                        else
                        {
                            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").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").TaskNum)}】】");
                            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(taskNews.FirstOrDefault(x => x.RGVName != "RGV01").TaskNum)}】】");

                                Thread.Sleep(1000);
                                return tasks.FirstOrDefault(x => x.RGVName != "RGV01");
                            }
                            Thread.Sleep(1000);
                            return taskNews.FirstOrDefault(x => x.RGVName != "RGV01");
                        }
                    }
                    else
@@ -791,7 +755,7 @@
        {
            try
            {
                var tasks = _taskRepository.QueryData(x=>x.TaskState==(int)TaskInStatusEnum.RGV_TransFerFInish|| x.TaskState == (int)TaskOutStatusEnum.RGV_TransFerFInish);
                var tasks = _taskRepository.QueryData(x => x.Floor == "1F" && (x.TaskState == (int)TaskInStatusEnum.RGV_TransFerFInish || x.TaskState == (int)TaskOutStatusEnum.RGV_TransFerFInish));
                Dt_Task task;
                if (tasks.Count() == 0)
                {
@@ -804,15 +768,16 @@
                    {
                        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_IndispatchFinish)
                                {
                                    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))&&x.RGVName=="RGV01");
                                    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)) && x.RGVName == "RGV01");


                                    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.TaskNum)}】】");

                                    Thread.Sleep(1000);
                                    return task;
@@ -821,7 +786,7 @@
                                {
                                    task = tasks.FirstOrDefault(x => x.SourceStation - taskSecond.TargetStation > 1 && x.TargetStation - taskSecond.TargetStation > 1 && x.RGVName == "RGV01");

                                    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)}】】");
                                    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;
                                }
@@ -829,19 +794,29 @@
                            }
                            else
                            {
                                if (commonRGVSecond.GetValue<StackerCraneDBName, bool>(StackerCraneDBName.WorkCompleted))
                                {
                                    RGVTaskFinish(commonRGVSecond, commonRGVSecond.GetValue<RGVDBName, short>(RGVDBName.RGVTaskNum));
                                }
                                if (commonRGVSecond.GetValue<RGVDBName, int>(RGVDBName.LevelPoint) > 35000)
                                {
                                    RGVTaskCommand command = new RGVTaskCommand()
                                    {
                                        PickupLocation = (byte)Convert.ToSByte(15),
                                        TaskNum = Convert.ToInt16(1000),
                                        TaskNum = Convert.ToInt16(1),
                                        TaskType = (byte)Convert.ToSByte(1)
                                    };
                                    SendCommand(commonRGVSecond, command);
                                    Thread.Sleep(1000);
                                    if (!commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Running))
                                    {
                                        return null;
                                    }
                                }

                                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").TaskNum)}】】");
                                    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");
                                }
@@ -851,18 +826,17 @@
                        {
                            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").TaskNum)}】】");
                                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
                    {
                        if (tasks.FirstOrDefault(x => x.RGVName == "RGV01") != null)
                        {
                            LogAndWarn("调度任务控制", $"【未找到RGV02设备信息】返回任务：【{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV01").TaskNum)}】】");
                            LogAndWarn("中转调度任务控制", $"【未找到RGV02设备信息】返回任务：【{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV01").TaskNum)}】】");
                            Thread.Sleep(1000);
                            return tasks.FirstOrDefault(x => x.RGVName == "RGV01");
                        }
@@ -876,17 +850,17 @@
                    {
                        if (commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic) && !commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault))
                        {
                            var taskFirst = _taskRepository.QueryFirst(x => x.RGVName == "RGV01" && x.TaskNum == commonRGVFirst.GetValue<RGVDBName, short>(RGVDBName.RGVTaskNum));

                            var taskFirst = _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 (taskFirst != null)
                            {
                                if (taskFirst.TaskState == (int)TaskOutStatusEnum.RGV_Outdispatch || taskFirst.TaskState == (int)TaskOutStatusEnum.RGV_OutdispatchFinish || taskFirst.TaskState == (int)TaskInStatusEnum.RGV_IndispatchFinish)
                                {

                                    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))&&x.RGVName=="RGV02");
                                    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)) && x.RGVName == "RGV02");

                                    task = GetDispatchTask(tasks, taskFirst);

                                    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)}】】");
                                    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;
@@ -895,7 +869,7 @@
                                {
                                    task = tasks.FirstOrDefault(x => taskFirst.TargetStation - x.SourceStation > 1 && taskFirst.TargetStation - x.TargetStation > 1 && x.RGVName == "RGV02");

                                    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)}】】");
                                    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;
                                }
@@ -903,19 +877,29 @@
                            }
                            else
                            {
                                if (commonRGVFirst.GetValue<StackerCraneDBName, bool>(StackerCraneDBName.WorkCompleted))
                                {
                                    RGVTaskFinish(commonRGVFirst, commonRGVFirst.GetValue<RGVDBName, short>(RGVDBName.RGVTaskNum));
                                }
                                if (commonRGVFirst.GetValue<RGVDBName, int>(RGVDBName.LevelPoint) < 420000)
                                {
                                    RGVTaskCommand command = new RGVTaskCommand()
                                    {
                                        PickupLocation = (byte)Convert.ToSByte(26),
                                        TaskNum = Convert.ToInt16(1000),
                                        TaskNum = Convert.ToInt16(1),
                                        TaskType = (byte)Convert.ToSByte(1)
                                    };
                                    SendCommand(commonRGVFirst, command);
                                    Thread.Sleep(1000);
                                    if (!commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Running))
                                    {
                                        return null;
                                    }
                                }

                                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").TaskNum)}】】");
                                    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");
@@ -926,7 +910,7 @@
                        {
                            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").TaskNum)}】】");
                                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");
                            }
@@ -936,7 +920,7 @@
                    {
                        if (tasks.FirstOrDefault(x => x.RGVName == "RGV02") != null)
                        {
                            LogAndWarn("调度任务控制", $"【未找到RGV01设备信息】 è¿”回任务：【{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV02").TaskNum)}】】");
                            LogAndWarn("中转调度任务控制", $"【未找到RGV01设备信息】 è¿”回任务：【{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV02").TaskNum)}】】");

                            Thread.Sleep(1000);
                            return tasks.FirstOrDefault(x => x.RGVName == "RGV02");
@@ -981,8 +965,12 @@

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

                                if (Barcode == null || Barcode == "" || Barcode.Trim().Contains("\0"))
                                short y = conveyorLine.GetValue<ConveyorLineDBName, short>(ConveyorLineDBName.InteractiveSignal, stationManager.stationChildCode);
                                var structs = BitConverter.GetBytes(y).ToArray().ToBoolArray();

                                if (Barcode == null || Barcode == "" || Barcode.Trim().Contains("\0")|| structs[5])
                                {
                                    WriteInfo("入库异常信息", $"托盘号【{Barcode}】检尺【{structs[5]}】任务号【{TaskNum}】");
                                    commonRGV.SetValue(StackerCraneDBName.PutcargoLocation, Convert.ToSByte(stationManager.stationRemark));
                                    commonRGV.SetValue(StackerCraneDBName.TaskNum, Convert.ToInt16(task.TaskNum));
                                    commonRGV.SetValue(StackerCraneDBName.TaskType, Convert.ToSByte(4));
@@ -1016,7 +1004,7 @@
                                    Thread.Sleep(100);
                                    conveyorLine.SetValue(ConveyorLineDBName.ConveyorLineTargetAddress, Convert.ToInt16(stationManager.stationNextChildCode), stationManager.stationChildCode);
                                    Thread.Sleep(100);
                                    conveyorLine.SetValue(ConveyorLineDBName.ConveyorLineTaskNum, Convert.ToInt16(1000), stationManager.stationChildCode);
                                    conveyorLine.SetValue(ConveyorLineDBName.ConveyorLineTaskNum, Convert.ToInt16(1), stationManager.stationChildCode);
                                    Thread.Sleep(100);
                                    conveyorLine.SetValue(ConveyorLineDBName.WriteInteractiveSignal, Convert.ToSByte(2), stationManager.stationChildCode);
                                }
@@ -1044,7 +1032,7 @@

        public Dt_Task? GetDispatchTask(List<Dt_Task> tasks, Dt_Task oldtask)
        {
            Dt_Task y = tasks.Where(x => x.Remark != null && ((x.SourceStation - oldtask.TargetStation > 1 && x.SourceStation - oldtask.SourceStation > 1 && x.TaskType == (int)TaskInboundTypeEnum.Inbound) || (x.SourceStation - oldtask.TargetStation > 1 && x.TargetStation - oldtask.SourceStation > 1 && x.SourceStation - oldtask.SourceStation > 1 && x.TargetStation - oldtask.TargetStation > 1 && x.TaskType == (int)TaskOutboundTypeEnum.Outbound))).First();
            Dt_Task y = tasks.Where(x => x.Remark != null && ((x.SourceStation - oldtask.TargetStation > 1 && x.SourceStation - oldtask.SourceStation > 1 && x.TaskType == (int)TaskInboundTypeEnum.Inbound) || (x.SourceStation - oldtask.TargetStation > 1 && x.TargetStation - oldtask.SourceStation > 1 && x.SourceStation - oldtask.SourceStation > 1 && x.TargetStation - oldtask.TargetStation > 1 && x.TaskType == (int)TaskOutboundTypeEnum.Outbound))).FirstOrDefault();
            if (y == null)
            {
                if (oldtask.TaskState == (int)TaskOutStatusEnum.RGV_Outdispatch || oldtask.TaskState == (int)TaskOutStatusEnum.RGV_OutdispatchFinish || oldtask.TaskState == (int)TaskInStatusEnum.RGV_IndispatchFinish)
@@ -1060,30 +1048,24 @@
            }
            else
            {
                IDevice? device = Storage.Devices.FirstOrDefault(x => x.DeviceCode == "1001");
                if (device != null)
                var stationManager = _stationManagerRepository.QueryData(x => x.stationType == 15);
                if (stationManager.Count() > 0)
                {
                    CommonConveyorLine conveyorLine = (CommonConveyorLine)device;
                    var stationManager = _stationManagerRepository.QueryData(x => x.stationType == 15);
                    if (stationManager.Count() > 0)
                    string next = null;
                    foreach (var item in stationManager)
                    {
                        string next = null;
                        foreach (var item in stationManager)
                        var x = _taskRepository.QueryFirst(x => x.NextAddress == item.stationChildCode || x.CurrentAddress == item.stationChildCode);
                        if (x == null)
                        {
                            short x = conveyorLine.GetValue<ConveyorLineDBName, short>(ConveyorLineDBName.InteractiveSignal, item.stationChildCode);
                            var structs = BitConverter.GetBytes(x).ToArray().ToBoolArray();
                            if (structs[2])
                            {
                                next = item.stationChildCode;
                                break;
                            }
                            next = item.stationChildCode;
                            break;
                        }
                        if (next != null)
                        {
                            oldtask.Remark = next;
                            _taskRepository.UpdateData(y);
                            return y;
                        }
                    }
                    if (next != null)
                    {
                        oldtask.Remark = next;
                        _taskRepository.UpdateData(oldtask);
                        return oldtask;
                    }
                }
                if (oldtask.TaskState == (int)TaskOutStatusEnum.RGV_Outdispatch || oldtask.TaskState == (int)TaskOutStatusEnum.RGV_OutdispatchFinish || oldtask.TaskState == (int)TaskInStatusEnum.RGV_IndispatchFinish)
@@ -1101,32 +1083,28 @@

        public Dt_Task? GetDispatchExecutingTask(Dt_Task oldtask)
        {
            IDevice? device = Storage.Devices.FirstOrDefault(x => x.DeviceCode == "1001");
            if (device != null)

            var stationManager = _stationManagerRepository.QueryData(x => x.stationType == 15);
            if (stationManager.Count() > 0)
            {
                CommonConveyorLine conveyorLine = (CommonConveyorLine)device;
                var stationManager = _stationManagerRepository.QueryData(x => x.stationType == 15);
                if (stationManager.Count() > 0)
                string next = null;
                foreach (var item in stationManager)
                {
                    string next = null;
                    foreach (var item in stationManager)
                    var x = _taskRepository.QueryFirst(x => x.NextAddress == item.stationChildCode || x.CurrentAddress == item.stationChildCode);
                    if (x == null)
                    {
                        short x = conveyorLine.GetValue<ConveyorLineDBName, short>(ConveyorLineDBName.InteractiveSignal, item.stationChildCode);
                        var structs = BitConverter.GetBytes(x).ToArray().ToBoolArray();
                        if (structs[2])
                        {
                            next = item.stationChildCode;
                            break;
                        }
                    }
                    if (next != null)
                    {
                        oldtask.Remark = next;
                        _taskRepository.UpdateData(oldtask);
                        return oldtask;
                        next = item.stationChildCode;
                        break;
                    }
                }
                if (next != null)
                {
                    oldtask.Remark = next;
                    _taskRepository.UpdateData(oldtask);
                    return oldtask;
                }
            }

            return null;
        }