合并

wanshenmean

2025-04-16 29f20b28392d212c04c0c40a512894f8622cfa53

 CodeManagement/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/ConveyorLineJob/Task/RequestInbound.cs

@@ -1,6 +1,10 @@
using HslCommunication;
using HslCommunication.Profinet.OpenProtocol;
using Mapster;
using Microsoft.AspNetCore.Mvc.ModelBinding.Validation;
using Microsoft.CodeAnalysis;
using Microsoft.VisualBasic;
using MoYu.Logging;
using Newtonsoft.Json;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
@@ -148,12 +152,12 @@
            {
                string isTrue = string.Empty;

                //ResultTrayCellsStatus result = GetResultTrayCellsStatus(command, stationManager);
                ResultTrayCellsStatus result = GetResultTrayCellsStatus(command, stationManager);

                List<string> strings = stationManager.Roadway.Split(",").ToList();
                foreach (string item in strings)
                {
                    isTrue = RequestInboundPlatform(item, "ZJ-11", true);
                    isTrue = RequestInboundPlatform(item, result.ProductionLine, true);
                    if (isTrue != null)
                    {
                        break;
@@ -171,10 +175,10 @@
                        RoadWay = childDeviceCode,
                        SourceAddress = childDeviceCode,
                        TargetAddress = isTrue,
                        TaskState = (int)TaskOutStatusEnum.OutNew,
                        Id = 0,
                        TaskType = (int)TaskOutboundTypeEnum.TrayInToOut,
                        ProductionLine = "ZJ-11",
                        TaskState = (int)TaskOutStatusEnum.SC_OutFinish,
                        Id = 2,
                        TaskType = (int)TaskOutboundTypeEnum.OutTray,
                        ProductionLine = result.ProductionLine,
                    };
                }
                else
@@ -283,7 +287,19 @@
        {
            string isTrue = string.Empty;

            ExecuteConveyorLineTask(conveyorLine, command, ProtocalDetailValue, childDeviceCode);

            ResultTrayCellsStatus result = GetResultTrayCellsStatus(command, stationManager);

            if (result.SerialNos.Count == 0)
            {
                var Traycontent = await _taskService.RequestWMSTask(command.Barcode, childDeviceCode);
                if (Traycontent.Status)
                {
                    ConsoleHelper.WriteSuccessLine("二封空框请求回流");
                    ExecuteConveyorLineTask(conveyorLine, command, ProtocalDetailValue, childDeviceCode);
                }
            }

            List<string> strings = stationManager.Roadway.Split(",").ToList();
            foreach (string item in strings)
@@ -304,9 +320,9 @@
                    RoadWay = childDeviceCode,
                    SourceAddress = childDeviceCode,
                    TargetAddress = isTrue,
                    TaskState = (int)TaskOutStatusEnum.OutNew,
                    TaskState = (int)TaskOutStatusEnum.SC_OutFinish,
                    Id = 2,
                    TaskType = (int)TaskOutboundTypeEnum.InToOut,
                    TaskType = (int)TaskOutboundTypeEnum.OutTray,
                    ProductionLine = result.ProductionLine,
                };
                var Taskcontent = _taskService.ReceiveWMSTask(new List<WMSTaskDTO> { taskDTO });
@@ -324,70 +340,7 @@
                    ExecuteConveyorLineTask(conveyorLine, command, ProtocalDetailValue, childDeviceCode);
                }
            }
            #region

            //if (Taskcontent.Status)
            //{
            //    var task = _taskService.QueryBarCodeConveyorLineTask(command.Barcode, childDeviceCode);
            //    if (task != null)
            //    {
            //        var value = _sys_ConfigService.GetByConfigKey(CateGoryConst.CONFIG_SYS_InStation, SysConfigKeyConst.JZNGInBoundStation).ConfigValue;
            //        var valueList = value.Split(',').ToList();
            //        if (valueList.Contains(task.SourceAddress))
            //        {
            //            conveyorLine.SetValue(ConveyorLineDBName.WriteConveyorLineTargetAddress, "1000", childDeviceCode);

            //            var log = $"【{conveyorLine._deviceName}】任务号：【{task.TaskNum}】,托盘条码：【{task.PalletCode}】已到达【{childDeviceCode}】请求扫码入库(实盘),下一目标地址【{1000}】";
            //            ConsoleHelper.WriteWarningLine(log);

            //            _noticeService.Logs(userTokenIds, new { conveyorLine.DeviceName, log = log, time = DateTime.Now.ToString("G"), color = "red" });
            //            WriteInfo(conveyorLine.DeviceName, log);

            //            ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
            //        }
            //        else if (task.TargetAddress == "1020-1")
            //        {
            //            var next = task.NextAddress;
            //            var taskCommand = MapTaskCommand(task, command);
            //            task.NextAddress = next;

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

            //            _noticeService.Logs(userTokenIds, new { conveyorLine.DeviceName, log = log, time = DateTime.Now.ToString("G"), color = "red" });
            //            WriteInfo(conveyorLine.DeviceName, log);

            //            conveyorLine.SendCommand(taskCommand, childDeviceCode);
            //            ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);

            //            var taskHty = task.Adapt<Dt_Task_Hty>();
            //            _task_HtyRepository.AddData(taskHty);
            //            _taskService.DeleteData(task);
            //        }
            //        else
            //        {
            //            var next = task.NextAddress;
            //            var taskCommand = MapTaskCommand(task, command);
            //            task.NextAddress = next;

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

            //            _noticeService.Logs(userTokenIds, new { conveyorLine.DeviceName, log = log, time = DateTime.Now.ToString("G"), color = "red" });
            //            WriteInfo(conveyorLine.DeviceName, log);

            //            conveyorLine.SendCommand(taskCommand, childDeviceCode);
            //            ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
            //            _taskService.UpdateTaskStatusToNext(task);
            //        }
            //    }
            //}
            //else
            //    WriteInfo(conveyorLine.DeviceName, content.Message);

            #endregion
        }


        /// <summary>
        /// 成化入静置
