优化代码结构和错误处理

肖洋

2025-01-19 d59b540dd78d49ddf1f2e1c6dfb7b19a7d3e3d7c

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

@@ -16,12 +16,14 @@
using WIDESEAWCS_DTO.TaskInfo;
using WIDESEAWCS_IProcessRepository;
using WIDESEAWCS_ISystemServices;
using WIDESEAWCS_ITaskInfo_HtyRepository;
using WIDESEAWCS_ITaskInfoRepository;
using WIDESEAWCS_ITaskInfoService;
using WIDESEAWCS_Model.Models;
using WIDESEAWCS_QuartzJob;
using WIDESEAWCS_QuartzJob.DeviceBase;
using WIDESEAWCS_QuartzJob.DTO;
using WIDESEAWCS_QuartzJob.Repository;
using WIDESEAWCS_QuartzJob.Service;
using WIDESEAWCS_SignalR;
using WIDESEAWCS_Tasks.ConveyorLineJob;
@@ -32,8 +34,9 @@
    [DisallowConcurrentExecution]
    public partial class CommonConveyorLineJob : JobBase, IJob
    {
        public readonly ITaskService _taskService;
        private readonly ITaskService _taskService;
        private readonly ITaskRepository _taskRepository;
        private readonly ITask_HtyRepository _task_HtyRepository;
        private readonly ITaskExecuteDetailService _taskExecuteDetailService;
        private readonly IRouterService _routerService;
        private readonly IPlatFormRepository _platFormRepository;
@@ -43,12 +46,12 @@
        private readonly IDt_StationManagerRepository _stationManagerRepository;
        private readonly ICacheService _cacheService;
        private readonly INoticeService _noticeService;
        private readonly IDeviceInfoRepository _deviceInfoRepository;

        private static List<string>? userTokenIds;
        private static List<int>? userIds;


        public CommonConveyorLineJob(ITaskService taskService, ITaskExecuteDetailService taskExecuteDetailService, IRouterService routerService, IMapper mapper, ITaskRepository taskRepository, IPlatFormRepository platFormRepository, ISys_ConfigService sys_ConfigService, IDt_StationManagerService stationManagerService, IDt_StationManagerRepository stationManagerRepository, ICacheService cacheService, INoticeService noticeService)
        public CommonConveyorLineJob(ITaskService taskService, ITaskExecuteDetailService taskExecuteDetailService, IRouterService routerService, IMapper mapper, ITaskRepository taskRepository, IPlatFormRepository platFormRepository, ISys_ConfigService sys_ConfigService, IDt_StationManagerService stationManagerService, IDt_StationManagerRepository stationManagerRepository, ICacheService cacheService, INoticeService noticeService, IDeviceInfoRepository deviceInfoRepository, ITask_HtyRepository task_HtyRepository)
        {
            _taskService = taskService;
            _taskExecuteDetailService = taskExecuteDetailService;
@@ -61,81 +64,128 @@
            _stationManagerRepository = stationManagerRepository;
            _cacheService = cacheService;
            _noticeService = noticeService;
            _deviceInfoRepository = deviceInfoRepository;
            _task_HtyRepository = task_HtyRepository;
        }

        public async Task Execute(IJobExecutionContext context)
        {
            string jobName = context.JobDetail.Key.Name;
            //if (MemoryLockManager.TryAcquireLock(jobName))
            //{
            try
            {
                // 从JobDataMap中获取传递的参数
                CommonConveyorLine conveyorLine = (CommonConveyorLine)context.JobDetail.JobDataMap.Get("JobParams");
                if (conveyorLine != null)
                {
                    //ConsoleHelper.WriteColorLine("开始：" + DateTime.Now, ConsoleColor.Cyan);
                    // 查询所有子设备的位置
                    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)

                    // 并行处理每个子设备
                    var tasks = childDeviceCodes.Select(childDeviceCode => ProcessDeviceAsync(conveyorLine, childDeviceCode)).ToList();

                    // 并行处理每个站点管理器
                    tasks = stationManagers.Select(station => Task.Run(async () =>
                    {
                        if (station.stationType == 11)
                        var (command, commandWrite) = ReadCommands(station, conveyorLine);
                        if (command == null || commandWrite == null)
                        {
                            // 读取任务命令和设备命令
                            ConveyorLineTaskCommand command = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(station.stationChildCode);
                            ConveyorLineTaskCommandWrite commandWrite = conveyorLine.ReadCustomer<ConveyorLineTaskCommandWrite>(station.stationChildCode, "DeviceCommand");
                            if (command != null && commandWrite != null)
                            {
                                // 将交互信号转换为布尔数组
                                var structs = BitConverter.GetBytes(commandWrite.WriteInteractiveSignal).Reverse().ToArray().ToBoolArray();
                                if (structs[0] == true)
                                {
                                    // 输出警告信息
                                    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);
                                }
                            }
                            return;
                        }
                        else if (station.stationType == 5)
                        {
                            // 读取任务命令和设备命令
                            ConveyorLineTaskCommand command = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(station.stationChildCode);
                            ConveyorLineTaskCommandWrite commandWrite = conveyorLine.ReadCustomer<ConveyorLineTaskCommandWrite>(station.stationChildCode, "DeviceCommand");
                            if (command != null && commandWrite != null)
                            {
                                // 将交互信号转换为布尔数组
                                var structs = BitConverter.GetBytes(commandWrite.WriteInteractiveSignal).Reverse().ToArray().ToBoolArray();
                                if (structs[0] == true)
                                {
                                    // 检查是否存在任务
                                    if (_taskRepository.QueryData(x => x.SourceAddress == station.stationChildCode).Count() > 0)
                                    {
                                        return;
                                    }
                                    // 输出警告信息
                                    ConsoleHelper.WriteWarningLine($"【{conveyorLine.DeviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{station.stationChildCode}】异常口请求扫码入库");
                                    // 处理新任务
                                    await HandleNewTaskAsync(conveyorLine, command, station.stationChildCode, 0);
                                }
                                else
                                {
                                    // 发送完成信号
                                    ConveyorLineSendFinish(conveyorLine, station.stationChildCode, 0, false);
                                }
                            }
                        }
                    }

                        IStationHandler handler = StationHandlerFactory.GetHandler(station.stationType, this);
                        await handler.HandleStationAsync(conveyorLine, station, command, commandWrite);
                    })).ToList();

                    #region
                    //foreach (var station in stationManagers)
                    //{
                    //    #region
                    //    //tasks.Add(Task.Run(async () =>
                    //    //{
                    //    //    if (station.stationType == 11)
                    //    //    {
                    //    //        // 读取任务命令和设备命令
                    //    //        ConveyorLineTaskCommand command = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(station.stationChildCode);
                    //    //        ConveyorLineTaskCommandWrite commandWrite = conveyorLine.ReadCustomer<ConveyorLineTaskCommandWrite>(station.stationChildCode, "DeviceCommand");
                    //    //        if (command != null && commandWrite != null)
                    //    //        {
                    //    //            // 将交互信号转换为布尔数组
                    //    //            var structs = BitConverter.GetBytes(commandWrite.WriteInteractiveSignal).Reverse().ToArray().ToBoolArray();
                    //    //            if (structs[0] == true)
                    //    //            {
                    //    //                // 输出警告信息
                    //    //                var log = $"【{conveyorLine.DeviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{station.stationChildCode}】空托盘请求扫码入库";
                    //    //                ConsoleHelper.WriteWarningLine(log);

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

                    //    //                // 处理入库请求
                    //    //                NGRequestTaskInbound(conveyorLine, command, station, 0);
                    //    //            }
                    //    //            else
                    //    //            {
                    //    //                // 发送完成信号
                    //    //                ConveyorLineSendFinish(conveyorLine, station.stationChildCode, 0, false);
                    //    //            }
                    //    //        }
                    //    //    }
                    //    //    else if (station.stationType == 5)
                    //    //    {
                    //    //        // 读取任务命令和设备命令
                    //    //        ConveyorLineTaskCommand command = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(station.stationChildCode);
                    //    //        ConveyorLineTaskCommandWrite commandWrite = conveyorLine.ReadCustomer<ConveyorLineTaskCommandWrite>(station.stationChildCode, "DeviceCommand");
                    //    //        if (command != null && commandWrite != null)
                    //    //        {
                    //    //            // 将交互信号转换为布尔数组
                    //    //            var structs = BitConverter.GetBytes(commandWrite.WriteInteractiveSignal).Reverse().ToArray().ToBoolArray();
                    //    //            if (structs[0] == true)
                    //    //            {
                    //    //                // 检查是否存在任务
                    //    //                if (_taskRepository.QueryData(x => x.SourceAddress == station.stationChildCode).Count() > 0)
                    //    //                {
                    //    //                    return;
                    //    //                }
                    //    //                // 输出警告信息
                    //    //                var log = $"【{conveyorLine.DeviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{station.stationChildCode}】异常口请求扫码入库";
                    //    //                ConsoleHelper.WriteWarningLine(log);

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

                    //    //                // 处理新任务
                    //    //                await HandleNewTaskAsync(conveyorLine, command, station.stationChildCode, 0);
                    //    //            }
                    //    //            else
                    //    //            {
                    //    //                // 发送完成信号
                    //    //                ConveyorLineSendFinish(conveyorLine, station.stationChildCode, 0, false);
                    //    //            }
                    //    //        }
                    //    //    }
                    //    //}));
                    //    #endregion

                    //    tasks.Add(Task.Run(async () =>
                    //    {
                    //        var (command, commandWrite) = ReadCommands(station, conveyorLine);
                    //        if (command == null || commandWrite == null)
                    //        {
                    //            return;
                    //        }

                    //        IStationHandler handler = StationHandlerFactory.GetHandler(station.stationType, this);
                    //        await handler.HandleStationAsync(conveyorLine, station, command, commandWrite);
                    //    }));
                    //}
                    #endregion

                    await Task.WhenAll(tasks);

                    //ConsoleHelper.WriteColorLine("结束：" + DateTime.Now, ConsoleColor.Cyan);
                }
            }
            catch (Exception ex)
