Merge branch 'master' of http://115.159.85.185:8098/r/HuaYiZhongHeng/BaiBuLiKu

刘磊

2024-12-21 a6ea79849f0142b5280f0c5d4b15ecc83f0d015a

 Code Management/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/ConveyorLineJob/CommonConveyorLineJob.cs

@@ -4,13 +4,11 @@
using Quartz;
using SqlSugar;
using System.Reflection;
using System.Threading.Tasks;
using WIDESEAWCS_BasicInfoRepository;
using WIDESEAWCS_BasicInfoService;
using WIDESEAWCS_Common;
using WIDESEAWCS_Common.TaskEnum;
using WIDESEAWCS_Core;
using WIDESEAWCS_Core.Caches;
using WIDESEAWCS_Core.Helper;
using WIDESEAWCS_Core.HttpContextUser;
using WIDESEAWCS_DTO.MOM;
@@ -26,7 +24,6 @@
using WIDESEAWCS_QuartzJob.Service;
using WIDESEAWCS_SignalR;
using WIDESEAWCS_Tasks.ConveyorLineJob;
using static System.Collections.Specialized.BitVector32;
using ICacheService = WIDESEAWCS_Core.Caches.ICacheService;

namespace WIDESEAWCS_Tasks
@@ -63,142 +60,209 @@

        public async Task Execute(IJobExecutionContext context)
        {
            try
            string jobName = context.JobDetail.Key.Name;
            if (MemoryLockManager.TryAcquireLock(jobName))
            {
                CommonConveyorLine conveyorLine = (CommonConveyorLine)context.JobDetail.JobDataMap.Get("JobParams");
                if (conveyorLine != null)
                try
                {
                    List<string> childDeviceCodes = _routerService.QueryAllPositions(conveyorLine.DeviceCode);
                    foreach (string childDeviceCode in childDeviceCodes)
                    CommonConveyorLine conveyorLine = (CommonConveyorLine)context.JobDetail.JobDataMap.Get("JobParams");
                    if (conveyorLine != null)
                    {
                        await ProcessDeviceAsync(conveyorLine, childDeviceCode);
                    }
                        List<string> childDeviceCodes = _routerService.QueryAllPositions(conveyorLine.DeviceCode);
                        var tasks = childDeviceCodes.Select(childDeviceCode => ProcessDeviceAsync(conveyorLine, childDeviceCode)).ToList();
                        await Task.WhenAll(tasks);

                    List<Dt_StationManager> stationManagers = _stationManagerService.GetAllStationByDeviceCode(conveyorLine.DeviceCode);
                    foreach (var station in stationManagers)
                    {
                        ConveyorLineTaskCommand command = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(station.stationChildCode);
                        ConveyorLineTaskCommandWrite commandWrite = conveyorLine.ReadCustomer<ConveyorLineTaskCommandWrite>(station.stationChildCode, "DeviceCommand");
                        if (command != null && commandWrite != null)
                        List<Dt_StationManager> stationManagers = _stationManagerService.GetAllStationByDeviceCode(conveyorLine.DeviceCode);
                        foreach (var station in stationManagers)
                        {
                            var structs = BitConverter.GetBytes(commandWrite.WriteInteractiveSignal).Reverse().ToArray().ToBoolArray();
                            if (structs[0] == true)
                            if (station.stationType == 11)
                            {
                                NGRequestTaskInbound(conveyorLine, command, station.stationChildCode, 0, station.stationLocation);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Console.Out.WriteLine(nameof(CommonConveyorLineJob) + ":" + ex.ToString());
            }
        }

        private async Task ProcessDeviceAsync(CommonConveyorLine conveyorLine, string childDeviceCode)
        {
            ConveyorLineTaskCommand command = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(childDeviceCode);
            ConveyorLineTaskCommandWrite commandWrite = conveyorLine.ReadCustomer<ConveyorLineTaskCommandWrite>(childDeviceCode, "DeviceCommand");
            if (command != null && commandWrite != null)
            {
                var structs = BitConverter.GetBytes(commandWrite.WriteInteractiveSignal).Reverse().ToArray().ToBoolArray();

                List<DeviceProtocolDetailDTO>? deviceProtocolDetails = conveyorLine.DeviceProtocolDetailDTOs.Where(x => x.DeviceProParamName == nameof(ConveyorLineTaskCommand.InteractiveSignal)).ToList();

                if (deviceProtocolDetails != null)
                {
                    foreach (var item in deviceProtocolDetails)
                    {
                        var outDeviceCodes = _routerService.QueryOutDeviceCodes(conveyorLine.DeviceCode);
                        if (structs[item.ProtocalDetailValue.ObjToInt()] == true)
                        {
                            MethodInfo? method = GetType().GetMethod(item.ProtocolDetailType);
                            if (method != null)
                            {
                                command.InteractiveSignal = commandWrite.WriteInteractiveSignal;
                                method.Invoke(this, new object[] { conveyorLine, command, childDeviceCode, item.ProtocalDetailValue.ObjToInt() });
                            }
                        }
                        else
                        {
                            DeviceProDTO? devicePro = conveyorLine.DeviceProDTOs.Where(x => x.DeviceProParamType == nameof(DeviceCommand) && x.DeviceChildCode == childDeviceCode).OrderBy(x => x.DeviceProOffset).FirstOrDefault();
                            string[] x = devicePro.DeviceProAddress.Split('.');
                            x[x.Length - 1] = (item.ProtocalDetailValue.ObjToInt() + 1).ToString();
                            string DeviceProAddress = string.Join(".", x);
                            var writeRead = conveyorLine.Communicator.Read<bool>(DeviceProAddress);
                            if (writeRead)
                            {
                                conveyorLine.Communicator.Write(DeviceProAddress, false);
                                //ConveyorLineSendFinish(conveyorLine, childDeviceCode, item.ProtocalDetailValue.ObjToInt(), false);
                            }
                        }
                    }
                }

                Platform platform = _platFormRepository.QueryFirst(x => x.PLCCode == conveyorLine.DeviceCode && x.PlatCode == childDeviceCode && x.Status == "Active");
                if (platform != null)
                {
                    if (command.InteractiveSignal != 2)
                    {
                        MethodInfo? method = GetType().GetMethod(platform.ExecutionMethod);
                        if (method != null)
                        {
                            command.InteractiveSignal = commandWrite.WriteInteractiveSignal;
                            int count = string.IsNullOrEmpty(platform.Location) ? 0 + 1 : platform.Location.Split(',').Count() + 1;
                            method.Invoke(this, new object[] { conveyorLine, command, childDeviceCode, count, platform });
                        }
                    }
                    else
                    {
                        if (platform.Location != null && platform.Location != "")
                        {
                            var strings = platform.Location.Split(',').ToList();
                            foreach (var ite in strings)
                            {
                                //int index = strings.FindIndex(p => p == ite);
                                ConveyorLineTaskCommand command1 = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(ite);
                                if (command1.InteractiveSignal != 2)
                                ConveyorLineTaskCommand command = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(station.stationChildCode);
                                ConveyorLineTaskCommandWrite commandWrite = conveyorLine.ReadCustomer<ConveyorLineTaskCommandWrite>(station.stationChildCode, "DeviceCommand");
                                if (command != null && commandWrite != null)
                                {
                                    MethodInfo? method = GetType().GetMethod(platform.ExecutionMethod);
                                    if (method != null)
                                    var structs = BitConverter.GetBytes(commandWrite.WriteInteractiveSignal).Reverse().ToArray().ToBoolArray();
                                    if (structs[0] == true)
                                    {
                                        command.InteractiveSignal = commandWrite.WriteInteractiveSignal;
                                        //int count = strings.Count - index;
                                        int count = strings.Count;
                                        method.Invoke(this, new object[] { conveyorLine, command, childDeviceCode, count, platform });
                                        ConsoleHelper.WriteWarningLine($"【{conveyorLine.DeviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{station.stationChildCode}】空托盘请求扫码入库");
                                        NGRequestTaskInbound(conveyorLine, command, station.stationChildCode, 0, station.stationLocation);
                                    }
                                    else
                                    {
                                        ConveyorLineSendFinish(conveyorLine, station.stationChildCode, 0, false);
                                    }
                                }
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    Console.Out.WriteLine(nameof(CommonConveyorLineJob) + ":" + ex.ToString());
                }
                finally
                {
                    MemoryLockManager.ReleaseLock(jobName);
                }
            }
            else
            {
                ConsoleHelper.WriteErrorLine($"[CommonConveyorLineJob]【{jobName}】任务已被锁定，无法处理");
            }
            return;
        }


        private Task ProcessDeviceAsync(CommonConveyorLine conveyorLine, string childDeviceCode)
        {
            ConveyorLineTaskCommand command = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(childDeviceCode);
            ConveyorLineTaskCommandWrite commandWrite = conveyorLine.ReadCustomer<ConveyorLineTaskCommandWrite>(childDeviceCode, "DeviceCommand");
            if (command != null && commandWrite != null)
            {
                #region 调用事件总线通知前端

                var tokenInfos = _cacheService.Get<List<UserInfo>>("Cache_UserToken");
                if (tokenInfos == null || !tokenInfos.Any())
                if (tokenInfos != null && tokenInfos.Any())
                {
                    //throw new Exception(conveyorLine.DeviceName + "缓存中未找到Token缓存");
                    return;
                }
                var userTokenIds = tokenInfos?.Select(x => x.Token_ID).ToList();
                var userIds = tokenInfos?.Select(x => x.UserId).ToList();
                    var userTokenIds = tokenInfos.Select(x => x.Token_ID).ToList();
                    var userIds = tokenInfos.Select(x => x.UserId).ToList();

                object obj = new
                {
                    childDeviceCode,
                    command,
                    commandWrite
                };
                _noticeService.StackerData(userIds?.FirstOrDefault(), userTokenIds, new { conveyorLine.DeviceName, data = obj });
                    object obj = new
                    {
                        command,
                        commandWrite
                    };
                    _noticeService.LineData(userIds.FirstOrDefault(), userTokenIds, new { conveyorLine.DeviceName, childDeviceCode, data = obj });
                }

                #endregion 调用事件总线通知前端

                var writeInteractiveSignal = commandWrite.WriteInteractiveSignal;
                var structs = BitConverter.GetBytes(writeInteractiveSignal).Reverse().ToArray().ToBoolArray();
                List<DeviceProtocolDetailDTO>? deviceProtocolDetails = conveyorLine.DeviceProtocolDetailDTOs.Where(x => x.DeviceProParamName == nameof(ConveyorLineTaskCommand.InteractiveSignal)).ToList();

                if (deviceProtocolDetails != null)
                {
                    foreach (var item in deviceProtocolDetails)
                    {
                        int itemValue = item.ProtocalDetailValue.ObjToInt();
                        if (structs[itemValue] == true)
                        {
                            var numRead = itemValue;
                            var numWrite = itemValue + 1;
                            ConsoleHelper.WriteWarningLine($"【{conveyorLine.DeviceName}】【{childDeviceCode}】【{numRead.ToString()}】位输送线读取信号：【{structs[itemValue]}】 【{numWrite}】位WCS写入信号：【{structs[itemValue + 1]}】");
                            if (structs[itemValue + 1] != structs[itemValue])
                            {
                                MethodInfo? method = GetType().GetMethod(item.ProtocolDetailType);
                                if (method != null)
                                {
                                    command.InteractiveSignal = writeInteractiveSignal;
                                    method.Invoke(this, new object[] { conveyorLine, command, childDeviceCode, itemValue });
                                }
                            }
                        }
                        else
                        {
                            ConveyorLineSendFinish(conveyorLine, childDeviceCode, itemValue, false);
                        }
                    }
                }

                Platform platform = _platFormRepository.QueryFirst(x => x.PLCCode == conveyorLine.DeviceCode && x.PlatCode == childDeviceCode && x.Status == "Active");
                if (platform != null && !string.IsNullOrEmpty(platform.Location))
                {
                    var strings = platform.Location.Split(',').ToList();
                    foreach (var ite in strings)
                    {
                        ConveyorLineTaskCommand command1 = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(ite);
                        if (command1.InteractiveSignal != 2)
                        {
                            command.InteractiveSignal = writeInteractiveSignal;
                            int count = strings.Count;
                            MethodInfo? method = GetType().GetMethod(platform.ExecutionMethod);
                            if (method != null)
                            {
                                command.InteractiveSignal = commandWrite.WriteInteractiveSignal;
                                method.Invoke(this, new object[] { conveyorLine, command, childDeviceCode, count, platform });
                            };
                        }
                    }
                }

                #region
                //var structs = BitConverter.GetBytes(commandWrite.WriteInteractiveSignal).Reverse().ToArray().ToBoolArray();

                //List<DeviceProtocolDetailDTO>? deviceProtocolDetails = conveyorLine.DeviceProtocolDetailDTOs.Where(x => x.DeviceProParamName == nameof(ConveyorLineTaskCommand.InteractiveSignal)).ToList();

                //if (deviceProtocolDetails != null)
                //{
                //    foreach (var item in deviceProtocolDetails)
                //    {
                //        if (structs[item.ProtocalDetailValue.ObjToInt()] == true)
                //        {
                //            MethodInfo? method = GetType().GetMethod(item.ProtocolDetailType);
                //            if (method != null)
                //            {
                //                var numRead = item.ProtocalDetailValue.ObjToInt();
                //                var numWrite = item.ProtocalDetailValue.ObjToInt() + 1;
                //                ConsoleHelper.WriteWarningLine($"【{conveyorLine.DeviceName}】【{childDeviceCode}】【{numRead.ToString()}】位输送线读取信号：【{structs[item.ProtocalDetailValue.ObjToInt()]}】 【{numWrite}】位WCS写入信号：【{structs[item.ProtocalDetailValue.ObjToInt() + 1]}】");
                //                if (structs[item.ProtocalDetailValue.ObjToInt() + 1] != structs[item.ProtocalDetailValue.ObjToInt()])
                //                {
                //                    command.InteractiveSignal = commandWrite.WriteInteractiveSignal;
                //                    method.Invoke(this, new object[] { conveyorLine, command, childDeviceCode, item.ProtocalDetailValue.ObjToInt() });
                //                }
                //            }
                //        }
                //        else
                //        {
                //            ConveyorLineSendFinish(conveyorLine, childDeviceCode, item.ProtocalDetailValue.ObjToInt(), false);
                //        }
                //    }
                //}

                //Platform platform = _platFormRepository.QueryFirst(x => x.PLCCode == conveyorLine.DeviceCode && x.PlatCode == childDeviceCode && x.Status == "Active");
                //if (platform != null)
                //{
                //    if (command.InteractiveSignal != 2)
                //    {
                //        MethodInfo? method = GetType().GetMethod(platform.ExecutionMethod);
                //        if (method != null)
                //        {
                //            command.InteractiveSignal = commandWrite.WriteInteractiveSignal;
                //            int count = string.IsNullOrEmpty(platform.Location) ? 0 + 1 : platform.Location.Split(',').Count() + 1;
                //            method.Invoke(this, new object[] { conveyorLine, command, childDeviceCode, count, platform });
                //        }
                //    }
                //    else
                //    {
                //        if (platform.Location != null && platform.Location != "")
                //        {
                //            var strings = platform.Location.Split(',').ToList();
                //            foreach (var ite in strings)
                //            {
                //                //int index = strings.FindIndex(p => p == ite);
                //                ConveyorLineTaskCommand command1 = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(ite);
                //                if (command1.InteractiveSignal != 2)
                //                {
                //                    MethodInfo? method = GetType().GetMethod(platform.ExecutionMethod);
                //                    if (method != null)
                //                    {
                //                        command.InteractiveSignal = commandWrite.WriteInteractiveSignal;
                //                        //int count = strings.Count - index;
                //                        int count = strings.Count;
                //                        method.Invoke(this, new object[] { conveyorLine, command, childDeviceCode, count, platform });
                //                    }
                //                }
                //            }
                //        }
                //    }
                //}
                #endregion
            }
            return Task.CompletedTask;
        }

        #region 入库

        /// <summary>
        /// 输送线请求入库
        /// </summary>
@@ -210,14 +274,36 @@
        {
            try
            {
                //ConsoleHelper.WriteWarningLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】请求扫码入库");
                ConsoleHelper.WriteWarningLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】请求扫码入库");

                var task = _taskService.QueryBarCodeConveyorLineTask(command.Barcode, childDeviceCode);
                HandleTaskOut(conveyorLine, command, childDeviceCode, ProtocalDetailValue, task);

                if (task == null && command.Barcode != "NoRead" && command.Barcode.IsNotEmptyOrNull())
                if (task != null)
                {
                    HandleNewTask(conveyorLine, command, childDeviceCode, ProtocalDetailValue);
                    if (task.TaskType == (int)TaskOutboundTypeEnum.OutTray || task.TaskType == (int)TaskOutboundTypeEnum.Outbound)
                    {
                        HandleTaskOut(conveyorLine, command, childDeviceCode, ProtocalDetailValue, task);
                    }
                    else
                    {
                        var next = task.NextAddress;
                        var taskCommand = MapTaskCommand(task, command);
                        task.NextAddress = next;
                        conveyorLine.SendCommand(taskCommand, childDeviceCode);

                        ConsoleHelper.WriteWarningLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】请求扫码入库,下一目标地址【{taskCommand.TargetAddress}】");

                        ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
                        _taskService.UpdateTaskStatusToNext(task);
                    }
                }
                else
                {
                    if (task == null && command.Barcode != "NoRead" && command.Barcode.IsNotEmptyOrNull())
                    {
                        task = _taskService.QueryBarcodeTask(command.Barcode, childDeviceCode);
                        if (task == null)
                            HandleNewTask(conveyorLine, command, childDeviceCode, ProtocalDetailValue);
                    }
                }
            }
            catch (Exception ex)
@@ -239,23 +325,26 @@
            Dt_Task task = _taskService.QueryExecutingConveyorLineTask(command.TaskNum, childDeviceCode);
            if (task != null)
            {
                Dt_Task? newTask = _taskService.UpdatePosition(task.TaskNum, task.CurrentAddress);
                if (newTask != null)
                if (command.Barcode == task.PalletCode)
                {
                    //ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(newTask);
                    //taskCommand.InteractiveSignal = command.InteractiveSignal;
                    var next = newTask.NextAddress;
                    var  taskCommand = MapTaskCommand(newTask, command);
                    newTask.NextAddress = next;
                    Dt_Task? newTask = _taskService.UpdatePosition(task.TaskNum, task.CurrentAddress);
                    if (newTask != null)
                    {
                        //ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(newTask);
                        //taskCommand.InteractiveSignal = command.InteractiveSignal;
                        var next = newTask.NextAddress;
                        var taskCommand = MapTaskCommand(newTask, command);
                        newTask.NextAddress = next;

                    ConsoleHelper.WriteWarningLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】请求入库下一地址,下一目标地址【{taskCommand.TargetAddress}】");
                        ConsoleHelper.WriteWarningLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】请求入库下一地址,下一目标地址【{taskCommand.TargetAddress}】");

                    conveyorLine.SendCommand(taskCommand, childDeviceCode);
                        conveyorLine.SendCommand(taskCommand, childDeviceCode);
                    }
                }
            }
        }

        #endregion
        #endregion 输送线请求入库下一地址

        /// <summary>
        /// 输送线入库完成
@@ -266,21 +355,41 @@
        /// <param name="ProtocalDetailValue">线体当前bool读取偏移地址</param>
        public void ConveyorLineInFinish(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int ProtocalDetailValue)
        {
            ConsoleHelper.WriteWarningLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线入库完成");
            var task = _taskService.QueryExecutingConveyorLineTask(command.TaskNum, childDeviceCode);
            if (task != null && task.TaskState != (int)TaskInStatusEnum.Line_InFinish)
            {
                ConsoleHelper.WriteWarningLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线入库完成,下一目标地址【等待分配货位】");
                ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
                if (command.Barcode == task.PalletCode && childDeviceCode == task.NextAddress)
                {
                    ConsoleHelper.WriteWarningLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线入库完成,下一目标地址【等待分配货位】");
                    ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);

                WebResponseContent content = _taskService.UpdateTaskStatusToNext(task);
                    if (task.TaskType == (int)TaskInboundTypeEnum.InNG)
                    {
                        int nextStatus = task.TaskState.GetNextNotCompletedStatus<TaskInStatusEnum>();

                Console.Out.WriteLine(content.Serialize());
                        var station = _stationManagerRepository.QueryFirst(x => x.stationChildCode == task.SourceAddress);
                        task.CurrentAddress = station.stationLocation;
                        task.NextAddress = station.stationNGLocation;
                        task.TargetAddress = task.NextAddress;
                        task.TaskState = nextStatus;
                        task.ModifyDate = DateTime.Now;
                        task.Modifier = "System";
                        _taskRepository.UpdateData(task);
                    }
                    else
                    {
                        WebResponseContent content = _taskService.UpdateTaskStatusToNext(task);
                        Console.Out.WriteLine(content.ToJsonString());
                    }
                }
            }
        }

        #endregion
        #endregion 入库

        #region 出库

        /// <summary>
        /// 输送线请求出信息
        /// </summary>
@@ -291,26 +400,30 @@
        public void RequestOutbound(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int ProtocalDetailValue)
        {
            var task = _taskService.QueryConveyorLineTask(conveyorLine.DeviceCode, childDeviceCode);
            ConsoleHelper.WriteSuccessLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线请求出库,task{task.ToJsonString()}");
            if (task != null)
            {
                //task.NextAddress = task.NextAddress.Replace("-1", "");
                //ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(task);
                //taskCommand.InteractiveSignal = command.InteractiveSignal;

                //ConveyorLineTaskCommand taskCommand = MapTaskCommand(task, command);

                var next = task.NextAddress;
                var taskCommand = MapTaskCommand(task, command);
                task.NextAddress = next;

                ConsoleHelper.WriteSuccessLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线请求出库,下一目标地址【{taskCommand.TargetAddress}】");

                conveyorLine.SendCommand(taskCommand, childDeviceCode);
                ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
                _taskService.UpdateTaskStatusToNext(task);
                if (task.TargetAddress == "1020-1")
                //if (command.Barcode == task.PalletCode)
                {
                    //task.NextAddress = task.NextAddress.Replace("-1", "");
                    //ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(task);
                    //taskCommand.InteractiveSignal = command.InteractiveSignal;

                    //ConveyorLineTaskCommand taskCommand = MapTaskCommand(task, command);

                    var next = task.NextAddress;
                    var taskCommand = MapTaskCommand(task, command);
                    task.NextAddress = next;

                    ConsoleHelper.WriteSuccessLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线请求出库,下一目标地址【{taskCommand.TargetAddress}】");

                    conveyorLine.SendCommand(taskCommand, childDeviceCode);
                    ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
                    _taskService.UpdateTaskStatusToNext(task);
                    if (task.TargetAddress == "1020-1")
                    {
                        _taskService.UpdateTaskStatusToNext(task);
                    }
                }
            }
        }
@@ -326,22 +439,25 @@
            Dt_Task task = _taskService.QueryExecutingConveyorLineTask(command.TaskNum, childDeviceCode);
            if (task != null)
            {
                Dt_Task? newTask = _taskService.UpdatePosition(task.TaskNum, task.CurrentAddress);
                if (newTask != null)
                if (command.Barcode == task.PalletCode)
                {
                    //ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(newTask);
                    //taskCommand.InteractiveSignal = command.InteractiveSignal;
                    Dt_Task? newTask = _taskService.UpdatePosition(task.TaskNum, task.CurrentAddress);
                    if (newTask != null)
                    {
                        //ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(newTask);
                        //taskCommand.InteractiveSignal = command.InteractiveSignal;

                    //ConveyorLineTaskCommand taskCommand = MapTaskCommand(newTask, command);
                        //ConveyorLineTaskCommand taskCommand = MapTaskCommand(newTask, command);

                    var next = newTask.NextAddress;
                    var taskCommand = MapTaskCommand(newTask, command);
                    newTask.NextAddress = next;
                        var next = newTask.NextAddress;
                        var taskCommand = MapTaskCommand(newTask, command);
                        newTask.NextAddress = next;

                    ConsoleHelper.WriteSuccessLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线请求出库下一地址,下一目标地址【{taskCommand.TargetAddress}】");
                        ConsoleHelper.WriteSuccessLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线请求出库下一地址,下一目标地址【{taskCommand.TargetAddress}】");

                    conveyorLine.SendCommand(taskCommand, childDeviceCode);
                    ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
                        conveyorLine.SendCommand(taskCommand, childDeviceCode);
                        ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
                    }
                }
            }
        }
@@ -357,33 +473,36 @@
            var task = _taskService.QueryExecutingConveyorLineTask(command.TaskNum, childDeviceCode);
            if (task != null)
            {
                WebResponseContent content = new WebResponseContent();
                //ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(task);
                //taskCommand.InteractiveSignal = command.InteractiveSignal;
                //ConveyorLineTaskCommand taskCommand = MapTaskCommand(task, command);

                var next = task.NextAddress;
                var taskCommand = MapTaskCommand(task, command);
                task.NextAddress = next;

                if (task.PalletCode != command.Barcode || task.Remark == "NG")
                if (command.Barcode == task.PalletCode)
                {
                    var NGAddress = _platFormRepository.QueryFirst(x => x.PlatCode == task.TargetAddress).Capacity;
                    taskCommand.TargetAddress = NGAddress;
                }
                else
                {
                    taskCommand.TargetAddress = 1000;
                }
                    WebResponseContent content = new WebResponseContent();
                    //ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(task);
                    //taskCommand.InteractiveSignal = command.InteractiveSignal;
                    //ConveyorLineTaskCommand taskCommand = MapTaskCommand(task, command);

                ConsoleHelper.WriteSuccessLine($"【{conveyorLine.DeviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线出库完成,下一目标地址【{taskCommand.TargetAddress}】");
                conveyorLine.SendCommand(taskCommand, childDeviceCode);
                ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
                content = _taskService.UpdateTaskStatusToNext(task);
                    var next = task.NextAddress;
                    var taskCommand = MapTaskCommand(task, command);
                    task.NextAddress = next;

                    if (task.PalletCode != command.Barcode || task.Remark == "NG")
                    {
                        var NGAddress = _platFormRepository.QueryFirst(x => x.PlatCode == task.TargetAddress).Capacity;
                        taskCommand.TargetAddress = NGAddress;
                    }
                    else
                    {
                        taskCommand.TargetAddress = 1000;
                    }

                    ConsoleHelper.WriteSuccessLine($"【{conveyorLine.DeviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线出库完成,下一目标地址【{taskCommand.TargetAddress}】");
                    conveyorLine.SendCommand(taskCommand, childDeviceCode);
                    ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
                    content = _taskService.UpdateTaskStatusToNext(task);
                }
            }
        }

        #endregion
        #endregion 出库

        /// <summary>
        /// 输送线交互完成
@@ -402,6 +521,7 @@
        }

        #region 检测空盘实盘任务

        /// <summary>
        /// 监测空托盘实盘出库
        /// </summary>
@@ -433,7 +553,8 @@
            var tasks = _taskRepository.QueryData(x => x.TaskType == (int)taskType && x.TargetAddress == childDeviceCode);
            if (tasks.Count < index)
            {
                ConsoleHelper.WriteErrorLine($"【{childDeviceCode}】请求【{taskType.ToString()}】任务,已有【{taskType.ToString()}】任务【{tasks.Count}】,最多拥有【{index - 1}】");
                //ConsoleHelper.WriteErrorLine($"【{childDeviceCode}】请求【{taskType.ToString()}】任务,已有【{taskType.ToString()}】任务【{tasks.Count}】,最多拥有【{index - 1}】");

                #region 调用WMS获取出库任务

                WMSTaskDTO taskDTO = new WMSTaskDTO();
@@ -448,7 +569,6 @@
                }
                var wmsIpAddress = wmsBase + requestTrayOutTask;


                var result = await HttpHelper.PostAsync(wmsIpAddress, new { position = childDeviceCode, tag = (int)taskType, areaCdoe = roadWay, platform.ProductionLine }.ToJsonString());
                //var result = await HttpHelper.PostAsync("http://localhost:5000/api/Task/RequestTrayOutTaskAsync", dynamic.ToJsonString());

@@ -460,7 +580,7 @@

                taskDTO = JsonConvert.DeserializeObject<WMSTaskDTO>(content.Data.ToString());

                #endregion
                #endregion 调用WMS获取出库任务

                CreateAndSendTask(taskDTO);
            }
@@ -478,8 +598,8 @@
            }
            return content;
        }
        #endregion

        #endregion 检测空盘实盘任务

        #region 化成NG口入库

@@ -559,7 +679,6 @@
            }
        }


        #endregion
        #endregion 化成NG口入库
    }
}