更新项目依赖，修复代码注释，调整开发环境配置

肖洋

2024-12-15 ccf5c6a4396e810b46676e545f7ad8970b3787f1

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

@@ -1,32 +1,20 @@
#region << 版 本 注 释 >>

/*----------------------------------------------------------------
 * 命名空间：WIDESEAWCS_Tasks.ConveyorLineJob
 * 创建者：胡童庆
 * 创建时间：2024/8/2 16:13:36
 * 版本：V1.0.0
 * 描述：
 *
 * ----------------------------------------------------------------
 * 修改人：
 * 修改时间：
 * 版本：V1.0.1
 * 修改说明：
 *
 *----------------------------------------------------------------*/

#endregion << 版 本 注 释 >>

using AutoMapper;
using AutoMapper;
using HslCommunication;
using OfficeOpenXml.FormulaParsing.Excel.Functions.Text;
using Newtonsoft.Json;
using Quartz;
using SqlSugar;
using System.Reflection;
using WIDESEAWCS_BasicInfoRepository;
using WIDESEAWCS_BasicInfoService;
using WIDESEAWCS_Common;
using WIDESEAWCS_Common.TaskEnum;
using WIDESEAWCS_Core;
using WIDESEAWCS_Core.Helper;
using WIDESEAWCS_Core.HttpContextUser;
using WIDESEAWCS_DTO.MOM;
using WIDESEAWCS_DTO.TaskInfo;
using WIDESEAWCS_IProcessRepository;
using WIDESEAWCS_ISystemServices;
using WIDESEAWCS_ITaskInfoRepository;
using WIDESEAWCS_ITaskInfoService;
using WIDESEAWCS_Model.Models;
@@ -34,31 +22,43 @@
using WIDESEAWCS_QuartzJob.DeviceBase;
using WIDESEAWCS_QuartzJob.DTO;
using WIDESEAWCS_QuartzJob.Service;
using WIDESEAWCS_SignalR;
using WIDESEAWCS_Tasks.ConveyorLineJob;
using ICacheService = WIDESEAWCS_Core.Caches.ICacheService;

namespace WIDESEAWCS_Tasks
{
    [DisallowConcurrentExecution]
    public class CommonConveyorLineJob : JobBase, IJob
    public partial class CommonConveyorLineJob : JobBase, IJob
    {
        private readonly List<string> _deviceCodes1 = new List<string>() { "1063", "1061", "1060" };
        private readonly List<string> _deviceCodes2 = new List<string>() { "1067", "1069", "1068" };
        private readonly ITaskService _taskService;
        public readonly ITaskService _taskService;
        private readonly ITaskRepository _taskRepository;
        private readonly ITaskExecuteDetailService _taskExecuteDetailService;
        private readonly IRouterService _routerService;
        private readonly IPlatFormRepository _platFormRepository;
        private readonly ISys_ConfigService _sys_ConfigService;
        private readonly IMapper _mapper;
        private readonly IDt_StationManagerService _stationManagerService;
        private readonly IDt_StationManagerRepository _stationManagerRepository;
        private readonly ICacheService _cacheService;
        private readonly INoticeService _noticeService;

        public CommonConveyorLineJob(ITaskService taskService, ITaskExecuteDetailService taskExecuteDetailService, IRouterService routerService, IMapper mapper, ITaskRepository taskRepository)
        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)
        {
            _taskService = taskService;
            _taskExecuteDetailService = taskExecuteDetailService;
            _routerService = routerService;
            _mapper = mapper;
            _taskRepository = taskRepository;
            _platFormRepository = platFormRepository;
            _sys_ConfigService = sys_ConfigService;
            _stationManagerService = stationManagerService;
            _stationManagerRepository = stationManagerRepository;
            _cacheService = cacheService;
            _noticeService = noticeService;
        }