@@ -143,15 +193,6 @@
                // 输出异常信息
                Console.Out.WriteLine(nameof(CommonConveyorLineJob) + ":" + ex.ToString());
            }
            //    finally
            //    {
            //        MemoryLockManager.ReleaseLock(jobName);
            //    }
            // }
            // else
            // {
            //     ConsoleHelper.WriteErrorLine($"[CommonConveyorLineJob]【{jobName}】任务已被锁定，无法处理");
            // }
            return;
        }

@@ -159,36 +200,20 @@
        {
            try
            {

                // 读取任务命令和设备命令
                ConveyorLineTaskCommand command = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(childDeviceCode);
                ConveyorLineTaskCommandWrite commandWrite = conveyorLine.ReadCustomer<ConveyorLineTaskCommandWrite>(childDeviceCode, "DeviceCommand");
                if (command != null && commandWrite != null)
                {

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

                    // 获取缓存中的用户信息
                    if (userTokenIds == null && userIds == null)
                    var tokenInfos = _cacheService.Get<List<UserInfo>>("Cache_UserToken");
                    if (tokenInfos != null && tokenInfos.Any())
                    {
                        var tokenInfos = _cacheService.Get<List<UserInfo>>("Cache_UserToken");
                        if (tokenInfos != null && tokenInfos.Any())
                        {
                            userTokenIds = tokenInfos.Select(x => x.Token_ID).ToList();
                            userIds = tokenInfos.Select(x => x.UserId).ToList();
                        userTokenIds = tokenInfos.Select(x => x.Token_ID).ToList();
                        userIds = tokenInfos.Select(x => x.UserId).ToList();

                            // 构造通知数据
                            object obj = new
                            {
                                command,
                                commandWrite
                            };
                            // 发送通知
                            _noticeService.LineData(userIds.FirstOrDefault(), userTokenIds, new { conveyorLine.DeviceName, childDeviceCode, data = obj });
                        }
                    }
                    else
                    {
                        // 构造通知数据
                        object obj = new
                        {
@@ -255,12 +280,14 @@
                            }
                        }
                    }

                    //if (conveyorLine.DeviceCode == "1001")
                    //{
                    //    ConsoleHelper.WriteSuccessLine("ProcessDeviceAsync方法结束时间：" + DateTime.Now.ToString("G") + $"点位：{childDeviceCode}");
                    //}
                }
            }
            catch (Exception ex)
            {

            }
            return Task.CompletedTask;
        }