@@ -401,164 +354,279 @@
        /// <exception cref="InvalidOperationException"></exception>
        private async Task JZRequestInBound(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int ProtocalDetailValue, Dt_StationManager stationManager)
        {
            ResultTrayCellsStatus resultTrayCellsStatus = GetResultTrayCellsStatus(command, stationManager);
            //todo判断是否为空框
            var serialNosError = resultTrayCellsStatus.SerialNos.Where(x => x.SerialNoStatus != 1 && x.SerialNoStatus != 4).ToList();
            if (serialNosError.Count > 0)
            try
            {
                //空框逻辑
                var Traycontent = await _taskService.RequestWMSTask(command.Barcode, childDeviceCode);
                if (Traycontent.Status)
                StaticVariable.isLineRun = false;
                
                if (StaticVariable.isStackerRun)
                {
                    ConsoleHelper.WriteSuccessLine("化成空框请求回流静置");
                    ExecuteConveyorLineTask(conveyorLine, command, ProtocalDetailValue, childDeviceCode);
                }

                ResultTrayCellsStatus resultTrayCellsStatus = GetResultTrayCellsStatus(command, stationManager);


                //todo判断是否为空框
                var serialNosError = resultTrayCellsStatus.SerialNos.Where(x => x.SerialNoStatus != 1 && x.SerialNoStatus != 4).ToList();
                if (serialNosError.Count > 0 || !resultTrayCellsStatus.Success)
                {
                    //NG流程
                    var platform = _platFormRepository.QueryFirst(x => x.ProductionLine == resultTrayCellsStatus.ProductionLine && x.DeviceCode == "1005");
                    ConveyorLineTaskCommand conveyorLineTaskCommand = new ConveyorLineTaskCommand()
                    {
                        TaskNum = 1,
                        TargetAddress = Convert.ToInt32(platform.Capacity),
                        Barcode = resultTrayCellsStatus.TrayBarcode,
                        InteractiveSignal = command.InteractiveSignal
                    };
                    conveyorLine.SendCommand(conveyorLineTaskCommand, childDeviceCode);
                    var logMessage = $"MOM数据异常,送至二封【{resultTrayCellsStatus.ProductionLine}】异常口【{Convert.ToInt32(platform.Capacity)}】";
                    LogAndSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, logMessage, conveyorLineTaskCommand.TargetAddress.ToString());
                    return;
                }
                if (resultTrayCellsStatus.SerialNos.Count == 0)
                {
                    var Traycontent = await _taskService.RequestWMSTask(command.Barcode, childDeviceCode);
                    if (Traycontent.Status)
                    {
                        ConsoleHelper.WriteSuccessLine("化成空框请求回流静置");
                        if (StaticVariable.isStackerRun)
                        {
                            ExecuteConveyorLineTask(conveyorLine, command, ProtocalDetailValue, childDeviceCode);
                        }
                        return;
                    }
                }
                else
                {
                    var configz = _sys_ConfigService.GetConfigsByCategory(CateGoryConst.CONFIG_SYS_IPAddress);
                    var wmsbase = configz.Where(x => x.ConfigKey == SysConfigKeyConst.WMSIP_BASE).FirstOrDefault()?.ConfigValue;
                    var address = configz.Where(x => x.ConfigKey == SysConfigKeyConst.QueryStockInfoForRealTrayJZAsync).FirstOrDefault()?.ConfigValue;
                    if (wmsbase == null || address == null)
                    {
                        throw new InvalidOperationException("WMS IP 未配置");
                    }
                    var wmsIpAddrss = wmsbase + address;
                    var result = await HttpHelper.PostAsync(wmsIpAddrss, new { ProductLine = resultTrayCellsStatus.ProductionLine, PalletCode = command.Barcode }.ToJsonString());
                    var StockInfocontent = JsonConvert.DeserializeObject<WebResponseContent>(result);
                    if (StockInfocontent.Status)
                    {
                        var Taskcontent = await _taskService.RequestWMSTask(command.Barcode, childDeviceCode);
                        ConsoleHelper.WriteErrorLine($"{JsonConvert.SerializeObject(Taskcontent)}");
                        if (Taskcontent.Status)
                        {
                            if (StaticVariable.isStackerRun)
                            {
                                ExecuteConveyorLineTask(conveyorLine, command, ProtocalDetailValue, childDeviceCode);
                            }
                            #region
                            //if (task != null && task.TaskState == (int)TaskOutStatusEnum.Line_OutExecuting && task.CurrentAddress == "1537")
                            //{
                            //    ConveyorLineTaskCommand command1 = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(stationManager.stationLocation);

                            //    if (command1.InteractiveSignal != 2)
                            //    {
                            //        ConsoleHelper.WriteSuccessLine("化成实托请求入静置");
                            //        if (StaticVariable.isStackerRun == true)
                            //        {
                            //            ExecuteConveyorLineTask(conveyorLine, command, ProtocalDetailValue, childDeviceCode);
                            //        }
                            //        return;
                            //    }
                            //    else
                            //    {
                            //        ConsoleHelper.WriteWarningLine("出库任务未完成");
                            //        return;
                            //    }
                            //}
                            //else if (task != null && task.TaskState == (int)TaskOutStatusEnum.SC_OutExecuting)
                            //{
                            //    ConsoleHelper.WriteWarningLine("已存在静置出库任务");
                            //    return;
                            //}
                            //else
                            //{
                            //    var Task = await _taskService.RequestWMSTask(command.Barcode, childDeviceCode);
                            //    if (Task.Status)
                            //    {
                            //        if (StaticVariable.isStackerRun == true)
                            //        {
                            //            ExecuteConveyorLineTask(conveyorLine, command, ProtocalDetailValue, childDeviceCode);
                            //        }
                            //    }
                            //    return;
                            //}
                            #endregion
                        }
                        else
                        {
                            WriteInfo(conveyorLine.DeviceName, Taskcontent.Message);
                            return;
                        }
                    }
                    else
                    {
                        string isTrue = string.Empty;

                        List<string> strings = stationManager.Roadway.Split(",").ToList();
                        foreach (string item in strings)
                        {
                            isTrue = RequestInboundPlatform(item, resultTrayCellsStatus.ProductionLine, false);
                            if (isTrue != null)
                            {
                                break;
                            }
                        }
                        if (isTrue != null && isTrue != string.Empty)
                        {
                            WMSTaskDTO taskDTO = new WMSTaskDTO
                            {
                                TaskNum = _taskRepository.GetTaskNo().Result,
                                Grade = 1,
                                PalletCode = command.Barcode,
                                RoadWay = isTrue,
                                SourceAddress = childDeviceCode,
                                TargetAddress = isTrue,
                                TaskState = (int)TaskOutStatusEnum.SC_OutFinish,
                                Id = 2,
                                TaskType = (int)TaskOutboundTypeEnum.InToOut,
                                ProductionLine = resultTrayCellsStatus.ProductionLine,
                            };
                            var Taskcontent = _taskService.ReceiveWMSTask(new List<WMSTaskDTO> { taskDTO });
                            if (Taskcontent.Status)
                            {
                                if (StaticVariable.isStackerRun)
                                {
                                    ExecuteConveyorLineTask(conveyorLine, command, ProtocalDetailValue, childDeviceCode);
                                }
                                return;
                            }
                            else
                            {
                                WriteInfo(conveyorLine.DeviceName, Taskcontent.Message);
                                return;
                            }
                        }
                        else
                        {
                            var Task = await _taskService.RequestWMSTask(command.Barcode, childDeviceCode);
                            ConsoleHelper.WriteErrorLine($"{JsonConvert.SerializeObject(Task)}");
                            if (Task.Status)
                            {
                                if (StaticVariable.isStackerRun)
                                {
                                    ExecuteConveyorLineTask(conveyorLine, command, ProtocalDetailValue, childDeviceCode);
                                }
                            }
                            ConsoleHelper.WriteWarningLine("二封缓存位已满");
                            return;
                        }

                    }
                }
            }
            catch (Exception ex)
            {
                ConsoleHelper.WriteWarningLine($"{ex.Message}");
            }
            finally
            {
                StaticVariable.isLineRun = true;
            }       
        }

        /// <summary>
        /// 执行输送线任务
        /// </summary>
        /// <param name="conveyorLine">输送线对象</param>
        /// <param name="command">输送线任务命令</param>
        /// <param name="ProtocalDetailValue">协议明细值</param>
        /// <param name="childDeviceCode">子设备编号</param>
        public void ExecuteConveyorLineTask(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, int ProtocalDetailValue, string childDeviceCode)
        {
            // 查询任务信息
            var task = _taskService.QueryBarCodeConveyorLineTask(command.Barcode, childDeviceCode);

            if (task == null) return;

            // 获取配置值并转换为列表
            var value = _sys_ConfigService.GetByConfigKey(CateGoryConst.CONFIG_SYS_InStation, SysConfigKeyConst.JZNGInBoundStation).ConfigValue;
            var valueList = value.Split(',').ToList();

            // 日志模板
            var logMessage = $"【{conveyorLine._deviceName}】任务号：【{task.TaskNum}】,托盘条码：【{task.PalletCode}】已到达【{childDeviceCode}】请求扫码入库(实盘),下一目标地址【{{0}}】";

            // 判断任务的起始地址是否在配置列表中
            if (valueList.Contains(task.SourceAddress))
            {
                // 设置目标地址为 "1000"
                conveyorLine.SetValue(ConveyorLineDBName.WriteConveyorLineTargetAddress, "1000", childDeviceCode);

                // 记录日志并发送完成信号
                LogAndSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, logMessage, "1000");
            }
            else if (task.Roadway.Contains("JZ"))
            {
                // 查询是否存在静置出库任务
                var outJZTask = _taskRepository.QueryData(x => x.Roadway == task.Roadway &&
                    (x.TaskState == (int)TaskOutStatusEnum.SC_OutExecuting ||
                     x.TaskState == (int)TaskOutStatusEnum.SC_OutFinish || x.TaskState == (int)TaskOutStatusEnum.OutNew));

                if (!outJZTask.Any())
                {
                    // 映射任务命令
                    var taskCommand = MapTaskCommand(task, command);

                    // 发送任务命令
                    conveyorLine.SendCommand(taskCommand, childDeviceCode);

                    // 记录日志并发送完成信号
                    LogAndSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, logMessage, taskCommand.TargetAddress.ToString());

                    // 更新任务状态
                    _taskService.UpdateTaskStatusToNext(task);
                }
                else
                {
                    ConsoleHelper.WriteWarningLine("已存在静置出库任务,静置入库任务无法下发至线体");
                }
            }
            else
            {
                var configz = _sys_ConfigService.GetConfigsByCategory(CateGoryConst.CONFIG_SYS_IPAddress);
                var wmsbase = configz.Where(x => x.ConfigKey == SysConfigKeyConst.WMSIP_BASE).FirstOrDefault()?.ConfigValue;
                var address = configz.Where(x => x.ConfigKey == SysConfigKeyConst.GetJZStockInfo).FirstOrDefault()?.ConfigValue;
                if (wmsbase == null || address == null)
                {
                    throw new InvalidOperationException("WMS IP 未配置");
                }
                var wmsIpAddrss = wmsbase + address;
                var result = await HttpHelper.PostAsync(wmsIpAddrss);
                var StockInfocontent = JsonConvert.DeserializeObject<WebResponseContent>(result);
                if (StockInfocontent.Status)
                {
                    var Taskcontent = await _taskService.RequestWMSTask(command.Barcode, childDeviceCode);
                    if (Taskcontent.Status)
                    {
                        var task = _taskRepository.QueryFirst(x => x.Roadway.Contains("JZ") && x.TaskState == (int)TaskOutStatusEnum.Line_OutExecuting || x.TaskState == (int)TaskOutStatusEnum.SC_OutExecuting || x.TaskState == (int)TaskOutStatusEnum.SC_OutFinish);
                        if (task != null && task.TaskState == (int)TaskOutStatusEnum.Line_OutExecuting)
                        {
                            ConveyorLineTaskCommand command1 = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(stationManager.stationLocation);
                // 映射任务命令
                var taskCommand = MapTaskCommand(task, command);

                            if (command1.InteractiveSignal != 2)
                            {
                                ConsoleHelper.WriteSuccessLine("化成实托请求入静置");
                                ExecuteConveyorLineTask(conveyorLine, command, ProtocalDetailValue, childDeviceCode);
                            }
                            else
                            {
                                ConsoleHelper.WriteWarningLine("出库任务未完成");
                            }
                        }
                        else if (task != null && task.TaskState == (int)TaskOutStatusEnum.SC_OutExecuting)
                        {
                            ConsoleHelper.WriteWarningLine("已存在静置出库任务");
                        }
                        else
                        {
                            
                            ExecuteConveyorLineTask(conveyorLine, command, ProtocalDetailValue, childDeviceCode);
                        }
                    }
                    else
                        WriteInfo(conveyorLine.DeviceName, Taskcontent.Message);
                }
                else
                {
                    string isTrue = string.Empty;
                // 发送任务命令
                conveyorLine.SendCommand(taskCommand, childDeviceCode);

                    List<string> strings = stationManager.Roadway.Split(",").ToList();
                    foreach (string item in strings)
                    {
                        isTrue = RequestInboundPlatform(item, resultTrayCellsStatus.ProductionLine, false);
                        if (isTrue != null)
                        {
                            break;
                        }
                    }
                    if (isTrue != null && isTrue != string.Empty)
                    {
                        WMSTaskDTO taskDTO = new WMSTaskDTO
                        {
                            TaskNum = _taskRepository.GetTaskNo().Result,
                            Grade = 1,
                            PalletCode = command.Barcode,
                            RoadWay = isTrue,
                            SourceAddress = childDeviceCode,
                            TargetAddress = isTrue,
                            TaskState = (int)TaskOutStatusEnum.OutNew,
                            Id = 2,
                            TaskType = (int)TaskOutboundTypeEnum.InToOut,
                            ProductionLine = resultTrayCellsStatus.ProductionLine,
                        };
                        var Taskcontent = _taskService.ReceiveWMSTask(new List<WMSTaskDTO> { taskDTO });
                        if (Taskcontent.Status)
                        {
                            ExecuteConveyorLineTask(conveyorLine, command, ProtocalDetailValue, childDeviceCode);
                        }
                        else
                            WriteInfo(conveyorLine.DeviceName, Taskcontent.Message);
                // 记录日志并发送完成信号
                LogAndSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, logMessage, taskCommand.TargetAddress.ToString());

                    }
                    else
                    {
                        ConsoleHelper.WriteWarningLine("二封缓存位已满");
                    }

                }
                // 更新任务状态
                _taskService.UpdateTaskStatusToNext(task);
            }
        }
        public void ExecuteConveyorLineTask(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, int ProtocalDetailValue ,string childDeviceCode)

        /// <summary>
        /// 记录日志并发送完成信号
        /// </summary>
        /// <param name="conveyorLine">输送线对象</param>
        /// <param name="childDeviceCode">子设备编号</param>
        /// <param name="ProtocalDetailValue">协议明细值</param>
        /// <param name="logMessage">日志消息模板</param>
        /// <param name="targetAddress">目标地址</param>
        private void LogAndSendFinish(CommonConveyorLine conveyorLine, string childDeviceCode, int ProtocalDetailValue, string logMessage, string targetAddress)
        {
            var task = _taskService.QueryBarCodeConveyorLineTask(command.Barcode, childDeviceCode);
            if (task != null)
            {
                var value = _sys_ConfigService.GetByConfigKey(CateGoryConst.CONFIG_SYS_InStation, SysConfigKeyConst.JZNGInBoundStation).ConfigValue;
                var valueList = value.Split(',').ToList();
                if (valueList.Contains(task.SourceAddress))
                {
                    conveyorLine.SetValue(ConveyorLineDBName.WriteConveyorLineTargetAddress, "1000", childDeviceCode);

                    var log = $"【{conveyorLine._deviceName}】任务号：【{task.TaskNum}】,托盘条码：【{task.PalletCode}】已到达【{childDeviceCode}】请求扫码入库(实盘),下一目标地址【{1000}】";
                    ConsoleHelper.WriteWarningLine(log);

                    _noticeService.Logs(userTokenIds, new { conveyorLine.DeviceName, log = log, time = DateTime.Now.ToString("G"), color = "red" });
                    WriteInfo(conveyorLine.DeviceName, log);

                    ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
                }
                else if (task.TargetAddress == "1020-1")
                {
                    var next = task.NextAddress;
                    var taskCommand = MapTaskCommand(task, command);
                    task.NextAddress = next;

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

                    _noticeService.Logs(userTokenIds, new { conveyorLine.DeviceName, log = log, time = DateTime.Now.ToString("G"), color = "red" });
                    WriteInfo(conveyorLine.DeviceName, log);

                    conveyorLine.SendCommand(taskCommand, childDeviceCode);
                    ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);

                    var taskHty = task.Adapt<Dt_Task_Hty>();
                    _task_HtyRepository.AddData(taskHty);
                    _taskService.DeleteData(task);
                }
                else
                {
                    var next = task.NextAddress;
                    var taskCommand = MapTaskCommand(task, command);
                    task.NextAddress = next;

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

                    _noticeService.Logs(userTokenIds, new { conveyorLine.DeviceName, log = log, time = DateTime.Now.ToString("G"), color = "red" });
                    WriteInfo(conveyorLine.DeviceName, log);

                    conveyorLine.SendCommand(taskCommand, childDeviceCode);
                    ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
                    _taskService.UpdateTaskStatusToNext(task);
                }
            }
            // 格式化日志消息
            var log = string.Format(logMessage, targetAddress);
            // 输出警告日志
            ConsoleHelper.WriteWarningLine(log);
            // 记录日志
            _noticeService.Logs(userTokenIds, new { conveyorLine.DeviceName, log, time = DateTime.Now.ToString("G"), color = "red" });
            WriteInfo(conveyorLine.DeviceName, log);
            // 发送完成信号
            ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
        }

    }
}