        public Task Execute(IJobExecutionContext context)
        public async Task Execute(IJobExecutionContext context)
        {
            try
            {
@@ -66,81 +66,143 @@
                if (conveyorLine != null)
                {
                    List<string> childDeviceCodes = _routerService.QueryAllPositions(conveyorLine.DeviceCode);
                    List<Task> tasks = new List<Task>();
                    foreach (string childDeviceCode in childDeviceCodes)
                    {
                        //Task task = Task.Run(() =>
                        //{
                        ConveyorLineTaskCommand command = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(childDeviceCode);
                        ConveyorLineTaskCommandWrite commandWrite = conveyorLine.ReadCustomer<ConveyorLineTaskCommandWrite>(childDeviceCode, "DeviceCommand");
                        if (command != null && commandWrite != null)
                        await ProcessDeviceAsync(conveyorLine, childDeviceCode);
                    }

                    List<Dt_StationManager> stationManagers = _stationManagerService.GetAllStationByDeviceCode(conveyorLine.DeviceCode);
                    foreach (var station in stationManagers)
                    {
                        if (station.stationType == 11)
                        {
                            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)
                            ConveyorLineTaskCommand command = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(station.stationChildCode);
                            ConveyorLineTaskCommandWrite commandWrite = conveyorLine.ReadCustomer<ConveyorLineTaskCommandWrite>(station.stationChildCode, "DeviceCommand");
                            if (command != null && commandWrite != null)
                            {
                                foreach (var item in deviceProtocolDetails)
                                var structs = BitConverter.GetBytes(commandWrite.WriteInteractiveSignal).Reverse().ToArray().ToBoolArray();
                                if (structs[0] == true)
                                {
                                    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)
                                        {
                                            ConveyorLineSendFinish(conveyorLine, childDeviceCode, item.ProtocalDetailValue.ObjToInt(), false);
                                        }
                                    }
                                    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);
                                }
                            }
                        }
                        //});
                        //tasks.Add(task);
                    }
                    //for (int i = 0; i < _deviceCodes1.Count; i++)
                    //{
                    //    ConveyorLineTaskCommand command = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(_deviceCodes1[i]);
                    //    if (command.InteractiveSignal != 2)
                    //    {
                    //        EmptyTrayReturn(conveyorLine, command, _deviceCodes1[_deviceCodes1.Count - 1], i);
                    //    }
                    //}
                    //for (int i = 0; i < _deviceCodes2.Count; i++)
                    //{
                    //    ConveyorLineTaskCommand command = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(_deviceCodes2[i]);
                    //    if (command.InteractiveSignal != 2)
                    //    {
                    //        EmptyTrayReturn(conveyorLine, command, _deviceCodes2[_deviceCodes1.Count - 1], i);
                    //    }
                    //}
                    Task.WaitAll(tasks.ToArray());
                }
            }
            catch (Exception ex)
            {
                Console.Out.WriteLine(nameof(CommonConveyorLineJob) + ":" + ex.ToString());
            }
            finally
            {
                WriteDebug("CommonConveyorLineJob", "test");
                //Console.Out.WriteLine(DateTime.Now);
            }
            return Task.CompletedTask;
        }

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

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

                var tokenInfos = _cacheService.Get<List<UserInfo>>("Cache_UserToken");
                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();

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

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

        #region 入库

        /// <summary>
        /// 输送线请求入库