@@ -306,7 +333,11 @@
                        conveyorLine.SendCommand(taskCommand, childDeviceCode);

                        // 输出警告信息，表示任务已到达子设备并请求扫码入库，下一目标地址
                        ConsoleHelper.WriteWarningLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】请求扫码入库,下一目标地址【{taskCommand.TargetAddress}】");
                        var logs = $"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】请求扫码入库,下一目标地址【{taskCommand.TargetAddress}】";
                        ConsoleHelper.WriteWarningLine(logs);

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

                        // 发送任务完成通知
                        ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
@@ -344,7 +375,12 @@
        /// <param name="childDeviceCode">子设备编号</param>
        public void RequestInNextAddress(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode)
        {
            ConsoleHelper.WriteWarningLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】请求入库下一地址");
            var log = $"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】请求入库下一地址";
            ConsoleHelper.WriteWarningLine(log);

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

            Dt_Task task = _taskService.QueryExecutingConveyorLineTask(command.TaskNum, childDeviceCode);
            if (task != null)
            {
@@ -359,7 +395,11 @@
                        var taskCommand = MapTaskCommand(newTask, command);
                        newTask.NextAddress = next;

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

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

                        conveyorLine.SendCommand(taskCommand, childDeviceCode);
                    }
@@ -380,16 +420,24 @@
        {
            try
            {
                var log = $"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线入库完成";
                ConsoleHelper.WriteWarningLine(log);

                ConsoleHelper.WriteWarningLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线入库完成");
                _noticeService.Logs(userTokenIds, new { conveyorLine.DeviceName, log = log, time = DateTime.Now.ToString("G"), color = "red" });
                WriteInfo(conveyorLine.DeviceName, log);

                var task = _taskService.QueryExecutingConveyorLineTask(command.TaskNum, childDeviceCode);
                if (task != null && task.TaskState != (int)TaskInStatusEnum.Line_InFinish)
                {
                    if (command.Barcode == task.PalletCode && childDeviceCode == task.NextAddress)
                    {
                        //conveyorLine.SetValue(ConveyorLineDBName.ConveyorLineTargetAddress, "1000", childDeviceCode);
                        conveyorLine.SetValue(ConveyorLineDBName.WriteConveyorLineTargetAddress, "1000", childDeviceCode);

                        ConsoleHelper.WriteWarningLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线入库完成,下一目标地址【等待分配货位,并写入1000】");
                        var logs = $"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线入库完成,下一目标地址【等待分配货位,并写入1000】";
                        ConsoleHelper.WriteWarningLine(logs);

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

                        ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);

@@ -416,7 +464,6 @@
            }
            catch (Exception ex)
            {

            }
        }

@@ -435,12 +482,15 @@
        {
            try
            {

                // 查询输送线任务，根据输送线设备和子设备代码获取任务信息
                var task = _taskService.QueryConveyorLineTask(conveyorLine.DeviceCode, childDeviceCode);

                // 输出成功信息，包括输送线名称、任务号、托盘条码和子设备代码，以及任务信息
                ConsoleHelper.WriteSuccessLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线请求出库,task{task.ToJsonString()}");
                var logs = $"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线请求出库,task{task.ToJsonString()}";
                ConsoleHelper.WriteSuccessLine(logs);

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

                // 如果任务不为空，则执行以下操作
                if (task != null)
@@ -455,7 +505,11 @@
                    task.NextAddress = next;

                    // 输出成功信息，包括输送线名称、任务号、托盘条码、子设备代码和下一目标地址
                    ConsoleHelper.WriteSuccessLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线请求出库,下一目标地址【{taskCommand.TargetAddress}】");
                    var log = $"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线请求出库,下一目标地址【{taskCommand.TargetAddress}】";
                    ConsoleHelper.WriteSuccessLine(log);

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

                    // 向输送线发送命令
                    conveyorLine.SendCommand(taskCommand, childDeviceCode);
@@ -475,7 +529,6 @@
            }
            catch (Exception ex)
            {

            }
        }

@@ -488,7 +541,11 @@
        public void RequestOutNextAddress(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int ProtocalDetailValue)
        {
            // 打印成功日志，显示当前设备名称、任务号、托盘条码以及请求出库下一地址的子设备代码
            ConsoleHelper.WriteSuccessLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线请求出库下一地址");
            var log = $"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线请求出库下一地址";
            ConsoleHelper.WriteSuccessLine(log);

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

            // 查询正在执行的输送线任务，根据任务号和子设备代码获取任务信息
            Dt_Task task = _taskService.QueryExecutingConveyorLineTask(command.TaskNum, childDeviceCode);
@@ -515,7 +572,11 @@
                        newTask.NextAddress = next;

                        // 打印成功日志，显示当前设备名称、任务号、托盘条码、子设备代码以及下一目标地址
                        ConsoleHelper.WriteSuccessLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线请求出库下一地址,下一目标地址【{taskCommand.TargetAddress}】");
                        var logs = $"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线请求出库下一地址,下一目标地址【{taskCommand.TargetAddress}】";
                        ConsoleHelper.WriteSuccessLine(logs);

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

                        // 发送任务命令到子设备
                        conveyorLine.SendCommand(taskCommand, childDeviceCode);
@@ -537,9 +598,12 @@
        {
            try
            {

                // 打印成功信息，表示托盘已到达指定输送线并完成出库
                ConsoleHelper.WriteSuccessLine($"【{conveyorLine.DeviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线出库完成");
                var logs = $"【{conveyorLine.DeviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线出库完成";
                ConsoleHelper.WriteSuccessLine(logs);

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

                // 查询正在执行的输送线任务
                var task = _taskService.QueryExecutingConveyorLineTask(command.TaskNum, childDeviceCode);
@@ -575,7 +639,12 @@
                        }

                        // 打印成功信息，表示托盘已到达指定输送线并完成出库，下一目标地址已确定
                        ConsoleHelper.WriteSuccessLine($"【{conveyorLine.DeviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线出库完成,下一目标地址【{taskCommand.TargetAddress}】");
                        var log = $"【{conveyorLine.DeviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线出库完成,下一目标地址【{taskCommand.TargetAddress}】";
                        ConsoleHelper.WriteSuccessLine(log);

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

                        // 发送命令到输送线
                        conveyorLine.SendCommand(taskCommand, childDeviceCode);
                        // 完成输送线发送
@@ -588,9 +657,14 @@
                        // 查询目标地址的容量
                        var NGAddress = _platFormRepository.QueryFirst(x => x.PlatCode == task.TargetAddress).Capacity;
                        // 打印成功信息，表示托盘已到达指定输送线并完成出库，下一目标地址已确定
                        ConsoleHelper.WriteSuccessLine($"【{conveyorLine.DeviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线出库完成,下一目标地址【{NGAddress}】");
                        var log = $"【{conveyorLine.DeviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线出库完成,下一目标地址【{NGAddress}】";
                        ConsoleHelper.WriteSuccessLine(log);

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

                        // 设置输送线的目标地址为NG地址
                        conveyorLine.SetValue(ConveyorLineDBName.ConveyorLineTargetAddress, NGAddress, childDeviceCode);
                        conveyorLine.SetValue(ConveyorLineDBName.WriteConveyorLineTargetAddress, NGAddress, childDeviceCode);
                        // 完成输送线发送
                        ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
                        // 更新任务状态到下一个状态
@@ -600,7 +674,6 @@
            }
            catch (Exception ex)
            {

            }
        }

@@ -629,8 +702,12 @@
            // 将修改后的数组x重新拼接成字符串，作为新的DeviceProAddress
            string DeviceProAddress = string.Join(".", x);

            // 使用conveyorLine的Communicator对象的Write方法，将value写入新的DeviceProAddress地址
            conveyorLine.Communicator.Write(DeviceProAddress, value);
            var writeBool = conveyorLine.Communicator.Read<bool>(DeviceProAddress);
            if (writeBool != value)
            {
                // 使用conveyorLine的Communicator对象的Write方法，将value写入新的DeviceProAddress地址
                conveyorLine.Communicator.Write(DeviceProAddress, value);
            }
        }

        #region 检测空盘实盘任务
@@ -655,7 +732,7 @@
                else
                    taskOutboundTypeEnum = TaskOutboundTypeEnum.Outbound;
                // 调用检查并创建任务的方法
                await CheckAndCreateTask(taskOutboundTypeEnum, childDeviceCode, index, platform.Stacker, platform);
                await CheckAndCreateTask(taskOutboundTypeEnum, childDeviceCode, index, platform);
            }
            catch (Exception)
            {
@@ -666,7 +743,7 @@
        /// <summary>
        /// 检查任务并创建新任务
        /// </summary>
        private async Task CheckAndCreateTask(TaskOutboundTypeEnum taskType, string childDeviceCode, int index, string roadWay, Platform platform)
        private async Task CheckAndCreateTask(TaskOutboundTypeEnum taskType, string childDeviceCode, int index, Platform platform)
        {
            // 查询数据库中已有的任务
            var tasks = _taskRepository.QueryData(x => x.TaskType == (int)taskType && x.TargetAddress == childDeviceCode);
@@ -691,8 +768,11 @@
                }
                var wmsIpAddress = wmsBase + requestTrayOutTask;

                var device = _deviceInfoRepository.QueryData(x => x.DeviceStatus == "1");
                var deviceCode = device.Select(x => x.DeviceCode).ToList();

                // 发送HTTP POST请求获取任务数据
                var result = await HttpHelper.PostAsync(wmsIpAddress, new { position = childDeviceCode, tag = (int)taskType, areaCdoe = roadWay, platform.ProductionLine }.ToJsonString());
                var result = await HttpHelper.PostAsync(wmsIpAddress, new { position = childDeviceCode, tag = (int)taskType, areaCdoe = platform.Stacker, AreaCdoes = deviceCode, platform.ProductionLine }.ToJsonString());
                // 解析返回的JSON数据
                WebResponseContent content = JsonConvert.DeserializeObject<WebResponseContent>(result);

@@ -718,7 +798,7 @@
            var content = _taskService.ReceiveWMSTask(new List<WMSTaskDTO> { taskDTO });
            if (content.Status)
            {
                Console.WriteLine($"{taskDTO.TaskType}呼叫成功");
                Console.WriteLine($"{taskDTO.TargetAddress}呼叫成功");
            }
            return content;
        }
