HuaYiZhongHeng/BaiBuLiKu.git

			@@ -1,33 +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 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;
			@@ -35,7 +22,9 @@
			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
			{
			@@ -47,9 +36,14 @@
			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, IPlatFormRepository platFormRepository)
			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;
			@@ -57,114 +51,217 @@
			_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
			string jobName = context.JobDetail.Key.Name;
			if (MemoryLockManager.TryAcquireLock(jobName))
			{
			CommonConveyorLine conveyorLine = (CommonConveyorLine)context.JobDetail.JobDataMap.Get("JobParams");
			if (conveyorLine != null)
			try
			{
			List<string> childDeviceCodes = _routerService.QueryAllPositions(conveyorLine.DeviceCode);
			List<Task> tasks = new List<Task>();
			foreach (string childDeviceCode in childDeviceCodes)
			CommonConveyorLine conveyorLine = (CommonConveyorLine)context.JobDetail.JobDataMap.Get("JobParams");
			if (conveyorLine != null)
			{
			//Task task = Task.Run(() =>
			//{
			ConveyorLineTaskCommand command = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(childDeviceCode);
			ConveyorLineTaskCommandWrite commandWrite = conveyorLine.ReadCustomer<ConveyorLineTaskCommandWrite>(childDeviceCode, "DeviceCommand");
			if (command != null && commandWrite != null)
			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 structs = BitConverter.GetBytes(commandWrite.WriteInteractiveSignal).Reverse().ToArray().ToBoolArray();

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

			if (deviceProtocolDetails != null)
			if (station.stationType == 11)
			{
			foreach (var item in deviceProtocolDetails)
			ConveyorLineTaskCommand command = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(station.stationChildCode);
			ConveyorLineTaskCommandWrite commandWrite = conveyorLine.ReadCustomer<ConveyorLineTaskCommandWrite>(station.stationChildCode, "DeviceCommand");
			if (command != null && commandWrite != null)
			{
			var outDeviceCodes = _routerService.QueryOutDeviceCodes(conveyorLine.DeviceCode);
			if (structs[item.ProtocalDetailValue.ObjToInt()] == true)
			var structs = BitConverter.GetBytes(commandWrite.WriteInteractiveSignal).Reverse().ToArray().ToBoolArray();
			if (structs[0] == 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() });
			}
			ConsoleHelper.WriteWarningLine($"【{conveyorLine.DeviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{station.stationChildCode}】空托盘请求扫码入库");
			NGRequestTaskInbound(conveyorLine, command, station.stationChildCode, 0, station.stationLocation);
			}
			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);
			}
			}
			}
			}

			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 (!string.IsNullOrEmpty(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;
			method.Invoke(this, new object[] { conveyorLine, command, childDeviceCode, count, platform });
			}
			}
			}
			ConveyorLineSendFinish(conveyorLine, station.stationChildCode, 0, false);
			}
			}
			}
			}
			//});

			//tasks.Add(task);
			Task.WaitAll(tasks.ToArray());
			}
			}
			catch (Exception ex)
			{
			Console.Out.WriteLine(nameof(CommonConveyorLineJob) + ":" + ex.ToString());
			}
			finally
			{
			MemoryLockManager.ReleaseLock(jobName);
			}
			}
			catch (Exception ex)
			else
			{
			Console.Out.WriteLine(nameof(CommonConveyorLineJob) + ":" + ex.ToString());
			ConsoleHelper.WriteErrorLine($"[CommonConveyorLineJob]【{jobName}】任务已被锁定，无法处理");
			}
			finally
			{
			//WriteDebug("CommonConveyorLineJob", "test");
			//Console.Out.WriteLine(DateTime.Now);
			}
			return;
			}

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

			var tokenInfos = _cacheService.Get<List<UserInfo>>("Cache_UserToken");
			if (tokenInfos != null && tokenInfos.Any())
			{
			var userTokenIds = tokenInfos.Select(x => x.Token_ID).ToList();
			var userIds = tokenInfos.Select(x => x.UserId).ToList();

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

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

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

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

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

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

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

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

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

			#region 入库

			/// <summary>
			/// 输送线请求入库
			@@ -175,140 +272,47 @@
			/// <param name="ProtocalDetailValue">线体当前bool读取偏移地址</param>
			public void RequestInbound(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int ProtocalDetailValue)
			{
			// 获取下一个任务
			var task = _taskService.QueryBarCodeConveyorLineTask(command.Barcode, childDeviceCode);
			//var taskOut = _taskService.QueryNextConveyorLineTask(conveyorLine.DeviceCode, childDeviceCode);
			//return;
			// 处理出库任务
			HandleTaskOut(conveyorLine, command, childDeviceCode, ProtocalDetailValue, task);

			// 如果没有出库任务，处理新任务
			if (task == null && command.Barcode != "NoRead")
			try
			{
			HandleNewTask(conveyorLine, command, childDeviceCode, ProtocalDetailValue);
			ConsoleHelper.WriteWarningLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】请求扫码入库");

			var task = _taskService.QueryBarCodeConveyorLineTask(command.Barcode, childDeviceCode);
			if (task != null)
			{
			if (task.TaskType == (int)TaskOutboundTypeEnum.OutTray \|\| task.TaskType == (int)TaskOutboundTypeEnum.Outbound)
			{
			HandleTaskOut(conveyorLine, command, childDeviceCode, ProtocalDetailValue, task);
			}
			else
			{
			var next = task.NextAddress;
			var taskCommand = MapTaskCommand(task, command);
			task.NextAddress = next;
			conveyorLine.SendCommand(taskCommand, childDeviceCode);

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

			ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
			_taskService.UpdateTaskStatusToNext(task);
			}
			}
			else
			{
			if (task == null && command.Barcode != "NoRead" && command.Barcode.IsNotEmptyOrNull())
			{
			task = _taskService.QueryBarcodeTask(command.Barcode, childDeviceCode);
			if (task == null)
			HandleNewTask(conveyorLine, command, childDeviceCode, ProtocalDetailValue);
			}
			}
			}

			#region 老版本

			//var taskNew = _taskService.QueryCraneConveyorLineTask(command.Barcode.ObjToInt(), childDeviceCode);
			//var Taskout = _taskService.QueryNextConveyorLineTask(conveyorLine.DeviceCode, childDeviceCode);
			//if (Taskout != null)
			//{
			// // 空托盘任务
			// if (Taskout.TaskType == (int)TaskOutboundTypeEnum.OutTray)
			// {
			// ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(Taskout);
			// taskCommand.InteractiveSignal = command.InteractiveSignal;
			// if (command.Barcode == "")
			// {
			// var NGAddress = _platFormRepository.QueryFirst(x => x.PlatCode == Taskout.TargetAddress).Capacity;
			// taskCommand.TargetAddress = NGAddress;
			// }
			// conveyorLine.SendCommand(taskCommand, childDeviceCode);

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

			// _taskService.UpdateTaskStatusToNext(Taskout);
			// }
			// else if (Taskout.TaskType == (int)TaskOutboundTypeEnum.Outbound)
			// {
			// ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(Taskout);
			// taskCommand.InteractiveSignal = command.InteractiveSignal;
			// if (Taskout.TaskState == (int)TaskOutStatusEnum.SC_OutFinish)
			// {
			// if (command.Barcode == "")
			// {
			// var NGAddress = _platFormRepository.QueryFirst(x => x.PlatCode == Taskout.TargetAddress).Capacity;
			// taskCommand.TargetAddress = NGAddress;
			// }
			// conveyorLine.SendCommand(taskCommand, childDeviceCode);

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

			// _taskService.UpdateTaskStatusToNext(Taskout);
			// }
			// else if (Taskout.TaskState == (int)TaskOutStatusEnum.Line_OutExecuting)
			// {
			// if (command.Barcode == "")
			// {
			// var NGAddress = _platFormRepository.QueryFirst(x => x.PlatCode == Taskout.TargetAddress).Capacity;
			// taskCommand.TargetAddress = NGAddress;

			// conveyorLine.SendCommand(taskCommand, childDeviceCode);

			// ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
			// _taskService.UpdateTaskStatusToNext(Taskout);
			// }
			// else
			// {
			// // todo 调用WMS任务完成接口
			// var x = new { taskNum = Taskout.TaskNum };
			// var result = HttpHelper.GetAsync("http:127.0.0.1:8098/api/Task/CompleteTaskAsync", x.ToJsonString()).Result;
			// WebResponseContent content = JsonConvert.DeserializeObject<WebResponseContent>(result);
			// if (content.Status)
			// {
			// ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
			// _taskService.UpdateTaskStatusToNext(Taskout);
			// }
			// }
			// }
			// }
			//}
			//if (taskNew == null)
			//{
			// // 化成->陈化空托盘回流
			// if (conveyorLine.DeviceCode == "1003" && childDeviceCode == "1016")
			// {
			// //TODO 调用WMS创建化成->陈化空托盘回流
			// WMSTaskDTO taskDTO = new WMSTaskDTO()
			// {
			// TaskNum = Convert.ToInt32(DateTime.Now.ToString("HHmmss")),
			// Grade = 1,
			// PalletCode = command.Barcode,
			// RoadWay = "CHSC01",
			// SourceAddress = childDeviceCode,
			// TargetAddress = "CHSC01",
			// TaskState = (int)TaskInStatusEnum.InNew,
			// Id = 0,
			// TaskType = (int)TaskInboundTypeEnum.InTray,
			// };
			// WebResponseContent content = CreateAndSendTask(taskDTO);
			// if (content.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);
			// }
			// }
			// }
			// else
			// {
			// 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);
			// }
			// }
			// }
			//}

			#endregion
			catch (Exception ex)
			{
			Console.Out.WriteLine(ex.ToString());
			}
			}

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

			/// <summary>
			/// 输送线请求入库下一地址
			@@ -321,15 +325,26 @@
			Dt_Task task = _taskService.QueryExecutingConveyorLineTask(command.TaskNum, childDeviceCode);
			if (task != null)
			{
			Dt_Task? newTask = _taskService.UpdatePosition(task.TaskNum, task.CurrentAddress);
			if (newTask != null)
			if (command.Barcode == task.PalletCode)
			{
			ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(newTask);
			taskCommand.InteractiveSignal = command.InteractiveSignal;
			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>
			/// 输送线入库完成
			@@ -340,17 +355,40 @@
			/// <param name="ProtocalDetailValue">线体当前bool读取偏移地址</param>
			public void ConveyorLineInFinish(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int ProtocalDetailValue)
			{
			Dt_Task task = _taskService.QueryExecutingConveyorLineTask(command.TaskNum, childDeviceCode);
			ConsoleHelper.WriteWarningLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线入库完成");
			var task = _taskService.QueryExecutingConveyorLineTask(command.TaskNum, childDeviceCode);
			if (task != null && task.TaskState != (int)TaskInStatusEnum.Line_InFinish)
			{
			ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
			if (command.Barcode == task.PalletCode && childDeviceCode == task.NextAddress)
			{
			ConsoleHelper.WriteWarningLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线入库完成,下一目标地址【等待分配货位】");
			ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);

			//conveyorLine.SetValue(ConveyorLineDBName.WriteInteractiveSignal, 0, childDeviceCode);
			WebResponseContent content = _taskService.UpdateTaskStatusToNext(task);
			if (task.TaskType == (int)TaskInboundTypeEnum.InNG)
			{
			int nextStatus = task.TaskState.GetNextNotCompletedStatus<TaskInStatusEnum>();

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

			#endregion 入库

			#region 出库

			/// <summary>
			/// 输送线请求出信息
			@@ -361,15 +399,32 @@
			/// <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);
			ConsoleHelper.WriteSuccessLine($"【{conveyorLine._deviceName}】任务号：【{command.TaskNum}】,托盘条码：【{command.Barcode}】已到达【{childDeviceCode}】输送线请求出库,task{task.ToJsonString()}");
			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;

			ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
			_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);
			}
			}
			}
			}

			@@ -379,17 +434,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);
			}
			}
			}
			}
			@@ -402,150 +470,39 @@
			/// <param name="childDeviceCode">子设备编号</param>
			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)
			{
			WebResponseContent content = new WebResponseContent();
			ConveyorLineTaskCommand taskCommand = _mapper.Map<ConveyorLineTaskCommand>(task);
			taskCommand.InteractiveSignal = command.InteractiveSignal;
			if (task.PalletCode != command.Barcode)
			if (command.Barcode == task.PalletCode)
			{
			var NGAddress = _platFormRepository.QueryFirst(x => x.PlatCode == task.TargetAddress).Capacity;
			taskCommand.TargetAddress = NGAddress;
			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);
			}
			else
			{
			taskCommand.TargetAddress = 0;
			}

			#region 向WMS上报任务完成

			WMSTaskDTO wMSTaskDTO = new WMSTaskDTO();
			var result = HttpHelper.PostAsync("http:127.0.0.1:8098/api/Task/CompleteTaskAsync", (new { taskNum = command.TaskNum }).ToJsonString()).Result;

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

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

			#endregion 向WMS请求空托盘任务

			conveyorLine.SendCommand(taskCommand, childDeviceCode);
			ConveyorLineSendFinish(conveyorLine, childDeviceCode, ProtocalDetailValue, true);
			content = _taskService.UpdateTaskStatusToNext(task);
			}
			}

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

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

			#region
			///// <summary>
			///// 陈化实盘出库)
			///// </summary>
			///// <param name="conveyorLine">输送线实例对象</param>
			///// <param name="command">读取的请求信息</param>
			///// <param name="childDeviceCode">子设备编号</param>
			///// <param name="index">线体当前bool读取偏移地址</param>
			//public void ChuanhuaOutbound(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode)
			//{
			// CheckAndCreateTask(TaskOutboundTypeEnum.Outbound, childDeviceCode, "CHSC01", "001-001-001");
			//}

			///// 静置空托盘出库
			///// </summary>
			///// <param name="conveyorLine">输送线实例对象</param>
			///// <param name="command">读取的请求信息</param>
			///// <param name="childDeviceCode">子设备编号</param>
			///// <param name="index">线体当前bool读取偏移地址</param>
			//public void EmptyTrayOutbound(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int index)
			//{
			// CheckAndCreateTask(TaskOutboundTypeEnum.OutTray, childDeviceCode, index, "JZSC01", "002-020-001");
			//}
			///// <summary>
			///// 静置实盘出库
			///// </summary>
			///// <param name="conveyorLine">输送线实例对象</param>
			///// <param name="command">读取的请求信息</param>
			///// <param name="childDeviceCode">子设备编号</param>
			///// <param name="index">线体当前bool读取偏移地址</param>
			//public void JingzhiOutbound(CommonConveyorLine conveyorLine, ConveyorLineTaskCommand command, string childDeviceCode, int index)
			//{
			// CheckAndCreateTask(TaskOutboundTypeEnum.Outbound, childDeviceCode, index, "JZSC01", "002-000-001");
			//}
			#endregion

			/// <summary>
			/// 检查任务并创建新任务
			/// </summary>
			private void CheckAndCreateTask(TaskOutboundTypeEnum taskType, string childDeviceCode, int index, string roadWay, List<string> roadways = null)
			{
			var tasks = _taskRepository.QueryData(x => x.TaskType == (int)taskType && x.TargetAddress == childDeviceCode);
			if (tasks.Count < index)
			{
			//var taskDTO = new WMSTaskDTO()
			//{
			// TaskNum = Convert.ToInt32(DateTime.Now.ToString("HHmmss")),
			// Grade = 1,
			// PalletCode = DateTime.Now.ToString("yyyyMMddHHmmss"),
			// RoadWay = roadWay,
			// SourceAddress = sourceAddress,
			// TargetAddress = childDeviceCode,
			// TaskState = (int)TaskOutStatusEnum.OutNew,
			// Id = 0,
			// TaskType = (int)taskType
			//};
			#region 调用WMS获取出库任务
			WMSTaskDTO taskDTO = new WMSTaskDTO();
			dynamic dynamic = new
			{
			position = childDeviceCode,
			tag = (int)taskType,
			areaCdoe = roadWay,
			roadways = roadways
			};
			var result = HttpHelper.PostAsync("http:127.0.0.1:8098/api/Task/RequestTaskAsync", dynamic.ToJsonString()).Result;

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

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

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

			CreateAndSendTask(taskDTO);
			}
			}
			#endregion 出库

			/// <summary>
			/// 输送线交互完成
			@@ -562,5 +519,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口入库
			}
			}