@@ -151,90 +213,25 @@
        /// <param name="ProtocalDetailValue">线体当前bool读取偏移地址</param>
        public void RequestInbound(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int ProtocalDetailValue)
        {
            var taskNew = _taskService.QueryCraneConveyorLineTask(command.Barcode.ObjToInt(), childDeviceCode);
            var TaskTray = _taskService.QueryConveyorLineTask(conveyorLine.DeviceCode, childDeviceCode);
            if (TaskTray != null && TaskTray.TaskType == (int)TaskOutboundTypeEnum.OutTray)
            try
            {
                // 空托盘任务
                if (TaskTray.TaskState == (int)TaskOutStatusEnum.SC_OutFinish)
                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())
                {
                    ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(TaskTray);
                    taskCommand.InteractiveSignal = command.InteractiveSignal;
                    if (command.Barcode == "")
                    {
                        taskCommand.TargetAddress = 1092;
                    }
                    conveyorLine.SendCommand(taskCommand, childDeviceCode);

                    ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);

                    _taskService.UpdateTaskStatusToNext(TaskTray);
                }
                else if(TaskTray.TaskState == (int)TaskOutStatusEnum.Line_OutExecuting)
                {
                    if(command.Barcode == "")
                    {
                        ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(TaskTray);
                        taskCommand.InteractiveSignal = command.InteractiveSignal;
                        taskCommand.TargetAddress = 1092;
                        conveyorLine.SendCommand(taskCommand, childDeviceCode);

                        ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
                        _taskService.UpdateTaskStatusToNext(TaskTray);
                    }
                    HandleNewTask(conveyorLine, command, childDeviceCode, ProtocalDetailValue);
                }
            }
            if( taskNew == null)
            catch (Exception ex)
            {
                if (_taskService.RequestWMSTask(command.Barcode, childDeviceCode).Status)
                {
                    Dt_Task task = _taskService.QueryConveyorLineTask(conveyorLine.DeviceCode, childDeviceCode);
                    if (task != null)
                    {
                        ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(task);
                        taskCommand.InteractiveSignal = command.InteractiveSignal;
                        conveyorLine.SendCommand(taskCommand, childDeviceCode);

                        ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);

                        _taskService.UpdateTaskStatusToNext(task);
                    }
                }
                Console.Out.WriteLine(ex.ToString());
            }
        }

        //
        /// <summary>
        /// 空托盘回流
        /// </summary>
        /// <param name="conveyorLine">输送线实例对象</param>
        /// <param name="command">读取的请求信息</param>
        /// <param name="childDeviceCode">子设备编号</param>
        /// <param name="ProtocalDetailValue">线体当前bool读取偏移地址</param>
        public void EmptyTrayReturn(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int index)
        {
            var tasks = _taskRepository.QueryData(x => (x.TaskState == (int)TaskOutStatusEnum.OutNew || x.TaskState == (int)TaskOutStatusEnum.Line_OutExecuting) && x.TaskType == (int)TaskOutboundTypeEnum.OutTray);
            if (tasks.Count <= index)
            {
                WMSTaskDTO taskDTO = new WMSTaskDTO()
                {
                    TaskNum = Convert.ToInt32(DateTime.Now.ToString("HHmmss")),
                    Grade = 1,
                    PalletCode = DateTime.Now.ToString("yyyyMMddHHmmss"),
                    RoadWay = "CHSC01",
                    SourceAddress = "001-001-001",
                    TargetAddress = childDeviceCode,
                    TaskState = (int)TaskOutStatusEnum.OutNew,
                    Id = 0,
                    TaskType = (int)TaskOutboundTypeEnum.OutTray
                };
                var content = _taskService.ReceiveWMSTask(new List<WMSTaskDTO> { taskDTO });
                if (content.Status)
                {
                    Console.WriteLine("空托盘呼叫成功");
                }
            }
        }
        #region 输送线请求入库下一地址

        /// <summary>
        /// 输送线请求入库下一地址
@@ -247,15 +244,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;
                    conveyorLine.SendCommand(taskCommand, childDeviceCode);
                    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}】");

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

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

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

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

                //conveyorLine.SetValue(ConveyorLineDBName.WriteInteractiveSignal, 0, childDeviceCode);
                WebResponseContent content = _taskService.UpdateTaskStatusToNext(task);
                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 入库

        #region 出库

        /// <summary>
        /// 输送线请求出信息