@@ -727,7 +807,7 @@

        #region 设备NG口入库

        public void NGRequestTaskInbound(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int ProtocalDetailValue, string TargetAddress)
        public void NGRequestTaskInbound(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, Dt_StationManager stationManager, int ProtocalDetailValue)
        {
            var config = _sys_ConfigService.GetConfigsByCategory(CateGoryConst.CONFIG_SYS_IPAddress);
            var wmsBase = config.FirstOrDefault(x => x.ConfigKey == SysConfigKeyConst.MOMIP_BASE)?.ConfigValue;
@@ -736,7 +816,6 @@
            {
                throw new InvalidOperationException("MOM IP 未配置");
            }
            Dt_StationManager stationManager = _stationManagerRepository.QueryFirst(x => x.stationPLC == conveyorLine.DeviceCode && x.stationChildCode == childDeviceCode);
            TrayCellsStatusDto trayCells = new TrayCellsStatusDto()
            {
                Software = "WMS",
@@ -744,59 +823,86 @@
                EquipmentCode = stationManager.stationEquipMOM,
                SessionId = Guid.NewGuid().ToString(),
                EmployeeNo = "MITest",
                SceneType = "1",
                SceneType = "4",
                RequestTime = TimeZoneInfo.ConvertTimeToUtc(DateTime.Now).ToString("yyyy-MM-ddTHH:mm:ss.fffZ")
            };

            var MOMIpAddress = wmsBase + ipAddress;

            var result = HttpHelper.PostAsync(MOMIpAddress, trayCells.ToJsonString()).Result;
            WriteInfo("入站校验", $"【{childDeviceCode}】入站校验请求参数【{trayCells.ToJsonString()}】");
            WriteInfo("入站校验", $"【{stationManager.stationChildCode}】入站校验请求参数【{trayCells.ToJsonString()}】");
            WriteInfo("入站校验", "");
            WriteInfo("入站校验", $"【{childDeviceCode}】入站校验返回参数【{result}】");
            WriteInfo("入站校验", $"【{stationManager.stationChildCode}】入站校验返回参数【{result}】");
            ResultTrayCellsStatus result1 = JsonConvert.DeserializeObject<ResultTrayCellsStatus>(result);

            if (result1.Success)
            {

                var serialNosError = result1.SerialNos.Where(x => x.SerialNoStatus != 1).ToList();
                ConsoleHelper.WriteWarningLine("1");
                var serialNosError = result1.SerialNos.Where(x => x.SerialNoStatus != 1 && x.SerialNoStatus != 4).ToList();
                if (serialNosError.Count > 0)
                {
                    conveyorLine.SetValue(ConveyorLineDBName.WriteConveyorLineTargetAddress, 100, stationManager.stationChildCode);
                    ConveyorLineSendFinish(conveyorLine, stationManager.stationChildCode, ProtocalDetailValue, true);
                    return;
                }

                if (result1.SerialNos.Count <= 0)
                if (stationManager.remark == "ZYNG")
                {
                    // 空托盘入库逻辑
                    Dt_Task dt_Task = new Dt_Task()
                    ConsoleHelper.WriteWarningLine($"【注液NG入库】");
                    if (result1.SerialNos.Count <= 0)
                    {
                        TargetAddress = TargetAddress,
                        PalletCode = command.Barcode,
                        NextAddress = TargetAddress,
                        TaskNum = 0
                    };

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

                    conveyorLine.SendCommand(taskCommand, childDeviceCode);

                    ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
                        ConsoleHelper.WriteWarningLine("1000");
                        conveyorLine.SetValue(ConveyorLineDBName.WriteConveyorLineTaskNum, 5, stationManager.stationChildCode);
                        conveyorLine.SetValue(ConveyorLineDBName.WriteConveyorLineTargetAddress, 1000, stationManager.stationChildCode);
                    }
                    else
                    {
                        ConsoleHelper.WriteWarningLine("2");
                        ConsoleHelper.WriteWarningLine(stationManager.stationLocation);
                        conveyorLine.SetValue(ConveyorLineDBName.WriteConveyorLineTaskNum, 5, stationManager.stationChildCode);
                        conveyorLine.SetValue(ConveyorLineDBName.WriteConveyorLineTargetAddress, stationManager.stationLocation, stationManager.stationChildCode);
                    }
                    ConveyorLineSendFinish(conveyorLine, stationManager.stationChildCode, ProtocalDetailValue, true);
                }
                else
                {
                    conveyorLine.SetValue(ConveyorLineDBName.ConveyorLineTargetAddress, 1000, childDeviceCode);

                    ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
                    if (result1.SerialNos.Count <= 0)
                    {
                        ConsoleHelper.WriteWarningLine("2");
                        ConsoleHelper.WriteWarningLine(stationManager.stationLocation);
                        conveyorLine.SetValue(ConveyorLineDBName.WriteConveyorLineTaskNum, 5, stationManager.stationChildCode);
                        conveyorLine.SetValue(ConveyorLineDBName.WriteConveyorLineTargetAddress, stationManager.stationLocation, stationManager.stationChildCode);
                    }
                    else
                    {
                        ConsoleHelper.WriteWarningLine("1000");
                        conveyorLine.SetValue(ConveyorLineDBName.WriteConveyorLineTaskNum, 5, stationManager.stationChildCode);
                        conveyorLine.SetValue(ConveyorLineDBName.WriteConveyorLineTargetAddress, 1000, stationManager.stationChildCode);
                    }
                    ConveyorLineSendFinish(conveyorLine, stationManager.stationChildCode, ProtocalDetailValue, true);
                }
            }
            else
            {

                ConsoleHelper.WriteErrorLine(result1.MOMMessage);
            }
        }

        #endregion 化成NG口入库
        #endregion 设备NG口入库

        public async Task LogAndWarn(string deviceName, string log, string color = "red")
        {
            ConsoleHelper.WriteWarningLine(log);
            await _noticeService.Logs(userTokenIds, new { deviceName, log = log, time = DateTime.Now.ToString("G"), color = color });
            WriteInfo(deviceName, log);
        }

        private (ConveyorLineTaskCommand, ConveyorLineTaskCommandWrite) ReadCommands(Dt_StationManager station, CommonConveyorLine conveyorLine)
        {
            ConveyorLineTaskCommand command = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(station.stationChildCode);
            ConveyorLineTaskCommandWrite commandWrite = conveyorLine.ReadCustomer<ConveyorLineTaskCommandWrite>(station.stationChildCode, "DeviceCommand");
            return (command, commandWrite);
        }

    }
}