RuiShengZhiNeng/AoTanSiWCS.git

			@@ -19,8 +19,10 @@
			using HslCommunication;
			using Microsoft.Extensions.Logging;
			using Newtonsoft.Json;
			using OfficeOpenXml.FormulaParsing.Excel.Functions.Math;
			using Quartz;
			using SixLabors.ImageSharp.Drawing;
			using SqlSugar;
			using System.Diagnostics.CodeAnalysis;
			using System.Reflection;
			using System.Text;
			@@ -30,6 +32,7 @@
			using WIDESEAWCS_Core.Caches;
			using WIDESEAWCS_Core.Helper;
			using WIDESEAWCS_Core.HttpContextUser;
			using WIDESEAWCS_DTO.Enum;
			using WIDESEAWCS_IBasicInfoRepository;
			using WIDESEAWCS_IBasicInfoService;
			using WIDESEAWCS_ITaskInfoRepository;
			@@ -42,10 +45,10 @@
			using WIDESEAWCS_QuartzJob.Models;
			using WIDESEAWCS_QuartzJob.Service;
			using WIDESEAWCS_SignalR;
			using WIDESEAWCS_TaskInfoRepository;
			using WIDESEAWCS_Tasks.ConveyorLineJob;
			using WIDESEAWCS_Tasks.RGVJob;
			using WIDESEAWCS_Tasks.StackerCraneJob;
			using static Microsoft.EntityFrameworkCore.DbLoggerCategory.Database;

			namespace WIDESEAWCS_Tasks
			{
			@@ -53,18 +56,19 @@
			public class CommonRGV_FirstFloorJob : JobBase, IJob
			{
			private readonly ITaskService _taskService;
			private readonly ITask_HtyRepository _task_HtyRepository;
			private readonly ITaskRepository _taskRepository;
			private readonly ITaskExecuteDetailService _taskExecuteDetailService;
			private readonly IRouterService _routerService;
			private readonly IDt_StationManagerService _stationManagerService;
			private readonly IDt_StationManagerRepository _stationManagerRepository;
			private readonly IMapper _mapper;
			private readonly ICacheService _cacheService;
			private readonly WIDESEAWCS_Core.Caches.ICacheService _cacheService;
			private readonly INoticeService _noticeService;
			private static List<string>? userTokenIds;
			private static List<int>? userIds;

			public CommonRGV_FirstFloorJob(ITaskService taskService, ITaskExecuteDetailService taskExecuteDetailService, IRouterService routerService, IDt_StationManagerService stationManagerService, IMapper mapper, ICacheService cacheService, INoticeService noticeService, ITaskRepository taskRepository, IDt_StationManagerRepository stationManagerRepository)
			public CommonRGV_FirstFloorJob(ITaskService taskService, ITaskExecuteDetailService taskExecuteDetailService, IRouterService routerService, IDt_StationManagerService stationManagerService, IMapper mapper, WIDESEAWCS_Core.Caches.ICacheService cacheService, INoticeService noticeService, ITaskRepository taskRepository, IDt_StationManagerRepository stationManagerRepository, ITask_HtyRepository task_HtyRepository)
			{
			_taskService = taskService;
			_taskExecuteDetailService = taskExecuteDetailService;
			@@ -75,11 +79,12 @@
			_noticeService = noticeService;
			_taskRepository = taskRepository;
			_stationManagerRepository = stationManagerRepository;
			_task_HtyRepository = task_HtyRepository;
			}

			public Task Execute(IJobExecutionContext context)
			{
			Console.WriteLine(DateTime.Now.ToString() + "ï¼çº¿ç¨IDï¼" + Thread.CurrentThread.ManagedThreadId);
			//Console.WriteLine(DateTime.Now.ToString() + "ï¼çº¿ç¨IDï¼" + Thread.CurrentThread.ManagedThreadId);
			try
			{
			//ç¨è¿ç§æ¹å¼è½ç¡®ä¿ç±»åè½¬æ¢ä¸ä¼æé®é¢
			@@ -105,21 +110,51 @@
			var IsExecutingTask = DispatchExecutingTask(FirstRgv, task);
			if (IsExecutingTask != null)
			{
			RGVTaskCommand? rgvTaskCommand = ConvertToRGVTaskCommand(task);
			RGVTaskCommand? rgvTaskCommand = ConvertToRGVTaskCommand(IsExecutingTask);
			if (rgvTaskCommand != null)
			{
			Thread.Sleep(1000);
			bool sendFlag = SendCommand(FirstRgv, rgvTaskCommand);
			if (sendFlag)
			{
			_taskService.UpdateTaskStatusToNext(task.TaskNum);
			if (IsExecutingTask.Remark != null)
			{
			IsExecutingTask.RGVName = "RGV02";
			IsExecutingTask.CurrentAddress = IsExecutingTask.Remark;
			IsExecutingTask.Remark = "";
			Dt_StationManager station = _stationManagerRepository.QueryFirst(x => x.stationChildCode == IsExecutingTask.NextAddress);
			IsExecutingTask.SourceStation = IsExecutingTask.CurrentAddress=="1025"?10:7;
			if (IsExecutingTask.TaskType == (int)TaskInboundTypeEnum.Inbound)
			{
			IsExecutingTask.TargetStation = station.stationRemark;
			}
			else
			{
			IsExecutingTask.TargetStation = station.remark;
			}
			IsExecutingTask.TaskState = (int)TaskInStatusEnum.RGV_TransFer;
			_taskRepository.UpdateData(IsExecutingTask);
			Thread.Sleep(1000);
			}
			else
			{
			IsExecutingTask.RGVName = FirstRgv.DeviceCode;
			_taskRepository.UpdateData(IsExecutingTask);
			_taskService.UpdateTaskStatusToNext(IsExecutingTask.TaskNum);
			Thread.Sleep(1000);
			}
			}
			}
			}
			}
			else
			{
			var taskNew = DispatchTask(FirstRgv);
			Dt_Task taskNew = null;
			taskNew = GetTransFerTask(FirstRgv);
			if (taskNew == null)
			{
			taskNew = DispatchTask(FirstRgv);
			}
			if (taskNew != null)
			{
			RGVTaskCommand? rgvTaskCommand = ConvertToRGVTaskCommand(taskNew);
			@@ -129,7 +164,44 @@
			bool sendFlag = SendCommand(FirstRgv, rgvTaskCommand);
			if (sendFlag)
			{
			_taskService.UpdateTaskStatusToNext(taskNew.TaskNum);
			if (taskNew.TaskState == (int)TaskInStatusEnum.RGV_TransFerFInish)
			{
			taskNew.TaskState = (int)TaskInStatusEnum.RGV_InExecuting;
			_taskRepository.UpdateData(taskNew);
			Thread.Sleep(1000);
			}
			else if (taskNew.TaskState == (int)TaskOutStatusEnum.RGV_TransFerFInish)
			{
			taskNew.TaskState = (int)TaskOutStatusEnum.RGV_OutExecuting;
			_taskRepository.UpdateData(taskNew);
			Thread.Sleep(1000);
			}
			else if (taskNew.Remark != null)
			{
			taskNew.RGVName = "RGV02";
			taskNew.CurrentAddress = taskNew.Remark;
			taskNew.Remark = "";
			taskNew.TaskState = (int)TaskOutStatusEnum.RGV_TransFer;
			Dt_StationManager station = _stationManagerRepository.QueryFirst(x => x.stationChildCode == taskNew.NextAddress);
			taskNew.SourceStation = taskNew.CurrentAddress == "1025" ? 10 : 7;
			if (taskNew.TaskType == (int)TaskInboundTypeEnum.Inbound)
			{
			taskNew.TargetStation = station.stationRemark;
			}
			else
			{
			taskNew.TargetStation = station.remark;
			}
			_taskRepository.UpdateData(taskNew);
			Thread.Sleep(1000);
			}
			else
			{
			taskNew.RGVName = FirstRgv.DeviceCode;
			_taskRepository.UpdateData(taskNew);
			_taskService.UpdateTaskStatusToNext(taskNew.TaskNum);
			Thread.Sleep(1000);
			}
			}
			}
			}
			@@ -164,6 +236,7 @@
			Running = RGVWorkStatus(FirstRgv.GetValue<RGVDBName, bool>(RGVDBName.Running)),
			LevelPoint = FirstRgv.GetValue<RGVDBName, int>(RGVDBName.LevelPoint),
			CurrentTaskNum = FirstRgv.GetValue<RGVDBName, short>(RGVDBName.RGVTaskNum),
			RGVAlarm = FirstRgv.GetValue<RGVDBName, uint>(RGVDBName.RGVAlarm),
			FirstRgv.DeviceCode,
			FirstRgv.DeviceName,
			};
			@@ -175,10 +248,10 @@
			}
			else
			{
			if (commonRGVFirst == null)
			Console.WriteLine($"RGV01æªæ¾å°è®¾å¤å¯¹è±¡çå¼");
			else
			Console.WriteLine($"RGV01è®¾å¤å¯¹è±¡ç±»åéè¯¯");
			//if (commonRGVFirst == null)
			// Console.WriteLine($"RGV01æªæ¾å°è®¾å¤å¯¹è±¡çå¼");
			//else
			// Console.WriteLine($"RGV01è®¾å¤å¯¹è±¡ç±»åéè¯¯");
			}

			#endregion
			@@ -196,20 +269,44 @@
			if (task != null)
			{
			var IsExecutingTask = DispatchExecutingTask(SecondRgv, task);
			RGVTaskCommand? rgvTaskCommand = ConvertToRGVTaskCommand(task);
			if (rgvTaskCommand != null)
			if (IsExecutingTask != null)
			{
			Thread.Sleep(1000);
			bool sendFlag = SendCommand(SecondRgv, rgvTaskCommand);
			if (sendFlag)
			RGVTaskCommand? rgvTaskCommand = ConvertToRGVTaskCommand(IsExecutingTask);
			if (rgvTaskCommand != null)
			{
			_taskService.UpdateTaskStatusToNext(task.TaskNum);
			Thread.Sleep(1000);
			bool sendFlag = SendCommand(SecondRgv, rgvTaskCommand);
			if (sendFlag)
			{
			if (IsExecutingTask.Remark != null)
			{
			IsExecutingTask.RGVName = "RGV01";
			IsExecutingTask.CurrentAddress = IsExecutingTask.Remark;
			IsExecutingTask.Remark = "";
			IsExecutingTask.TaskState = (int)TaskInStatusEnum.RGV_TransFer;
			_taskRepository.UpdateData(IsExecutingTask);
			Thread.Sleep(1000);
			}
			else
			{
			IsExecutingTask.RGVName = SecondRgv.DeviceCode;
			_taskRepository.UpdateData(IsExecutingTask);
			_taskService.UpdateTaskStatusToNext(IsExecutingTask.TaskNum);
			Thread.Sleep(1000);
			}
			}
			}
			}
			}
			else
			{
			var taskNew = DispatchTask(SecondRgv);
			Dt_Task taskNew = null;
			taskNew = GetTransFerTask(SecondRgv);
			if (taskNew == null)
			{
			taskNew = DispatchTask(SecondRgv);
			}

			if (taskNew != null)
			{
			RGVTaskCommand? rgvTaskCommand = ConvertToRGVTaskCommand(taskNew);
			@@ -219,7 +316,34 @@
			bool sendFlag = SendCommand(SecondRgv, rgvTaskCommand);
			if (sendFlag)
			{
			_taskService.UpdateTaskStatusToNext(taskNew.TaskNum);
			if (taskNew.TaskState == (int)TaskInStatusEnum.RGV_TransFerFInish)
			{
			taskNew.TaskState = (int)TaskInStatusEnum.RGV_InExecuting;
			_taskRepository.UpdateData(taskNew);
			Thread.Sleep(1000);
			}
			else if (taskNew.TaskState == (int)TaskOutStatusEnum.RGV_TransFerFInish)
			{
			taskNew.TaskState = (int)TaskOutStatusEnum.RGV_OutExecuting;
			_taskRepository.UpdateData(taskNew);
			Thread.Sleep(1000);
			}
			else if (taskNew.Remark != null)
			{
			taskNew.RGVName = "RGV01";
			taskNew.CurrentAddress = taskNew.Remark;
			taskNew.Remark = "";
			taskNew.TaskState = (int)TaskOutStatusEnum.RGV_TransFer;
			_taskRepository.UpdateData(taskNew);
			Thread.Sleep(1000);
			}
			else
			{
			taskNew.RGVName = SecondRgv.DeviceCode;
			_taskRepository.UpdateData(taskNew);
			_taskService.UpdateTaskStatusToNext(taskNew.TaskNum);
			Thread.Sleep(1000);
			}
			}
			}
			}
			@@ -254,6 +378,7 @@
			Running = RGVWorkStatus(SecondRgv.GetValue<RGVDBName, bool>(RGVDBName.Running)),
			LevelPoint = SecondRgv.GetValue<RGVDBName, int>(RGVDBName.LevelPoint),
			CurrentTaskNum = SecondRgv.GetValue<RGVDBName, short>(RGVDBName.RGVTaskNum),
			RGVAlarm = SecondRgv.GetValue<RGVDBName, uint>(RGVDBName.RGVAlarm),
			SecondRgv.DeviceCode,
			SecondRgv.DeviceName,
			};
			@@ -265,10 +390,10 @@
			}
			else
			{
			if (commonRGVSecond == null)
			Console.WriteLine($"RGV02æªæ¾å°è®¾å¤å¯¹è±¡çå¼");
			else
			Console.WriteLine($"RGV02è®¾å¤å¯¹è±¡ç±»åéè¯¯");
			//if (commonRGVSecond == null)
			// Console.WriteLine($"RGV02æªæ¾å°è®¾å¤å¯¹è±¡çå¼");
			//else
			// Console.WriteLine($"RGV02è®¾å¤å¯¹è±¡ç±»åéè¯¯");
			}
			#endregion
			//}
			@@ -289,33 +414,25 @@
			CommonRGV_FirstFloor? commonRGVSecond = Storage.Devices.FirstOrDefault(x => x.DeviceCode == "RGV02") as CommonRGV_FirstFloor;
			if (commonRGVSecond != null)
			{
			if (commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic) && !commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault) && !commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Running) && !commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.InStock))
			if (commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic) && !commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault))
			{
			if (commonRGVSecond.GetValue<RGVDBName, int>(RGVDBName.LevelPoint) > 1000)
			{
			RGVTaskCommand command = new RGVTaskCommand()
			{
			PickupLocation = (byte)Convert.ToSByte(15),
			TaskNum = Convert.ToInt16(1000),
			TaskType = (byte)Convert.ToSByte(1)
			};
			SendCommand(commonRGVSecond, command);
			}
			LogAndWarn("æ§è¡è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVSecond.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGV.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãä½ä¸ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Running)}ãè®¾å¤ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãæ¯å¦æè´§ï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.InStock)}ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(task)}ãã");
			return task;
			}
			else if (commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic) && !commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault))
			{
			var taskSecond = _taskRepository.QueryFirst(x => x.RGVName == "RGV02" && x.TaskNum == commonRGVSecond.GetValue<RGVDBName, short>(RGVDBName.RGVTaskNum));
			var taskSecond = _taskRepository.QueryFirst(x => x.RGVName == "RGV02" && x.TaskNum == commonRGVSecond.GetValue<RGVDBName, short>(RGVDBName.RGVTaskNum) && ((x.TaskType == (int)TaskInboundTypeEnum.Inbound && x.TaskState < 230) \|\| (x.TaskType == (int)TaskOutboundTypeEnum.Outbound)));
			if (taskSecond != null)
			{
			if (taskSecond.TaskState == (int)TaskOutStatusEnum.RGV_Outdispatch \|\| taskSecond.TaskState == (int)TaskOutStatusEnum.RGV_OutdispatchFinish \|\| taskSecond.TaskState == (int)TaskInStatusEnum.RGV_Indispatch \|\| taskSecond.TaskState == (int)TaskInStatusEnum.RGV_InAwaitWMS \|\| taskSecond.TaskState == (int)TaskInStatusEnum.RGV_IndispatchFinish)
			{
			if (task.TaskState == (int)TaskOutStatusEnum.RGV_OutdispatchFinish \|\| task.TaskState == (int)TaskInStatusEnum.RGV_IndispatchFinish)
			{
			if (task.TargetStation > taskSecond.SourceStation && task.TargetStation > taskSecond.TargetStation)
			if (task.TargetStation- taskSecond.SourceStation > 1 && task.TargetStation - taskSecond.TargetStation > 1)
			{
			LogAndWarn("æ§è¡è°åº¦ä»»å¡æ§å¶", $"ã{commonRGV.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGV.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãè®¾å¤ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãã{commonRGVSecond.DeviceCode}ãä»»å¡ã{JsonConvert.SerializeObject(taskSecond)}ã{commonRGVSecond.DeviceCode}è¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(task)}ãã");
			LogAndWarn("æ§è¡è°åº¦ä»»å¡æ§å¶", $"ã{commonRGV.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGV.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãè®¾å¤ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãã{commonRGVSecond.DeviceCode}ãä»»å¡ã{JsonConvert.SerializeObject(taskSecond)}ã{commonRGVSecond.DeviceCode}è¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(task.TaskNum)}ãã");
			Thread.Sleep(1000);

			if (task.Remark != null)
			{
			return GetDispatchExecutingTask(taskSecond);
			}

			return task;
			}
			}
			@@ -324,9 +441,14 @@
			{
			if (task.TaskState == (int)TaskOutStatusEnum.RGV_OutdispatchFinish \|\| task.TaskState == (int)TaskInStatusEnum.RGV_IndispatchFinish)
			{
			if (task.TargetStation > taskSecond.TargetStation)
			if (task.TargetStation - taskSecond.TargetStation > 1)
			{
			LogAndWarn("æ§è¡è°åº¦ä»»å¡æ§å¶", $"ã{commonRGV.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGV.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãè®¾å¤ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãã{commonRGVSecond.DeviceCode}ãä»»å¡ã{JsonConvert.SerializeObject(taskSecond)}ã{commonRGVSecond.DeviceCode}è¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(task)}ãã");
			LogAndWarn("æ§è¡è°åº¦ä»»å¡æ§å¶", $"ã{commonRGV.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGV.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãè®¾å¤ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãã{commonRGVSecond.DeviceCode}ãä»»å¡ã{JsonConvert.SerializeObject(taskSecond)}ã{commonRGVSecond.DeviceCode}è¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(task.TaskNum)}ãã");
			Thread.Sleep(1000);
			if (task.Remark != null)
			{
			return GetDispatchExecutingTask(taskSecond);
			}
			return task;
			}
			}
			@@ -335,7 +457,7 @@
			}
			else
			{
			if (commonRGVSecond.GetValue<RGVDBName, int>(RGVDBName.LevelPoint) > 1000)
			if (commonRGVSecond.GetValue<RGVDBName, int>(RGVDBName.LevelPoint) > 35000)
			{
			RGVTaskCommand command = new RGVTaskCommand()
			{
			@@ -345,7 +467,8 @@
			};
			SendCommand(commonRGVSecond, command);
			}
			LogAndWarn("æ§è¡è°åº¦ä»»å¡æ§å¶", $"ã{commonRGV.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGV.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãè®¾å¤ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãã{commonRGVSecond.DeviceCode}ãä»»å¡ã{JsonConvert.SerializeObject(taskSecond)}ã{commonRGVSecond.DeviceCode}è¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(task)}ãã");
			LogAndWarn("æ§è¡è°åº¦ä»»å¡æ§å¶", $"ã{commonRGV.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGV.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãè®¾å¤ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãã{commonRGVSecond.DeviceCode}ãä»»å¡ã{JsonConvert.SerializeObject(taskSecond)}ã{commonRGVSecond.DeviceCode}è¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(task.TaskNum)}ãã");
			Thread.Sleep(1000);
			return task;
			}
			}
			@@ -357,24 +480,10 @@
			CommonRGV_FirstFloor? commonRGVFirst = Storage.Devices.FirstOrDefault(x => x.DeviceCode == "RGV01") as CommonRGV_FirstFloor;
			if (commonRGVFirst != null)
			{
			if (commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic) && !commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault) && !commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Running) && !commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.InStock))

			if (commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic) && !commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault))
			{
			if (commonRGVFirst.GetValue<RGVDBName, int>(RGVDBName.LevelPoint) > 1000)
			{
			RGVTaskCommand command = new RGVTaskCommand()
			{
			PickupLocation = (byte)Convert.ToSByte(26),
			TaskNum = Convert.ToInt16(1000),
			TaskType = (byte)Convert.ToSByte(1)
			};
			SendCommand(commonRGVFirst, command);
			}
			LogAndWarn("æ§è¡è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVFirst.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGV.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãä½ä¸ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Running)}ãè®¾å¤ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãæ¯å¦æè´§ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.InStock)}ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(task)}ãã");
			return task;
			}
			else if (commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic) && !commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault))
			{
			var taskSecond = _taskRepository.QueryFirst(x => x.RGVName == "RGV01" && x.TaskNum == commonRGVFirst.GetValue<RGVDBName, short>(RGVDBName.RGVTaskNum));
			var taskSecond = _taskRepository.QueryFirst(x => x.RGVName == "RGV01" && x.TaskNum == commonRGVFirst.GetValue<RGVDBName, short>(RGVDBName.RGVTaskNum)&&((x.TaskType==(int)TaskInboundTypeEnum.Inbound&&x.TaskState<230)\|\|(x.TaskType == (int)TaskOutboundTypeEnum.Outbound)));
			if (taskSecond != null)
			{

			@@ -382,9 +491,15 @@
			{
			if (task.TaskState == (int)TaskOutStatusEnum.RGV_OutdispatchFinish \|\| task.TaskState == (int)TaskInStatusEnum.RGV_IndispatchFinish)
			{
			if (task.TargetStation < taskSecond.SourceStation && task.TargetStation < taskSecond.TargetStation)
			if (taskSecond.SourceStation - task.TargetStation > 1 && taskSecond.TargetStation - task.TargetStation > 1)
			{
			LogAndWarn("æ§è¡è°åº¦ä»»å¡æ§å¶", $"ã{commonRGV.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGV.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãè®¾å¤ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãã{commonRGVFirst.DeviceCode}ãä»»å¡ã{JsonConvert.SerializeObject(taskSecond)}ã{commonRGVFirst.DeviceCode}è¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(task)}ãã");
			LogAndWarn("æ§è¡è°åº¦ä»»å¡æ§å¶", $"ã{commonRGV.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGV.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãè®¾å¤ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãã{commonRGVFirst.DeviceCode}ãä»»å¡ã{JsonConvert.SerializeObject(taskSecond)}ã{commonRGVFirst.DeviceCode}è¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(task.TaskNum)}ãã");
			Thread.Sleep(1000);

			if (task.Remark != null)
			{
			return GetDispatchExecutingTask(taskSecond);
			}
			return task;
			}
			}
			@@ -393,9 +508,15 @@
			{
			if (task.TaskState == (int)TaskOutStatusEnum.RGV_OutdispatchFinish \|\| task.TaskState == (int)TaskInStatusEnum.RGV_IndispatchFinish)
			{
			if (task.TargetStation < taskSecond.TargetStation)
			if (taskSecond.TargetStation - task.TargetStation > 1)
			{
			LogAndWarn("æ§è¡è°åº¦ä»»å¡æ§å¶", $"ã{commonRGV.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGV.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãè®¾å¤ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãã{commonRGVFirst.DeviceCode}ãä»»å¡ã{JsonConvert.SerializeObject(taskSecond)}ã{commonRGVFirst.DeviceCode}è¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(task)}ãã");
			LogAndWarn("æ§è¡è°åº¦ä»»å¡æ§å¶", $"ã{commonRGV.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGV.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãè®¾å¤ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãã{commonRGVFirst.DeviceCode}ãä»»å¡ã{JsonConvert.SerializeObject(taskSecond)}ã{commonRGVFirst.DeviceCode}è¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(task.TaskNum)}ãã");
			Thread.Sleep(1000);

			if (task.Remark != null)
			{
			return GetDispatchExecutingTask(taskSecond);
			}
			return task;
			}
			}
			@@ -404,7 +525,7 @@
			}
			else
			{
			if (commonRGVFirst.GetValue<RGVDBName, int>(RGVDBName.LevelPoint) > 1000)
			if (commonRGVFirst.GetValue<RGVDBName, int>(RGVDBName.LevelPoint) < 420000)
			{
			RGVTaskCommand command = new RGVTaskCommand()
			{
			@@ -414,7 +535,8 @@
			};
			SendCommand(commonRGVFirst, command);
			}
			LogAndWarn("æ§è¡è°åº¦ä»»å¡æ§å¶", $"ã{commonRGV.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGV.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãè®¾å¤ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãã{commonRGVFirst.DeviceCode}ãä»»å¡ã{JsonConvert.SerializeObject(taskSecond)}ã{commonRGVFirst.DeviceCode}è¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(task)}ãã");
			LogAndWarn("æ§è¡è°åº¦ä»»å¡æ§å¶", $"ã{commonRGV.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGV.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãè®¾å¤ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãã{commonRGVFirst.DeviceCode}ãä»»å¡ã{JsonConvert.SerializeObject(taskSecond)}ã{commonRGVFirst.DeviceCode}è¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(task.TaskNum)}ãã");
			Thread.Sleep(1000);
			return task;
			}
			}
			@@ -444,57 +566,55 @@
			CommonRGV_FirstFloor? commonRGVSecond = Storage.Devices.FirstOrDefault(x => x.DeviceCode == "RGV02") as CommonRGV_FirstFloor;
			if (commonRGVSecond != null)
			{
			if (commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic) && !commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault) && !commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Running) && !commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.InStock))
			{
			if (commonRGVSecond.GetValue<RGVDBName, int>(RGVDBName.LevelPoint) > 1000)
			{
			RGVTaskCommand command = new RGVTaskCommand()
			{
			PickupLocation = (byte)Convert.ToSByte(15),
			TaskNum = Convert.ToInt16(1000),
			TaskType = (byte)Convert.ToSByte(1)
			};
			SendCommand(commonRGVSecond, command);
			}
			if (tasks.FirstOrDefault(x => x.RGVName == "RGV01") != null)
			{
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVSecond.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGV.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãä½ä¸ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Running)}ãè®¾å¤ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãæ¯å¦æè´§ï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.InStock)}ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV01"))}ãã");
			return tasks.FirstOrDefault(x => x.RGVName == "RGV01");
			}
			else
			{
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVSecond.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGV.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãä½ä¸ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Running)}ãè®¾å¤ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãæ¯å¦æè´§ï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.InStock)}ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName != "RGV02"))}ãã");
			return tasks.FirstOrDefault(x => x.RGVName != "RGV02");
			}
			}
			else if (commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic) && !commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault))
			if (commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic) && !commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault))
			{
			var taskSecond = _taskRepository.QueryFirst(x => x.RGVName == "RGV02" && x.TaskNum == commonRGVSecond.GetValue<RGVDBName, short>(RGVDBName.RGVTaskNum));
			if (taskSecond != null)
			{
			if (taskSecond.TaskState == (int)TaskOutStatusEnum.RGV_Outdispatch \|\| taskSecond.TaskState == (int)TaskOutStatusEnum.RGV_OutdispatchFinish \|\| taskSecond.TaskState == (int)TaskInStatusEnum.RGV_Indispatch \|\| taskSecond.TaskState == (int)TaskInStatusEnum.RGV_InAwaitWMS \|\| taskSecond.TaskState == (int)TaskInStatusEnum.RGV_IndispatchFinish)
			{
			task = tasks.FirstOrDefault(x => x.SourceStation > taskSecond.TargetStation && x.TargetStation > taskSecond.SourceStation && x.SourceStation > taskSecond.SourceStation && x.TargetStation > taskSecond.TargetStation);
			#region
			//if (taskSecond.TaskState == (int)TaskOutStatusEnum.RGV_Outdispatch \|\| taskSecond.TaskState == (int)TaskOutStatusEnum.RGV_OutdispatchFinish \|\| taskSecond.TaskState == (int)TaskInStatusEnum.RGV_IndispatchFinish)
			//{

			// //task = tasks.FirstOrDefault(x =>(x.SourceStation- taskSecond.TargetStation > 1 && x.SourceStation - taskSecond.SourceStation > 1&&x.TaskType==(int)TaskInboundTypeEnum.Inbound) \|\|(x.SourceStation - taskSecond.TargetStation > 1 && x.TargetStation - taskSecond.SourceStation > 1 && x.SourceStation - taskSecond.SourceStation > 1 && x.TargetStation - taskSecond.TargetStation > 1&&x.TaskType== (int)TaskOutboundTypeEnum.Outbound));
			// //if (task == null)
			// //{
			// // task = tasks.FirstOrDefault(x => (x.SourceStation - taskSecond.TargetStation > 1 && x.SourceStation - taskSecond.SourceStation > 1 && x.TaskType == (int)TaskInboundTypeEnum.Inbound) \|\| (x.SourceStation - taskSecond.TargetStation > 1 && x.TargetStation - taskSecond.SourceStation > 1 && x.SourceStation - taskSecond.SourceStation > 1 && x.TargetStation - taskSecond.TargetStation > 1 && x.TaskType == (int)TaskOutboundTypeEnum.Outbound));
			// //}

			LogAndWarn("æ§è¡è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVSecond.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGV.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãè®¾å¤ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãã{commonRGVSecond.DeviceCode}ãä»»å¡ã{JsonConvert.SerializeObject(taskSecond)}ã{commonRGVSecond.DeviceCode}è¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(task)}ãã");
			// task = GetDispatchTask(tasks, taskSecond);

			// LogAndWarn("æ§è¡è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVSecond.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGV.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãè®¾å¤ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãã{commonRGVSecond.DeviceCode}ãä»»å¡ã{JsonConvert.SerializeObject(taskSecond)}ã{commonRGVSecond.DeviceCode}è¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(task.TaskNum)}ãã");

			return task;
			}
			else if (taskSecond.TaskState == (int)TaskOutStatusEnum.RGV_OutExecuting \|\| taskSecond.TaskState == (int)TaskInStatusEnum.RGV_InExecuting)
			{
			task = tasks.FirstOrDefault(x => x.SourceStation > taskSecond.TargetStation && x.TargetStation > taskSecond.TargetStation);
			// Thread.Sleep(1000);
			// return task;
			//}
			//else if (taskSecond.TaskState == (int)TaskOutStatusEnum.RGV_OutExecuting \|\| taskSecond.TaskState == (int)TaskInStatusEnum.RGV_InExecuting)
			//{
			// task = tasks.FirstOrDefault(x => x.SourceStation - taskSecond.TargetStation> 1 &&x.TargetStation - taskSecond.TargetStation > 1);

			LogAndWarn("æ§è¡è°åº¦ä»»å¡æ§å¶", $"ã{commonRGV.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãè®¾å¤ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãã{commonRGVSecond.DeviceCode}ãä»»å¡ã{JsonConvert.SerializeObject(taskSecond)}ã{commonRGVSecond.DeviceCode}è¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(task)}ãã");
			// LogAndWarn("æ§è¡è°åº¦ä»»å¡æ§å¶", $"ã{commonRGV.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãè®¾å¤ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãã{commonRGVSecond.DeviceCode}ãä»»å¡ã{JsonConvert.SerializeObject(taskSecond)}ã{commonRGVSecond.DeviceCode}è¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(task.TaskNum)}ãã");
			// Thread.Sleep(1000);
			// return task;
			//}
			//return null;
			#endregion

			return task;
			}
			return null;
			task = GetDispatchTask(tasks, taskSecond);

			LogAndWarn("æ§è¡è°åº¦ä»»å¡æ§å¶", $"ã{commonRGV.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãè®¾å¤ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãã{commonRGVSecond.DeviceCode}ãä»»å¡ã{JsonConvert.SerializeObject(taskSecond)}ã{commonRGVSecond.DeviceCode}è¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(task.TaskNum)}ãã");
			Thread.Sleep(1000);

			return task;
			}
			else
			{
			if (commonRGVSecond.GetValue<RGVDBName, int>(RGVDBName.LevelPoint) > 1000)
			var taskNews = tasks.Where(x => (x.TaskType == (int)TaskInboundTypeEnum.Inbound && Convert.ToInt32(x.SourceAddress) < 1015) \|\| (x.TaskType == (int)TaskOutboundTypeEnum.Outbound && (x.Roadway == "SC01" \|\| x.Roadway == "SC02" \|\| x.Roadway == "SC03"))\|\|x.RGVName=="RGV01").ToList();
			if (taskNews.Count== 0)
			{
			return null;
			}

			if (commonRGVSecond.GetValue<RGVDBName, int>(RGVDBName.LevelPoint) > 35000)
			{
			RGVTaskCommand command = new RGVTaskCommand()
			{
			@@ -506,13 +626,15 @@
			}
			if (tasks.FirstOrDefault(x => x.RGVName == "RGV01") != null)
			{
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVSecond.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãä½ä¸ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Running)}ãè®¾å¤ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãæ¯å¦æè´§ï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.InStock)}ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV01"))}ãã");
			return tasks.FirstOrDefault(x => x.RGVName == "RGV01");
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVSecond.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãä½ä¸ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Running)}ãè®¾å¤ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãæ¯å¦æè´§ï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.InStock)}ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV01").TaskNum)}ãã");
			Thread.Sleep(1000);
			return taskNews.FirstOrDefault(x => x.RGVName == "RGV01");
			}
			else
			{
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVSecond.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãä½ä¸ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Running)}ãè®¾å¤ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãæ¯å¦æè´§ï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.InStock)}ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName != "RGV02"))}ãã");
			return tasks.FirstOrDefault(x => x.RGVName != "RGV02");
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVSecond.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãä½ä¸ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Running)}ãè®¾å¤ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãæ¯å¦æè´§ï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.InStock)}ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName != "RGV02").TaskNum)}ãã");
			Thread.Sleep(1000);
			return taskNews.FirstOrDefault(x => x.RGVName != "RGV02");
			}
			}
			}
			@@ -520,12 +642,14 @@
			{
			if (tasks.FirstOrDefault(x => x.RGVName == "RGV01") != null)
			{
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVSecond.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãä½ä¸ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Running)}ãè®¾å¤ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãæ¯å¦æè´§ï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.InStock)}ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV01"))}ãã");
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVSecond.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãä½ä¸ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Running)}ãè®¾å¤ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãæ¯å¦æè´§ï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.InStock)}ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV01").TaskNum)}ãã");
			Thread.Sleep(1000);
			return tasks.FirstOrDefault(x => x.RGVName == "RGV01");
			}
			else
			{
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVSecond.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãä½ä¸ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Running)}ãè®¾å¤ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãæ¯å¦æè´§ï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.InStock)}ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName != "RGV02"))}ãã");
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVSecond.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãä½ä¸ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Running)}ãè®¾å¤ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãæ¯å¦æè´§ï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.InStock)}ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName != "RGV02").TaskNum)}ãã");
			Thread.Sleep(1000);
			return tasks.FirstOrDefault(x => x.RGVName != "RGV02");
			}
			}
			@@ -534,12 +658,14 @@
			{
			if (tasks.FirstOrDefault(x => x.RGVName == "RGV01") != null)
			{
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVSecond.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãä½ä¸ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Running)}ãè®¾å¤ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãæ¯å¦æè´§ï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.InStock)}ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV01"))}ãã");
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ãæªæ¾å°RGV02è®¾å¤ä¿¡æ¯ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV01").TaskNum)}ãã");
			Thread.Sleep(1000);
			return tasks.FirstOrDefault(x => x.RGVName == "RGV01");
			}
			else
			{
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVSecond.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãä½ä¸ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Running)}ãè®¾å¤ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãæ¯å¦æè´§ï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.InStock)}ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName != "RGV02"))}ãã");
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ãæªæ¾å°RGV02è®¾å¤ä¿¡æ¯ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName != "RGV02").TaskNum)}ãã");
			Thread.Sleep(1000);
			return tasks.FirstOrDefault(x => x.RGVName != "RGV02");
			}
			}
			@@ -549,61 +675,54 @@
			CommonRGV_FirstFloor? commonRGVFirst = Storage.Devices.FirstOrDefault(x => x.DeviceCode == "RGV01") as CommonRGV_FirstFloor;
			if (commonRGVFirst != null)
			{
			if (commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic) && !commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault) && !commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Running) && !commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.InStock))
			{
			if (commonRGVFirst.GetValue<RGVDBName, int>(RGVDBName.LevelPoint) > 1000)
			{
			RGVTaskCommand command = new RGVTaskCommand()
			{
			PickupLocation = (byte)Convert.ToSByte(26),
			TaskNum = Convert.ToInt16(1000),
			TaskType = (byte)Convert.ToSByte(1)
			};
			SendCommand(commonRGVFirst, command);
			}
			if (tasks.FirstOrDefault(x => x.RGVName == "RGV02") != null)
			{
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVFirst.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãä½ä¸ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Running)}ãè®¾å¤ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãæ¯å¦æè´§ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.InStock)}ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV02"))}ãã");

			return tasks.FirstOrDefault(x => x.RGVName == "RGV02");
			}
			else
			{
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVFirst.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãä½ä¸ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Running)}ãè®¾å¤ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãæ¯å¦æè´§ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.InStock)}ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName != "RGV01"))}ãã");

			return tasks.FirstOrDefault(x => x.RGVName != "RGV01");
			}
			}
			else if (commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic) && !commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault))
			if (commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic) && !commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault))
			{
			var taskFirst = _taskRepository.QueryFirst(x => x.RGVName == "RGV01" && x.TaskNum == commonRGVFirst.GetValue<RGVDBName, short>(RGVDBName.RGVTaskNum));
			if (taskFirst != null)
			{
			if (taskFirst.TaskState == (int)TaskOutStatusEnum.RGV_Outdispatch \|\| taskFirst.TaskState == (int)TaskOutStatusEnum.RGV_OutdispatchFinish \|\| taskFirst.TaskState == (int)TaskInStatusEnum.RGV_Indispatch \|\| taskFirst.TaskState == (int)TaskInStatusEnum.RGV_InAwaitWMS \|\| taskFirst.TaskState == (int)TaskInStatusEnum.RGV_IndispatchFinish)
			{
			task = tasks.FirstOrDefault(x => x.SourceStation < taskFirst.TargetStation && x.TargetStation < taskFirst.SourceStation && x.SourceStation < taskFirst.SourceStation && x.TargetStation < taskFirst.TargetStation);
			#region
			//if (taskFirst.TaskState == (int)TaskOutStatusEnum.RGV_Outdispatch \|\| taskFirst.TaskState == (int)TaskOutStatusEnum.RGV_OutdispatchFinish \|\| taskFirst.TaskState == (int)TaskInStatusEnum.RGV_IndispatchFinish)
			//{

			LogAndWarn("æ§è¡è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVFirst.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãè®¾å¤ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãã{commonRGVFirst.DeviceCode}ãä»»å¡ã{JsonConvert.SerializeObject(taskFirst)}ã{commonRGVFirst.DeviceCode}è¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(task)}ãã");
			// //task = tasks.FirstOrDefault(x => (x.SourceStation - taskFirst.TargetStation > 1 && x.SourceStation - taskFirst.SourceStation > 1 && x.TaskType == (int)TaskInboundTypeEnum.Inbound) \|\| (x.SourceStation - taskFirst.TargetStation > 1 && x.TargetStation - taskFirst.SourceStation > 1 && x.SourceStation - taskFirst.SourceStation > 1 && x.TargetStation - taskFirst.TargetStation > 1 && x.TaskType == (int)TaskOutboundTypeEnum.Outbound));

			return task;
			}
			else if (taskFirst.TaskState == (int)TaskOutStatusEnum.RGV_OutExecuting \|\| taskFirst.TaskState == (int)TaskInStatusEnum.RGV_InExecuting)
			{
			task = tasks.FirstOrDefault(x => x.SourceStation < taskFirst.TargetStation && x.TargetStation < taskFirst.TargetStation);
			// task = GetDispatchTask(tasks, taskFirst);

			LogAndWarn("æ§è¡è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVFirst.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãè®¾å¤ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãã{commonRGVFirst.DeviceCode}ãä»»å¡ã{JsonConvert.SerializeObject(taskFirst)}ã{commonRGVFirst.DeviceCode}è¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(task)}ãã");
			// LogAndWarn("æ§è¡è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVFirst.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãè®¾å¤ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãã{commonRGVFirst.DeviceCode}ãä»»å¡ã{JsonConvert.SerializeObject(taskFirst)}ã{commonRGVFirst.DeviceCode}è¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(task.TaskNum)}ãã");
			// Thread.Sleep(1000);

			return task;
			}
			return null;
			// return task;
			//}
			//else if (taskFirst.TaskState == (int)TaskOutStatusEnum.RGV_OutExecuting \|\| taskFirst.TaskState == (int)TaskInStatusEnum.RGV_InExecuting)
			//{
			// task = tasks.FirstOrDefault(x => taskFirst.TargetStation - x.SourceStation > 1 && taskFirst.TargetStation - x.TargetStation > 1);

			// LogAndWarn("æ§è¡è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVFirst.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãè®¾å¤ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãã{commonRGVFirst.DeviceCode}ãä»»å¡ã{JsonConvert.SerializeObject(taskFirst)}ã{commonRGVFirst.DeviceCode}è¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(task.TaskNum)}ãã");
			// Thread.Sleep(1000);
			// return task;
			//}
			//return null;
			#endregion

			task = GetDispatchTask(tasks, taskFirst);

			LogAndWarn("æ§è¡è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVFirst.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãè®¾å¤ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãã{commonRGVFirst.DeviceCode}ãä»»å¡ã{JsonConvert.SerializeObject(taskFirst)}ã{commonRGVFirst.DeviceCode}è¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(task.TaskNum)}ãã");
			Thread.Sleep(1000);

			return task;
			}
			else
			{
			if (commonRGVFirst.GetValue<RGVDBName, int>(RGVDBName.LevelPoint) > 1000)
			var taskNews = tasks.Where(x => (x.TaskType == (int)TaskInboundTypeEnum.Inbound && Convert.ToInt32(x.SourceAddress) > 1015) \|\| (x.TaskType == (int)TaskOutboundTypeEnum.Outbound && (x.Roadway == "SC04" \|\| x.Roadway == "SC05" \|\| x.Roadway == "SC06"))\|\|x.RGVName=="RGV02").ToList();
			if (taskNews.Count == 0)
			{
			return null;
			}
			if (commonRGVFirst.GetValue<RGVDBName, int>(RGVDBName.LevelPoint) < 420000)
			{
			RGVTaskCommand command = new RGVTaskCommand()
			{
			PickupLocation = (byte)Convert.ToSByte(15),
			PickupLocation = (byte)Convert.ToSByte(26),
			TaskNum = Convert.ToInt16(1000),
			TaskType = (byte)Convert.ToSByte(1)
			};
			@@ -611,14 +730,16 @@
			}
			if (tasks.FirstOrDefault(x => x.RGVName == "RGV02") != null)
			{
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVFirst.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãä½ä¸ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Running)}ãè®¾å¤ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãæ¯å¦æè´§ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.InStock)}ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV02"))}ãã");
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVFirst.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãä½ä¸ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Running)}ãè®¾å¤ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãæ¯å¦æè´§ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.InStock)}ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV02").TaskNum)}ãã");

			Thread.Sleep(1000);
			return tasks.FirstOrDefault(x => x.RGVName == "RGV02");
			}
			else
			{
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVFirst.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãä½ä¸ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Running)}ãè®¾å¤ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãæ¯å¦æè´§ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.InStock)}ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName != "RGV01"))}ãã");
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVFirst.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãä½ä¸ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Running)}ãè®¾å¤ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãæ¯å¦æè´§ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.InStock)}ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName != "RGV01").TaskNum)}ãã");

			Thread.Sleep(1000);
			return tasks.FirstOrDefault(x => x.RGVName != "RGV01");
			}
			}
			@@ -627,14 +748,15 @@
			{
			if (tasks.FirstOrDefault(x => x.RGVName == "RGV02") != null)
			{
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVFirst.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãä½ä¸ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Running)}ãè®¾å¤ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãæ¯å¦æè´§ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.InStock)}ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV02"))}ãã");

			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVFirst.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãä½ä¸ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Running)}ãè®¾å¤ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãæ¯å¦æè´§ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.InStock)}ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV02").TaskNum)}ãã");
			Thread.Sleep(1000);
			return tasks.FirstOrDefault(x => x.RGVName == "RGV02");
			}
			else
			{
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVFirst.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãä½ä¸ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Running)}ãè®¾å¤ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãæ¯å¦æè´§ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.InStock)}ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName != "RGV01"))}ãã");
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVFirst.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãä½ä¸ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Running)}ãè®¾å¤ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãæ¯å¦æè´§ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.InStock)}ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName != "RGV01").TaskNum)}ãã");

			Thread.Sleep(1000);
			return tasks.FirstOrDefault(x => x.RGVName != "RGV01");
			}
			}
			@@ -643,14 +765,16 @@
			{
			if (tasks.FirstOrDefault(x => x.RGVName == "RGV02") != null)
			{
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVFirst.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãä½ä¸ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Running)}ãè®¾å¤ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãæ¯å¦æè´§ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.InStock)}ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV02"))}ãã");
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ãæªæ¾å°RGV01è®¾å¤ä¿¡æ¯ã è¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV02").TaskNum)}ãã");

			Thread.Sleep(1000);
			return tasks.FirstOrDefault(x => x.RGVName == "RGV02");
			}
			else
			{
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVFirst.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãä½ä¸ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Running)}ãè®¾å¤ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãæ¯å¦æè´§ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.InStock)}ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName != "RGV01"))}ãã");
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ãæªæ¾å°RGV01è®¾å¤ä¿¡æ¯ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName != "RGV01").TaskNum)}ãã");

			Thread.Sleep(1000);
			return tasks.FirstOrDefault(x => x.RGVName != "RGV01");
			}
			}
			@@ -659,6 +783,171 @@
			catch (Exception ex)
			{
			WriteInfo("è°åº¦ä»»å¡å¼å¸¸æ¥å¿", ex.Message+Environment.NewLine+ex.StackTrace);
			return null;
			}
			}

			public Dt_Task GetTransFerTask(CommonRGV_FirstFloor commonRGV)
			{
			try
			{
			var tasks = _taskRepository.QueryData(x=>x.TaskState==(int)TaskInStatusEnum.RGV_TransFerFInish\|\| x.TaskState == (int)TaskOutStatusEnum.RGV_TransFerFInish);
			Dt_Task task;
			if (tasks.Count() == 0)
			{
			return null;
			}
			if (commonRGV.DeviceCode == "RGV01")
			{
			CommonRGV_FirstFloor? commonRGVSecond = Storage.Devices.FirstOrDefault(x => x.DeviceCode == "RGV02") as CommonRGV_FirstFloor;
			if (commonRGVSecond != null)
			{
			if (commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic) && !commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault))
			{
			var taskSecond = _taskRepository.QueryFirst(x => x.RGVName == "RGV02" && x.TaskNum == commonRGVSecond.GetValue<RGVDBName, short>(RGVDBName.RGVTaskNum));
			if (taskSecond != null)
			{
			if (taskSecond.TaskState == (int)TaskOutStatusEnum.RGV_Outdispatch \|\| taskSecond.TaskState == (int)TaskOutStatusEnum.RGV_OutdispatchFinish \|\| taskSecond.TaskState == (int)TaskInStatusEnum.RGV_IndispatchFinish)
			{
			task = tasks.FirstOrDefault(x => ((x.SourceStation - taskSecond.TargetStation > 1 && x.SourceStation - taskSecond.SourceStation > 1 && x.TaskType == (int)TaskInboundTypeEnum.Inbound) \|\| (x.SourceStation - taskSecond.TargetStation > 1 && x.TargetStation - taskSecond.SourceStation > 1 && x.SourceStation - taskSecond.SourceStation > 1 && x.TargetStation - taskSecond.TargetStation > 1 && x.TaskType == (int)TaskOutboundTypeEnum.Outbound))&&x.RGVName=="RGV01");


			LogAndWarn("æ§è¡è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVSecond.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGV.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãè®¾å¤ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãã{commonRGVSecond.DeviceCode}ãä»»å¡ã{JsonConvert.SerializeObject(taskSecond)}ã{commonRGVSecond.DeviceCode}è¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(task.TaskNum)}ãã");

			Thread.Sleep(1000);
			return task;
			}
			else if (taskSecond.TaskState == (int)TaskOutStatusEnum.RGV_OutExecuting \|\| taskSecond.TaskState == (int)TaskInStatusEnum.RGV_InExecuting)
			{
			task = tasks.FirstOrDefault(x => x.SourceStation - taskSecond.TargetStation > 1 && x.TargetStation - taskSecond.TargetStation > 1 && x.RGVName == "RGV01");

			LogAndWarn("æ§è¡è°åº¦ä»»å¡æ§å¶", $"ã{commonRGV.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãè®¾å¤ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãã{commonRGVSecond.DeviceCode}ãä»»å¡ã{JsonConvert.SerializeObject(taskSecond)}ã{commonRGVSecond.DeviceCode}è¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(task.TaskNum)}ãã");
			Thread.Sleep(1000);
			return task;
			}
			return null;
			}
			else
			{
			if (commonRGVSecond.GetValue<RGVDBName, int>(RGVDBName.LevelPoint) > 35000)
			{
			RGVTaskCommand command = new RGVTaskCommand()
			{
			PickupLocation = (byte)Convert.ToSByte(15),
			TaskNum = Convert.ToInt16(1000),
			TaskType = (byte)Convert.ToSByte(1)
			};
			SendCommand(commonRGVSecond, command);
			}
			if (tasks.FirstOrDefault(x => x.RGVName == "RGV01") != null)
			{
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVSecond.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãä½ä¸ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Running)}ãè®¾å¤ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãæ¯å¦æè´§ï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.InStock)}ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV01").TaskNum)}ãã");
			Thread.Sleep(1000);
			return tasks.FirstOrDefault(x => x.RGVName == "RGV01");
			}
			}
			}
			else
			{
			if (tasks.FirstOrDefault(x => x.RGVName == "RGV01") != null)
			{
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVSecond.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãä½ä¸ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Running)}ãè®¾å¤ç¶æï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãæ¯å¦æè´§ï¼ã{commonRGVSecond.GetValue<RGVDBName, bool>(RGVDBName.InStock)}ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV01").TaskNum)}ãã");
			Thread.Sleep(1000);
			return tasks.FirstOrDefault(x => x.RGVName == "RGV01");
			}

			}
			}
			else
			{
			if (tasks.FirstOrDefault(x => x.RGVName == "RGV01") != null)
			{
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ãæªæ¾å°RGV02è®¾å¤ä¿¡æ¯ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV01").TaskNum)}ãã");
			Thread.Sleep(1000);
			return tasks.FirstOrDefault(x => x.RGVName == "RGV01");
			}
			}
			return null;
			}
			else
			{
			CommonRGV_FirstFloor? commonRGVFirst = Storage.Devices.FirstOrDefault(x => x.DeviceCode == "RGV01") as CommonRGV_FirstFloor;
			if (commonRGVFirst != null)
			{
			if (commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic) && !commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault))
			{
			var taskFirst = _taskRepository.QueryFirst(x => x.RGVName == "RGV01" && x.TaskNum == commonRGVFirst.GetValue<RGVDBName, short>(RGVDBName.RGVTaskNum));
			if (taskFirst != null)
			{
			if (taskFirst.TaskState == (int)TaskOutStatusEnum.RGV_Outdispatch \|\| taskFirst.TaskState == (int)TaskOutStatusEnum.RGV_OutdispatchFinish \|\| taskFirst.TaskState == (int)TaskInStatusEnum.RGV_IndispatchFinish)
			{

			task = tasks.FirstOrDefault(x => ((x.SourceStation - taskFirst.TargetStation > 1 && x.SourceStation - taskFirst.SourceStation > 1 && x.TaskType == (int)TaskInboundTypeEnum.Inbound) \|\| (x.SourceStation - taskFirst.TargetStation > 1 && x.TargetStation - taskFirst.SourceStation > 1 && x.SourceStation - taskFirst.SourceStation > 1 && x.TargetStation - taskFirst.TargetStation > 1 && x.TaskType == (int)TaskOutboundTypeEnum.Outbound))&&x.RGVName=="RGV02");

			task = GetDispatchTask(tasks, taskFirst);

			LogAndWarn("æ§è¡è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVFirst.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãè®¾å¤ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãã{commonRGVFirst.DeviceCode}ãä»»å¡ã{JsonConvert.SerializeObject(taskFirst)}ã{commonRGVFirst.DeviceCode}è¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(task.TaskNum)}ãã");
			Thread.Sleep(1000);

			return task;
			}
			else if (taskFirst.TaskState == (int)TaskOutStatusEnum.RGV_OutExecuting \|\| taskFirst.TaskState == (int)TaskInStatusEnum.RGV_InExecuting)
			{
			task = tasks.FirstOrDefault(x => taskFirst.TargetStation - x.SourceStation > 1 && taskFirst.TargetStation - x.TargetStation > 1 && x.RGVName == "RGV02");

			LogAndWarn("æ§è¡è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVFirst.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãè®¾å¤ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãã{commonRGVFirst.DeviceCode}ãä»»å¡ã{JsonConvert.SerializeObject(taskFirst)}ã{commonRGVFirst.DeviceCode}è¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(task.TaskNum)}ãã");
			Thread.Sleep(1000);
			return task;
			}
			return null;
			}
			else
			{
			if (commonRGVFirst.GetValue<RGVDBName, int>(RGVDBName.LevelPoint) < 420000)
			{
			RGVTaskCommand command = new RGVTaskCommand()
			{
			PickupLocation = (byte)Convert.ToSByte(26),
			TaskNum = Convert.ToInt16(1000),
			TaskType = (byte)Convert.ToSByte(1)
			};
			SendCommand(commonRGVFirst, command);
			}
			if (tasks.FirstOrDefault(x => x.RGVName == "RGV02") != null)
			{
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVFirst.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãä½ä¸ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Running)}ãè®¾å¤ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãæ¯å¦æè´§ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.InStock)}ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV02").TaskNum)}ãã");

			Thread.Sleep(1000);
			return tasks.FirstOrDefault(x => x.RGVName == "RGV02");
			}
			}
			}
			else
			{
			if (tasks.FirstOrDefault(x => x.RGVName == "RGV02") != null)
			{
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ã{commonRGVFirst.DeviceCode}å·¥ä½æ¨¡å¼ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Automatic)}ãä½ä¸ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Running)}ãè®¾å¤ç¶æï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.Fault)}ãæ¯å¦æè´§ï¼ã{commonRGVFirst.GetValue<RGVDBName, bool>(RGVDBName.InStock)}ãè¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV02").TaskNum)}ãã");
			Thread.Sleep(1000);
			return tasks.FirstOrDefault(x => x.RGVName == "RGV02");
			}
			}
			}
			else
			{
			if (tasks.FirstOrDefault(x => x.RGVName == "RGV02") != null)
			{
			LogAndWarn("è°åº¦ä»»å¡æ§å¶", $"ãæªæ¾å°RGV01è®¾å¤ä¿¡æ¯ã è¿åä»»å¡ï¼ã{JsonConvert.SerializeObject(tasks.FirstOrDefault(x => x.RGVName == "RGV02").TaskNum)}ãã");

			Thread.Sleep(1000);
			return tasks.FirstOrDefault(x => x.RGVName == "RGV02");
			}
			}
			return null;
			}
			}
			catch (Exception ex)
			{
			WriteInfo("è°åº¦ä»»å¡å¼å¸¸æ¥å¿", ex.Message + Environment.NewLine + ex.StackTrace);
			return null;
			}
			}
			@@ -672,24 +961,10 @@
			{
			if (commonRGV != null)
			{
			WriteInfo("RGVä»»å¡å®æ", $"{commonRGV.DeviceName}å®æä»»å¡å·{TaskNum}");
			var task = _taskRepository.QueryFirst(x => x.TaskNum == TaskNum);
			if (task != null)
			{
			if (task.TaskState == (int)TaskInStatusEnum.InRetuen)
			{
			Dt_StationManager stationManager = _stationManagerRepository.QueryFirst(x => x.stationChildCode == task.SourceAddress);
			if (stationManager != null)
			{
			IDevice? device = Storage.Devices.FirstOrDefault(x => x.DeviceCode == stationManager.stationPLC);
			if (device != null)
			{
			CommonConveyorLine conveyorLine = (CommonConveyorLine)device;
			commonRGV.SetValue(StackerCraneDBName.TaskType, Convert.ToSByte(4));

			var content = _taskService.RGVTaskCompleted(TaskNum);
			}
			}
			}
			if (task.TaskState == (int)TaskInStatusEnum.RGV_Indispatch)
			{
			Dt_StationManager stationManager = _stationManagerRepository.QueryFirst(x => x.stationChildCode == task.SourceAddress);
			@@ -701,16 +976,26 @@
			CommonConveyorLine conveyorLine = (CommonConveyorLine)device;
			Thread.Sleep(100);
			DeviceProDTO? devicePro = conveyorLine.DeviceProDTOs.Where(x => x.DeviceChildCode == stationManager.stationChildCode && x.DeviceProParamName == "ConveyorLineBarcode").FirstOrDefault();
			var x = conveyorLine.Communicator.Read(devicePro.DeviceProAddress, 5);

			var x = conveyorLine.Communicator.Read(devicePro.DeviceProAddress, 10);

			string Barcode = Encoding.UTF8.GetString(x);

			if (Barcode == null \|\| Barcode == "")
			if (Barcode == null \|\| Barcode == "" \|\| Barcode.Trim().Contains("\0"))
			{
			conveyorLine.SetValue(ConveyorLineDBName.WriteInteractiveSignal, Convert.ToSByte(3), stationManager.stationChildCode);
			commonRGV.SetValue(StackerCraneDBName.PutcargoLocation, Convert.ToSByte(stationManager.stationRemark));
			commonRGV.SetValue(StackerCraneDBName.TaskNum, Convert.ToInt16(task.TaskNum));
			task.TaskState = (int)TaskInStatusEnum.InRetuen;
			_taskRepository.UpdateData(task);
			commonRGV.SetValue(StackerCraneDBName.TaskType, Convert.ToSByte(4));

			task.ModifyDate = DateTime.Now;
			task.Modifier = "System";

			Dt_Task_Hty task_Hty = _mapper.Map<Dt_Task_Hty>(task);
			task_Hty.TaskId = 0;
			task_Hty.OperateType = (int)OperateTypeEnum.å¼å¸¸éå;

			_taskRepository.DeleteData(task);
			_task_HtyRepository.AddData(task_Hty);
			return;
			}
			var content = _taskService.RGVTaskCompleted(TaskNum, Barcode);
			@@ -729,7 +1014,6 @@
			{
			CommonConveyorLine conveyorLine = (CommonConveyorLine)device;
			Thread.Sleep(100);
			var Barcode = conveyorLine.GetValue<ConveyorLineDBName, string>(ConveyorLineDBName.ConveyorLineBarcode, stationManager.stationChildCode);
			conveyorLine.SetValue(ConveyorLineDBName.ConveyorLineTargetAddress, Convert.ToInt16(stationManager.stationNextChildCode), stationManager.stationChildCode);
			Thread.Sleep(100);
			conveyorLine.SetValue(ConveyorLineDBName.ConveyorLineTaskNum, Convert.ToInt16(1000), stationManager.stationChildCode);
			@@ -753,47 +1037,97 @@
			{
			if (InStock)
			{
			return _taskService.QueryRGVExecutingTask(commonRGV.DeviceCode, commonRGV.GetValue<RGVDBName, short>(RGVDBName.RGVTaskNum));
			return _taskService.QueryRGVExecutingTask(commonRGV.DeviceCode);
			}
			return null;
			}

			#region
			//if (commonRGV.LastTaskType == null)
			//{
			// task = _taskService.QueryRGVTask(commonRGV.DeviceCode);
			//}
			//else
			//{
			// if (commonRGV.LastTaskType.GetValueOrDefault().GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup)
			// {
			// task = _taskService.QueryRGVInTask(commonRGV.DeviceCode);
			// if (task == null)
			// {
			// task = _taskService.QueryRGVOutTask(commonRGV.DeviceCode);
			// }
			// }
			// else
			// {
			// task = _taskService.QueryRGVOutTask(commonRGV.DeviceCode);
			// }
			//}
			public Dt_Task? GetDispatchTask(List<Dt_Task> tasks, Dt_Task oldtask)
			{
			Dt_Task y = tasks.Where(x => x.Remark != null && ((x.SourceStation - oldtask.TargetStation > 1 && x.SourceStation - oldtask.SourceStation > 1 && x.TaskType == (int)TaskInboundTypeEnum.Inbound) \|\| (x.SourceStation - oldtask.TargetStation > 1 && x.TargetStation - oldtask.SourceStation > 1 && x.SourceStation - oldtask.SourceStation > 1 && x.TargetStation - oldtask.TargetStation > 1 && x.TaskType == (int)TaskOutboundTypeEnum.Outbound))).First();
			if (y == null)
			{
			if (oldtask.TaskState == (int)TaskOutStatusEnum.RGV_Outdispatch \|\| oldtask.TaskState == (int)TaskOutStatusEnum.RGV_OutdispatchFinish \|\| oldtask.TaskState == (int)TaskInStatusEnum.RGV_IndispatchFinish)
			{

			//if (task != null && task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup)
			//{
			// if (task == null)
			// {
			// task = _taskService.QueryRGVInTask(commonRGV.DeviceCode);
			// }
			// else
			// {
			// return task;
			// }
			//}
			//else if (task == null)
			//{
			// task = _taskService.QueryRGVInTask(commonRGV.DeviceCode);
			//}
			#endregion
			return tasks.FirstOrDefault(x => (x.SourceStation - oldtask.TargetStation > 1 && x.SourceStation - oldtask.SourceStation > 1 && x.TaskType == (int)TaskInboundTypeEnum.Inbound) \|\| (x.SourceStation - oldtask.TargetStation > 1 && x.TargetStation - oldtask.SourceStation > 1 && x.SourceStation - oldtask.SourceStation > 1 && x.TargetStation - oldtask.TargetStation > 1 && x.TaskType == (int)TaskOutboundTypeEnum.Outbound));
			}
			else if (oldtask.TaskState == (int)TaskOutStatusEnum.RGV_OutExecuting \|\| oldtask.TaskState == (int)TaskInStatusEnum.RGV_InExecuting)
			{
			return tasks.FirstOrDefault(x => x.SourceStation - oldtask.TargetStation > 1 && x.TargetStation - oldtask.TargetStation > 1);
			}
			return null;
			}
			else
			{
			IDevice? device = Storage.Devices.FirstOrDefault(x => x.DeviceCode == "1001");
			if (device != null)
			{
			CommonConveyorLine conveyorLine = (CommonConveyorLine)device;
			var stationManager = _stationManagerRepository.QueryData(x => x.stationType == 15);
			if (stationManager.Count() > 0)
			{
			string next = null;
			foreach (var item in stationManager)
			{
			short x = conveyorLine.GetValue<ConveyorLineDBName, short>(ConveyorLineDBName.InteractiveSignal, item.stationChildCode);
			var structs = BitConverter.GetBytes(x).ToArray().ToBoolArray();
			if (structs[2])
			{
			next = item.stationChildCode;
			break;
			}
			}
			if (next != null)
			{
			oldtask.Remark = next;
			_taskRepository.UpdateData(y);
			return y;
			}
			}
			}
			if (oldtask.TaskState == (int)TaskOutStatusEnum.RGV_Outdispatch \|\| oldtask.TaskState == (int)TaskOutStatusEnum.RGV_OutdispatchFinish \|\| oldtask.TaskState == (int)TaskInStatusEnum.RGV_IndispatchFinish)
			{

			return tasks.FirstOrDefault(x => (x.SourceStation - oldtask.TargetStation > 1 && x.SourceStation - oldtask.SourceStation > 1 && x.TaskType == (int)TaskInboundTypeEnum.Inbound) \|\| (x.SourceStation - oldtask.TargetStation > 1 && x.TargetStation - oldtask.SourceStation > 1 && x.SourceStation - oldtask.SourceStation > 1 && x.TargetStation - oldtask.TargetStation > 1 && x.TaskType == (int)TaskOutboundTypeEnum.Outbound));
			}
			else if (oldtask.TaskState == (int)TaskOutStatusEnum.RGV_OutExecuting \|\| oldtask.TaskState == (int)TaskInStatusEnum.RGV_InExecuting)
			{
			return tasks.FirstOrDefault(x => x.SourceStation - oldtask.TargetStation > 1 && x.TargetStation - oldtask.TargetStation > 1);
			}
			return null;
			}
			}

			public Dt_Task? GetDispatchExecutingTask(Dt_Task oldtask)
			{
			IDevice? device = Storage.Devices.FirstOrDefault(x => x.DeviceCode == "1001");
			if (device != null)
			{
			CommonConveyorLine conveyorLine = (CommonConveyorLine)device;
			var stationManager = _stationManagerRepository.QueryData(x => x.stationType == 15);
			if (stationManager.Count() > 0)
			{
			string next = null;
			foreach (var item in stationManager)
			{
			short x = conveyorLine.GetValue<ConveyorLineDBName, short>(ConveyorLineDBName.InteractiveSignal, item.stationChildCode);
			var structs = BitConverter.GetBytes(x).ToArray().ToBoolArray();
			if (structs[2])
			{
			next = item.stationChildCode;
			break;
			}
			}
			if (next != null)
			{
			oldtask.Remark = next;
			_taskRepository.UpdateData(oldtask);
			return oldtask;
			}
			}
			}
			return null;
			}

			/// <summary>
			@@ -809,23 +1143,37 @@
			rgvTaskCommand.TaskNum = Convert.ToInt16(task.TaskNum);
			if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.InboundGroup)//å¤ææ¯å¦æ¯å¥åºä»»å¡
			{
			//rgvTaskCommand.TaskType = (byte)Convert.ToSByte(16);
			//rgvTaskCommand.TaskType = (byte)Convert.ToSByte(64); éå
			if (task.TaskState == (int)TaskInStatusEnum.InNew)
			{
			Dt_StationManager stationManager = _stationManagerRepository.QueryFirst(x => x.stationChildCode == task.SourceAddress);
			rgvTaskCommand.TaskType = (byte)Convert.ToSByte(3);
			rgvTaskCommand.PickupLocation = (byte)Convert.ToSByte(stationManager.stationRemark);
			}
			else if (task.TaskState == (int)TaskInStatusEnum.RGV_TransFerFInish)
			{
			Dt_StationManager stationManagerStart = _stationManagerRepository.QueryFirst(x => x.stationChildCode == task.CurrentAddress);
			Dt_StationManager stationManagerEnd = _stationManagerRepository.QueryFirst(x => x.stationChildCode == task.NextAddress);
			rgvTaskCommand.TaskType = (byte)Convert.ToSByte(5);
			rgvTaskCommand.PickupLocation = (byte)Convert.ToSByte(stationManagerStart.stationRemark);
			rgvTaskCommand.PutcargoLocation = (byte)Convert.ToSByte(stationManagerEnd.stationRemark);
			}
			else if (task.TaskState == (int)TaskInStatusEnum.RGV_IndispatchFinish)
			{
			Dt_StationManager stationManager = _stationManagerRepository.QueryFirst(x => x.stationChildCode == task.NextAddress);
			rgvTaskCommand.TaskType = (byte)Convert.ToSByte(4);
			rgvTaskCommand.PutcargoLocation = (byte)Convert.ToSByte(stationManager.stationRemark);
			if (task.Remark != null && (task.Roadway == "SC01" \|\| task.Roadway == "SC06"))
			{
			Dt_StationManager stationManager = _stationManagerRepository.QueryFirst(x => x.stationChildCode == task.Remark);
			rgvTaskCommand.TaskType = (byte)Convert.ToSByte(4);
			rgvTaskCommand.PutcargoLocation = (byte)Convert.ToSByte(stationManager.stationRemark);
			}
			else
			{
			Dt_StationManager stationManager = _stationManagerRepository.QueryFirst(x => x.stationChildCode == task.NextAddress);
			rgvTaskCommand.TaskType = (byte)Convert.ToSByte(4);
			rgvTaskCommand.PutcargoLocation = (byte)Convert.ToSByte(stationManager.stationRemark);
			}
			}
			else
			{
			_taskService.UpdateTaskExceptionMessage(task.TaskNum, $"æªæ¾å°ç«å°ã{task.NextAddress}ãä¿¡æ¯ï¼æ æ³è·åå¯¹åºçå åæºåè´§ç«å°ä¿¡æ¯");
			return null;
			}
			}
			@@ -834,9 +1182,28 @@

			if (task.TaskState == (int)TaskOutStatusEnum.Line_OutFinish)
			{
			Dt_StationManager stationManager = _stationManagerRepository.QueryFirst(x => x.stationChildCode == task.CurrentAddress);
			rgvTaskCommand.TaskType = (byte)Convert.ToSByte(3);
			rgvTaskCommand.PickupLocation = (byte)Convert.ToSByte(stationManager.stationRemark);
			if (task.Remark != null && (task.Roadway == "SC01" \|\| task.Roadway == "SC06"))
			{
			Dt_StationManager stationManagerStart = _stationManagerRepository.QueryFirst(x => x.stationChildCode == task.CurrentAddress);
			Dt_StationManager stationManagerEnd = _stationManagerRepository.QueryFirst(x => x.stationChildCode == task.Remark);
			rgvTaskCommand.TaskType = (byte)Convert.ToSByte(5);
			rgvTaskCommand.PickupLocation = (byte)Convert.ToSByte(stationManagerStart.stationRemark);
			rgvTaskCommand.PutcargoLocation = (byte)Convert.ToSByte(stationManagerEnd.stationRemark);
			}
			else
			{
			Dt_StationManager stationManager = _stationManagerRepository.QueryFirst(x => x.stationChildCode == task.CurrentAddress);
			rgvTaskCommand.TaskType = (byte)Convert.ToSByte(3);
			rgvTaskCommand.PickupLocation = (byte)Convert.ToSByte(stationManager.stationRemark);
			}
			}
			else if (task.TaskState == (int)TaskOutStatusEnum.RGV_TransFerFInish)
			{
			Dt_StationManager stationManagerStart = _stationManagerRepository.QueryFirst(x => x.stationChildCode == task.CurrentAddress);
			Dt_StationManager stationManagerEnd = _stationManagerRepository.QueryFirst(x => x.stationChildCode == task.NextAddress);
			rgvTaskCommand.TaskType = (byte)Convert.ToSByte(5);
			rgvTaskCommand.PickupLocation = (byte)Convert.ToSByte(stationManagerStart.stationRemark);
			rgvTaskCommand.PutcargoLocation = (byte)Convert.ToSByte(stationManagerEnd.stationRemark);
			}
			else if (task.TaskState == (int)TaskOutStatusEnum.RGV_OutdispatchFinish)
			{
			@@ -846,7 +1213,6 @@
			}
			else
			{
			_taskService.UpdateTaskExceptionMessage(task.TaskNum, $"æªæ¾å°ç«å°ã{task.NextAddress}ãä¿¡æ¯ï¼æ æ³è·åå¯¹åºçå åæºåè´§ç«å°ä¿¡æ¯");
			return null;
			}
			}