@@ -284,16 +314,34 @@
        /// <param name="conveyorLine">输送线实例对象</param>
        /// <param name="command">读取的请求信息</param>
        /// <param name="childDeviceCode">子设备编号</param>
        public void RequestOutbound(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode)
        /// <param name="ProtocalDetailValue">线体当前bool读取偏移地址</param>
        public void RequestOutbound(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int ProtocalDetailValue)
        {
            Dt_Task task = _taskService.QueryConveyorLineTask(conveyorLine.DeviceCode, childDeviceCode);
            var task = _taskService.QueryConveyorLineTask(conveyorLine.DeviceCode, childDeviceCode);
            if (task != null)
            {
                ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(task);
                taskCommand.InteractiveSignal = command.InteractiveSignal;
                conveyorLine.SendCommand(taskCommand, childDeviceCode);
                if (command.Barcode == task.PalletCode)
                {
                    //task.NextAddress = task.NextAddress.Replace("-1", "");
                    //ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(task);
                    //taskCommand.InteractiveSignal = command.InteractiveSignal;

                _taskService.UpdateTaskStatusToNext(task);
                    //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);
                    }
                }
            }
        }

@@ -303,17 +351,30 @@
        /// <param name="conveyorLine">输送线实例对象</param>
        /// <param name="command">读取的请求信息</param>
        /// <param name="childDeviceCode">子设备编号</param>
        public void RequestOutNextAddress(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode)
        public void RequestOutNextAddress(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int ProtocalDetailValue)
        {
            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;
                    conveyorLine.SendCommand(taskCommand, childDeviceCode);
                    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);

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

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

                        conveyorLine.SendCommand(taskCommand, childDeviceCode);
                        ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
                    }
                }
            }
        }
@@ -324,16 +385,41 @@
        /// <param name="conveyorLine">输送线实例对象</param>
        /// <param name="command">读取的请求信息</param>
        /// <param name="childDeviceCode">子设备编号</param>
        public void ConveyorLineOutFinish(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode)
        public void ConveyorLineOutFinish(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int ProtocalDetailValue)
        {
            Dt_Task task = _taskService.QueryExecutingConveyorLineTask(command.TaskNum, childDeviceCode);
            var task = _taskService.QueryExecutingConveyorLineTask(command.TaskNum, childDeviceCode);
            if (task != null)
            {
                conveyorLine.SetValue(ConveyorLineDBName.WriteInteractiveSignal, 0, childDeviceCode);
                WebResponseContent content = _taskService.UpdateTaskStatusToNext(task);
                Console.Out.WriteLine(content.Serialize());
                if (command.Barcode == task.PalletCode)
                {
                    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")
                    {
                        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 出库

        /// <summary>
        /// 输送线交互完成
@@ -350,5 +436,166 @@
            string DeviceProAddress = string.Join(".", x);
            conveyorLine.Communicator.Write(DeviceProAddress, value);
        }

        #region 检测空盘实盘任务

        /// <summary>
        /// 监测空托盘实盘出库
        /// </summary>
        /// <param name="conveyorLine">输送线实例对象</param>
        /// <param name="command">读取的请求信息</param>
        /// <param name="childDeviceCode">子设备编号</param>
        /// <param name="index">线体当前bool读取偏移地址</param>
        public async void EmptyTrayReturn(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int index, Platform platform)
        {
            try
            {
                TaskOutboundTypeEnum taskOutboundTypeEnum;
                if (platform.PlatformType.Contains("OutTray"))
                    taskOutboundTypeEnum = TaskOutboundTypeEnum.OutTray;
                else
                    taskOutboundTypeEnum = TaskOutboundTypeEnum.Outbound;
                await CheckAndCreateTask(taskOutboundTypeEnum, childDeviceCode, index, platform.Stacker, platform);
            }
            catch (Exception)
            {
            }
        }

        /// <summary>
        /// 检查任务并创建新任务
        /// </summary>
        private async Task CheckAndCreateTask(TaskOutboundTypeEnum taskType, string childDeviceCode, int index, string roadWay, Platform platform)
        {
            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}】");

                #region 调用WMS获取出库任务

                WMSTaskDTO taskDTO = new WMSTaskDTO();

                // 获取WMSip地址
                var config = _sys_ConfigService.GetConfigsByCategory(CateGoryConst.CONFIG_SYS_IPAddress);
                var wmsBase = config.FirstOrDefault(x => x.ConfigKey == SysConfigKeyConst.WMSIP_BASE)?.ConfigValue;
                var requestTrayOutTask = config.FirstOrDefault(x => x.ConfigKey == SysConfigKeyConst.RequestTrayOutTask)?.ConfigValue;
                if (wmsBase == null || requestTrayOutTask == null)
                {
                    throw new InvalidOperationException("WMS IP 未配置");
                }
                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());

                WebResponseContent content = JsonConvert.DeserializeObject<WebResponseContent>(result);

                // 检查状态并返回
                if (!content.Status)
                    return;

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

                #endregion 调用WMS获取出库任务

                CreateAndSendTask(taskDTO);
            }
        }

        /// <summary>
        /// 创建任务
        /// </summary>
        public WebResponseContent CreateAndSendTask(WMSTaskDTO taskDTO)
        {
            var content = _taskService.ReceiveWMSTask(new List<WMSTaskDTO> { taskDTO });
            if (content.Status)
            {
                Console.WriteLine($"{taskDTO.TaskType}呼叫成功");
            }
            return content;
        }

        #endregion 检测空盘实盘任务

        #region 化成NG口入库

        public void NGRequestTaskInbound(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int ProtocalDetailValue, string TargetAddress)
        {
            var config = _sys_ConfigService.GetConfigsByCategory(CateGoryConst.CONFIG_SYS_IPAddress);
            var wmsBase = config.FirstOrDefault(x => x.ConfigKey == SysConfigKeyConst.MOMIP_BASE)?.ConfigValue;
            var ipAddress = config.FirstOrDefault(x => x.ConfigKey == SysConfigKeyConst.TrayCellsStatus)?.ConfigValue;
            if (wmsBase == null || ipAddress == null)
            {
                throw new InvalidOperationException("MOM IP 未配置");
            }
            Dt_StationManager stationManager = _stationManagerRepository.QueryFirst(x => x.stationPLC == conveyorLine.DeviceCode && x.stationChildCode == childDeviceCode);
            TrayCellsStatusDto trayCells = new TrayCellsStatusDto()
            {
                Software = "WMS",
                TrayBarcode = command.Barcode,
                EquipmentCode = stationManager.stationEquipMOM,
                SessionId = Guid.NewGuid().ToString(),
                EmployeeNo = "MITest",
                SceneType = "1",
                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("入站校验", "");
            WriteInfo("入站校验", $"【{childDeviceCode}】入站校验返回参数【{result}】");
            ResultTrayCellsStatus result1 = JsonConvert.DeserializeObject<ResultTrayCellsStatus>(result);

            var serialNosError = result1.SerialNos.Where(x => x.SerialNoStatus != 1).ToList();
            if (serialNosError.Count > 0)
            {
                return;
            }

            if (result1.SerialNos.Count <= 0)
            {
                // 空托盘入库逻辑
                Dt_Task dt_Task = new Dt_Task()
                {
                    TargetAddress = TargetAddress,
                    PalletCode = command.Barcode,
                    NextAddress = TargetAddress,
                    TaskNum = 0
                };
                //ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(dt_Task);
                //taskCommand.InteractiveSignal = command.InteractiveSignal;

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

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

                conveyorLine.SendCommand(taskCommand, childDeviceCode);

                ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
            }
            else
            {
                // 空托盘入库逻辑
                Dt_Task dt_Task = new Dt_Task()
                {
                    TargetAddress = TargetAddress,
                    PalletCode = command.Barcode,
                    NextAddress = "1000",
                    TaskNum = 0
                };
                ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(dt_Task);
                taskCommand.InteractiveSignal = command.InteractiveSignal;
                conveyorLine.SendCommand(taskCommand, childDeviceCode);

                ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
            }
        }

        #endregion 化成NG口入库
    }
}