M071.git - Gitblit

			@@ -6,25 +6,24 @@
			using System.Collections.Concurrent;
			using System.Collections.Generic;
			using System.Collections.ObjectModel;
			using System.Diagnostics;
			using System.Drawing;
			using System.IO;
			using System.Linq;
			using System.Text;
			using System.Threading;
			using System.Threading.Tasks;
			using static Bro.Common.Helper.EnumHelper;

			namespace Bro.Device.GTSCard
			{
			[Device("GTSCard", "固高板卡", EnumHelper.DeviceAttributeType.Device)]
			public class GTSCardDriver : DeviceBase, IMonitor, IMotion
			public class GTSCardDriver : MotionCardBase
			{
			public event Action<DateTime, string, IDevice, MonitorSet> OnMonitorInvoke;
			public event Action<DateTime, IDevice, WarningSet> OnMonitorAlarm;

			public delegate bool OnAxisStartToCheckDelegate(int axisIndex, int startPosition, int endPosition);
			// 异常事件
			public Action<Exception> OnExceptionRaised;

			public GTSCardInitialConfig IConfig
			public GTSCardInitialConfig IIConfig
			{
			get
			{
			@@ -32,31 +31,7 @@
			}
			}

			static Dictionary<int, object> axisMoveLockDict = new Dictionary<int, object>();

			/// <summary>
			/// 轴运动开始时的检测，true:有冲突不可继续执行 false：无冲突,可继续执行
			/// </summary>
			public event OnAxisStartToCheckDelegate OnAxisStartToCheckConfliction;
			/// <summary>
			/// 暂停（线程同步事件）
			/// </summary>
			Dictionary<int, ManualResetEvent> axisImmediatePauseHandleDict = new Dictionary<int, ManualResetEvent>();
			Dictionary<int, CancellationTokenSource> axisMoveCancelDict = new Dictionary<int, CancellationTokenSource>();
			/// <summary>
			/// 运行过程中的线程等待
			/// </summary>
			private Dictionary<int, ManualResetEvent> runningEventDic = new Dictionary<int, ManualResetEvent>();
			private Dictionary<int, AutoResetEvent> axisMovingHandleDict = new Dictionary<int, AutoResetEvent>();
			private ConcurrentDictionary<int, int> axisDestination = new ConcurrentDictionary<int, int>();

			private ObservableCollection<int> _commandAxisList = new ObservableCollection<int>();
			public Action<bool> CommandAxisCountChangedAction = null;
			private Dictionary<int, VelocityPara> velIndexDict = new Dictionary<int, VelocityPara>();
			ManualResetEvent _pauseHandle = new ManualResetEvent(true);

			static object lockObj = new object();
			static object _commandAxisLock = new object();
			static object moveLock = new object();
			/// <summary>
			/// 是否复位标志
			/// </summary>
			@@ -67,7 +42,7 @@
			_isResetting = isReset;
			}

			public List<AxisInfo> GetCurrentAxisInfo(params string[] axisName)
			public override List<AxisInfo> GetCurrentAxisInfo(params string[] axisName)
			{
			throw new NotImplementedException();
			}
			@@ -76,26 +51,7 @@

			protected override void Init()
			{
			InitialMotionCard((short)IConfig.CardNum, IConfig.InitialConfigFilePath);

			axisMoveLockDict = IConfig.AxisSettings.ToDictionary(a => a.AxisIndex, a => new object());
			runningEventDic = IConfig.AxisSettings.ToDictionary(a => a.AxisIndex, a => new ManualResetEvent(false));
			axisMovingHandleDict = IConfig.AxisSettings.ToDictionary(a => a.AxisIndex, a => new AutoResetEvent(true));
			axisImmediatePauseHandleDict = IConfig.AxisSettings.ToDictionary(a => a.AxisIndex, a => new ManualResetEvent(true));
			axisMoveCancelDict = IConfig.AxisSettings.ToDictionary(a => a.AxisIndex, a => new CancellationTokenSource());

			axisMoveCancelDict.Values.ToList().ForEach(c =>
			{
			c = new CancellationTokenSource();
			});

			_commandAxisList.CollectionChanged -= CommandAxisList_CollectionChanged;
			_commandAxisList.CollectionChanged += CommandAxisList_CollectionChanged;
			}

			private void CommandAxisList_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
			{
			CommandAxisCountChangedAction?.Invoke(_commandAxisList.Count > 0);
			InitialMotionCard();
			}

			protected override void Pause()
			@@ -110,239 +66,385 @@

			protected override void Start()
			{
			throw new NotImplementedException();
			AllAxisOn();
			}

			protected override void Stop()
			{
			throw new NotImplementedException();
			AllMoveStop();
			AllAxisOff();
			}

			/// <summary>
			/// 设备运行（执行板卡系列的操作的集合）
			/// </summary>
			/// <param name="config"></param>
			/// <returns></returns>
			public override ResponseMessage Run(IOperationConfig config)
			{
			ResponseMessage responseMessage = new ResponseMessage();
			var motionCardOperationConfig = config as MotionCardOperationConfigBase;
			foreach (var operationSet in motionCardOperationConfig.OperationCollection)
			{
			responseMessage = RunOperationSet(operationSet);
			if (!responseMessage.Result)
			{
			return responseMessage;
			}
			}
			return responseMessage;
			}

			/// <summary>
			/// 执行一个系列的操作
			/// </summary>
			private ResponseMessage RunOperationSet(MotionCardOperationSet operationSet)
			{
			ResponseMessage responseMessage = new ResponseMessage();
			// 1.预检查
			if (CurrentState == DeviceState.DSOpen)
			{
			foreach (var preCheck in operationSet.PreCheckIOCollection)
			{
			int timeout = operationSet.PreCheckIOTimeout;
			IOValue? ioData = null;
			while (CurrentState == DeviceState.DSOpen)
			{
			Thread.Sleep(10);
			ioData = MonitorValues.FirstOrDefault(u => u.IONum == preCheck.IOItem.IONum && u.IOType == preCheck.IOItem.IOType)?.Value;//IO 是开、关从MonitorValues 获取
			timeout -= 10;
			if (preCheck.CheckValue == ioData \|\| (operationSet.PreCheckIOTimeout > 0 && timeout < 0))
			{
			break;
			}
			}

			if (preCheck.CheckValue != ioData)
			{
			responseMessage.Result = false;
			responseMessage.Message = $"预检查不通过，配置：{preCheck.GetDisplayText()}，当前值：{ioData}";
			return responseMessage;
			}
			}
			}

			// 2.板卡运动
			if (CurrentState == DeviceState.DSOpen)
			{
			responseMessage = MoveToPoint(operationSet.MotionOperationCollection);
			if (!responseMessage.Result)
			{
			return responseMessage;
			}
			}


			// 3.IO输出不需要超时
			if (CurrentState == DeviceState.DSOpen)
			{
			foreach (var ioOutput in operationSet.IOOutputCollection)
			{
			var ioData = MonitorValues.FirstOrDefault(u => u.IONum == ioOutput.IOItem.IONum && u.IOType == ioOutput.IOItem.IOType)?.Value;//IO 是开、关从MonitorValues 获取
			if (ioOutput.CheckValue != ioData)
			{
			responseMessage.Result = false;
			responseMessage.Message = $"IO输出不通过，配置：{ioOutput.GetDisplayText()}，当前值：{ioData}";
			return responseMessage;
			}
			}
			}

			// 4.IO确认
			if (CurrentState == DeviceState.DSOpen)
			{
			foreach (var ioConfirm in operationSet.IOConfirmCollection)
			{
			int timeout = operationSet.IOConfirmTimeout;
			IOValue? ioData = null;
			while (CurrentState == DeviceState.DSOpen)
			{
			Thread.Sleep(10);
			ioData = MonitorValues.FirstOrDefault(u => u.IONum == ioConfirm.IOItem.IONum && u.IOType == ioConfirm.IOItem.IOType)?.Value;//IO 是开、关从MonitorValues 获取
			timeout -= 10;
			if (ioConfirm.CheckValue == ioData \|\| (operationSet.IOConfirmTimeout > 0 && timeout < 0))
			{
			break;
			}
			}

			if (ioConfirm.CheckValue != ioData)
			{
			responseMessage.Result = false;
			responseMessage.Message = $"IO确认不通过，配置：{ioConfirm.GetDisplayText()}，当前值：{ioData}";
			return responseMessage;
			}
			}
			}

			return responseMessage;
			}
			#endregion

			#region GTSCard

			public void ClearPosition(short cardNum, short axisNum)
			{
			int ret = GTSCardAPI.GT_SetPos(cardNum, axisNum, 0);
			}

			/// <summary>
			/// Load Motion Card parameter from file
			/// </summary>
			/// <param name="fileName">Invalid Parameter</param>
			/// <returns></returns>
			public void InitialMotionCard(short cardNum, string fileName)
			public void InitialMotionCard()
			{
			var res = GTSCardAPI.GT_LoadConfig(cardNum, fileName);
			if (res != GTSCardAPI.ResultSuccess)
			var res = GTSCardAPI.GT_Open((short)IConfig.CardNum, 0, 1); //打开运动控制器。参数必须为（0,1），不能修改。
			res += GTSCardAPI.GT_LoadConfig((short)IConfig.CardNum, IConfig.InitialConfigFilePath);
			res += GTSCardAPI.GT_ClrSts(0, 1, 8);
			if (res != (short)GTSRetCode.GRCRunOK)
			{
			throw new Exception("板卡载入配置文件异常，错误码：" + res);
			}
			}


			public bool AllAxisOn()
			{
			List<Task<bool>> taskList = new List<Task<bool>>(); ;
			// 如果是多个轴的运动等每个轴开启
			IConfig.AxisSettings.Where(a => a.IsAxisEnabled).ToList().ForEach(axisNum =>
			{
			var task = AxisOnAsync((short)IConfig.CardNum, (short)axisNum.AxisIndex);
			taskList.Add(task);
			});
			Task.WaitAll(taskList.ToArray());
			var resultOK = taskList.All(u => u.GetAwaiter().GetResult());
			return resultOK;
			}

			public bool AllAxisOff()
			{
			List<Task<bool>> taskList = new List<Task<bool>>(); ;
			// 如果是多个轴的运动等每个轴关闭
			IConfig.AxisSettings.Where(a => a.IsAxisEnabled).ToList().ForEach(axisNum =>
			{
			var task = AxisOffAsync((short)IConfig.CardNum, (short)axisNum.AxisIndex);
			taskList.Add(task);
			});
			Task.WaitAll(taskList.ToArray());
			var resultOK = taskList.All(u => u.GetAwaiter().GetResult());
			return resultOK;
			}

			/// <summary>
			/// 单个轴点位到点位运动（异步）
			/// 单个轴开启
			/// </summary>
			/// <param name="item">运动对象</param>
			/// <returns></returns>
			public async Task SingleAxisMovingAsync(MovingOption item)
			public async Task<bool> AxisOnAsync(short cardNum, short axisNum)
			{
			await Task.Run(() =>
			return await Task.Run(() =>
			{
			SingleAxisMoving(item);
			var ret = GTSCardAPI.GT_AxisOn(cardNum, axisNum);
			return ret == (short)GTSRetCode.GRCRunOK;
			});
			}

			/// <summary>
			/// 单个轴点位到点位运动（异步）
			/// 单个轴关闭
			/// </summary>
			/// <returns></returns>
			public async Task<bool> AxisOffAsync(short cardNum, short axisNum)
			{
			return await Task.Run(() =>
			{
			var ret = GTSCardAPI.GT_AxisOff(cardNum, axisNum);
			return ret == (short)GTSRetCode.GRCRunOK;
			});
			}

			/// <summary>
			/// 点位到点位运动
			/// </summary>
			/// <param name="item">运动对象</param>
			public void SingleAxisMoving(MovingOption item)
			/// <returns>运动控制+停止判断</returns>
			public override ResponseMessage MoveToPoint(IOperationConfig opConfig)
			{
			if (IConfig.AxisSettings.FirstOrDefault(a => a.AxisIndex == item.AxisIndex)?.IsAxisEnabled ?? false)
			ResponseMessage responseMessage = new ResponseMessage();
			var gtsOperationCollection = opConfig as MotionOperationCollection;
			List<Task<bool>> taskList = new List<Task<bool>>();
			foreach (var movingOp in gtsOperationCollection.MovingOps)
			{
			axisImmediatePauseHandleDict[item.AxisIndex].WaitOne();
			VelocityPara vel = new VelocityPara();
			if (item.VelocityPara.Velocity != 0)
			{
			velIndexDict[item.AxisIndex] = vel = item.VelocityPara;
			}
			else
			{
			vel = velIndexDict[item.AxisIndex];
			}

			string _position = "";
			string motionType = item.MoveMode == EnumHelper.MotorMoveMode.Normal ? (item.IsAbsolute ? "Abs" : "Rel") : item.MoveMode.ToString();

			_position = $"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")},{item.AxisIndex},{motionType},{GetCmdOrPosition(item.AxisIndex, 0).ToString()},{GetCmdOrPosition(item.AxisIndex, 1).ToString()},{item.Destination},";

			lock (axisMoveLockDict[item.AxisIndex])
			{
			Task.Run(() =>
			{
			lock (_commandAxisLock)
			{
			try
			{
			if (!_commandAxisList.Contains(item.AxisIndex))
			{
			_commandAxisList.Add(item.AxisIndex);
			}
			}
			catch (Exception)
			{
			}
			}
			});

			switch (item.MoveMode)
			{
			case EnumHelper.MotorMoveMode.Normal:
			{
			if (_isResetting)
			{
			LogAsync(DateTime.Now, "复位中启动运动异常", item.AxisIndex + "启动运动异常");
			return;
			}

			SetAxisParam(item.AxisIndex, vel);
			if (item.IsAbsolute)
			{
			MoveAbs(item.AxisIndex, item.Destination, (int)(vel.Velocity * IConfig.AxisVelocityRatio));
			}
			else
			{
			MoveRel(item.AxisIndex, item.Destination, (int)(vel.Velocity * IConfig.AxisVelocityRatio));
			}
			}
			break;
			case EnumHelper.MotorMoveMode.FindOri:
			{
			AxisSetting setting = IConfig.AxisSettings.FirstOrDefault(u => u.AxisIndex == item.AxisIndex);
			StartHoming(item.AxisIndex, setting.HomeMode, setting.IsHomePositive ? 1 : 0, item.VelocityPara.Dec, item.VelocityPara.Acc, item.VelocityPara.Velocity);
			}
			break;
			}

			Task.Run(() =>
			{
			lock (_commandAxisLock)
			{
			try
			{
			_commandAxisList.Remove(item.AxisIndex);
			}
			catch (Exception)
			{
			}
			}
			});
			}

			_position += $"{GetCmdOrPosition(item.AxisIndex, 0).ToString()},";
			_position += $"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}";
			LogAsync(DateTime.Now, "", _position);
			}
			}

			public int GetCmdOrPosition(int axisNum, int flag = 0)
			{
			int position = 0;

			if (flag == 0)
			{
			GetPosition(axisNum, ref position);
			}
			else
			{
			GetCmdPosition(axisNum, ref position);
			var task = SingleAxisMoving(movingOp);
			taskList.Add(task);
			}

			return position;
			Task.WaitAll(taskList.ToArray());
			responseMessage.Result = taskList.All(u => u.GetAwaiter().GetResult());
			if (!responseMessage.Result)
			{
			responseMessage.Message = $"点位运动异常";
			}
			return responseMessage;
			}

			/// <summary>
			///Get single Axis Feedback position
			/// 点到点运动设置参数
			/// </summary>
			/// <param name="axisNum">Axis number</param>
			/// <param name="nPosition">Feedback/Encorde position </param>
			/// <param name="optionPara">运动参数对象</param>
			/// <returns></returns>
			public void GetPosition(int axisNum, ref int nPosition)
			private bool SetAxisParam(MovingOption optionPara)
			{
			lock (lockObj)
			{
			double prfpos = 0; uint pclock = 0;
			var ret = GTSCardAPI.GT_GetPrfPos((short)IConfig.CardNum, (short)axisNum, out prfpos, 1, out pclock);
			if (ret != GTSCardAPI.ResultSuccess)
			{
			throw new Exception("轴" + axisNum + "获取当前位置异常，错误码：" + ret);
			}
			nPosition = prfpos / IConfig.AxisVelocityRatio;
			}
			}

			public int GetPosition(int axisNum)
			{
			int position = 0;

			if (!IConfig.AxisSettings.FirstOrDefault(u => u.AxisIndex == axisNum).IsUseCmmdPosition)
			{
			GetPosition(axisNum, ref position);
			}
			else
			{
			GetCmdPosition(axisNum, ref position);
			}

			return position;
			}

			/// <summary>
			///Get single Axis Command position
			/// </summary>
			/// <param name="axisNum">Axis number</param>
			/// <param name="nPosition">Command position </param>
			/// <returns></returns>
			public void GetCmdPosition(int axisNum, ref int nPosition)
			{
			var ret = GTSCardAPI.APS_get_command(axisNum, ref nPosition);
			if (ret != (Int32)GTSCardParameter.ResultSuccess)
			{
			throw new Exception("轴" + axisNum + "获取当前位置异常，错误码：" + ret);
			}
			nPosition = prfpos / IConfig.AxisVelocityRatio;
			}

			/// <summary>
			/// Set AxisParam
			/// </summary>
			/// <param name="axisNo"></param>
			/// <param name="param"></param>
			/// <returns></returns>
			public void SetAxisParam(int axisNum, VelocityPara param)
			{
			int ret = 0;
			GTSCardAPI.TTrapPrm trapprm;
			GTSCardAPI.GT_PrfTrap((short)IConfig.CardNum, (short)axisNum);
			GTSCardAPI.GT_GetTrapPrm((short)IConfig.CardNum, (short)axisNum, out trapprm);
			List<short> resultCode = new List<short>() { 0 };
			GTSCardAPI.TTrapPrm trapprm = new GTSCardAPI.TTrapPrm();
			resultCode.Add(GTSCardAPI.GT_PrfTrap((short)IConfig.CardNum, (short)optionPara.AxisIndex));
			resultCode.Add(GTSCardAPI.GT_GetTrapPrm((short)IConfig.CardNum, (short)optionPara.AxisIndex, out trapprm));
			trapprm.smoothTime = 1;
			if (param.Acc != 0)
			{
			trapprm.acc = param.Acc;
			}
			if (param.Dec != 0)
			{
			trapprm.dec = param.Dec;
			}
			ret += GTSCardAPI.GT_SetTrapPrm((short)IConfig.CardNum, (short)axisNum, ref trapprm);
			ret += GTSCardAPI.GT_SetVel((short)IConfig.CardNum, (short)axisNum, param.Velocity * IConfig.AxisVelocityRatio);
			trapprm.acc = optionPara.VelocityPara.Acc != 0 ? optionPara.VelocityPara.Acc : 1;
			trapprm.dec = optionPara.VelocityPara.Dec != 0 ? optionPara.VelocityPara.Dec : 1;

			if (ret != (int)APS_Define.ResultSuccess)
			resultCode.Add(GTSCardAPI.GT_SetTrapPrm((short)IConfig.CardNum, (short)optionPara.AxisIndex, ref trapprm));
			resultCode.Add(GTSCardAPI.GT_SetVel((short)IConfig.CardNum, (short)optionPara.AxisIndex, optionPara.VelocityPara.Velocity * IConfig.AxisVelocityRatio));

			var resultOK = resultCode.All(u => u == (short)GTSRetCode.GRCRunOK);
			if (!resultOK)
			{
			throw new Exception("轴" + axisNum + "设置参数异常，错误码：" + ret);
			throw new Exception("轴" + optionPara.AxisIndex + "设置参数异常，错误码：" + string.Join(",", resultCode));
			}
			return resultOK;
			}

			/// <summary>
			/// 单个轴运动(点到点 jog 回零...）
			/// </summary>
			/// <param name="optionPara">运动参数对象</param>
			public async Task<bool> SingleAxisMoving(MovingOption optionPara)
			{
			return await Task.Run(() =>
			{
			bool isSuccessAndStop = false;
			try
			{
			if (IConfig.AxisSettings.FirstOrDefault(a => a.AxisIndex == optionPara.AxisIndex)?.IsAxisEnabled ?? false)
			{
			string _position = "";
			string motionType = optionPara.MoveMode == EnumHelper.MotionMode.Normal ? (optionPara.IsAbsolute ? "Abs" : "Rel") : optionPara.MoveMode.ToString();

			_position = $"{DateTime.Now:yyyy-MM-dd HH:mm:ss.fff},{optionPara.AxisIndex},{motionType},{GetPosition(optionPara.AxisIndex)},{GetPrfPosition(optionPara.AxisIndex)},{optionPara.Destination},";

			switch (optionPara.MoveMode)
			{
			case MotionMode.Normal:
			{
			if (_isResetting)
			{
			LogAsync(DateTime.Now, "复位中启动运动异常", optionPara.AxisIndex + "启动运动异常");
			return false;
			}

			if (optionPara.IsAbsolute)
			{
			isSuccessAndStop = P2PMoveAbs(optionPara);
			}
			else
			{
			isSuccessAndStop = P2PMoveRel(optionPara);
			}

			}
			break;
			case MotionMode.FindOri:
			{
			isSuccessAndStop = GoHome(optionPara);
			}
			break;
			case MotionMode.Jog:
			{
			isSuccessAndStop = JogMove(optionPara);
			}
			break;
			}
			_position += $"{GetPosition(optionPara.AxisIndex)},";
			_position += $"{DateTime.Now:yyyy-MM-dd HH:mm:ss.fff}";
			LogAsync(DateTime.Now, "", _position);
			}
			}
			catch (Exception ex)
			{
			isSuccessAndStop = false;
			LogAsync(DateTime.Now, $"轴{optionPara.AxisIndex}运动异常", ex.GetExceptionMessage());
			}
			return isSuccessAndStop;
			});
			}

			/// <summary>
			/// 获取规划位置（要去的位置）
			/// </summary>
			/// <param name="axisNum">Axis number</param>
			/// <returns></returns>
			public double GetPrfPosition(int axisNum)
			{
			double position = 0;
			double prfpos = 0; uint pclock = 0;
			var ret = GTSCardAPI.GT_GetPrfPos((short)IConfig.CardNum, (short)axisNum, out prfpos, 1, out pclock);
			if (ret != (short)GTSRetCode.GRCRunOK)
			{
			throw new Exception("轴" + axisNum + "获取规划位置异常，错误码：" + ret);
			}
			position = prfpos / IConfig.AxisVelocityRatio;
			return position;
			}

			/// <summary>
			/// 获取目前当前位置
			/// </summary>
			/// <param name="axisNum">Axis number</param>
			/// <returns></returns>
			public double GetPosition(int axisNum)
			{
			lock (moveLock)
			{
			double position = 0;
			int pPos = 0;
			var ret = GTSCardAPI.GT_GetPos((short)IConfig.CardNum, (short)axisNum, out pPos);
			if (ret != (short)GTSRetCode.GRCRunOK)
			{
			throw new Exception("轴" + axisNum + "获取目标位置异常，错误码：" + ret);
			}
			position = pPos / IConfig.AxisVelocityRatio;
			return position;
			}
			}

			/// <summary>
			/// 获取规划速度
			/// </summary>
			/// <param name="axisNum">Axis number</param>
			/// <returns></returns>
			public double GetPrfVelocity(int axisNum)
			{
			double prfVel = 0;
			uint pclock = 0;
			var ret = GTSCardAPI.GT_GetPrfVel((short)IConfig.CardNum, (short)axisNum, out prfVel, 1, out pclock);
			if (ret != (short)GTSRetCode.GRCRunOK)
			{
			throw new Exception("轴" + axisNum + "获取规划速度异常，错误码：" + ret);
			}
			prfVel = prfVel / IConfig.AxisVelocityRatio;
			return prfVel;
			}

			/// <summary>
			/// 获取当前速度
			/// </summary>
			/// <param name="axisNum">Axis number</param>
			/// <returns></returns>
			public double GetVelocity(int axisNum)
			{
			double vel = 0;
			var ret = GTSCardAPI.GT_GetVel((short)IConfig.CardNum, (short)axisNum, out vel);
			if (ret != (short)GTSRetCode.GRCRunOK)
			{
			throw new Exception("轴" + axisNum + "获取当前速度异常，错误码：" + ret);
			}
			vel = vel / IConfig.AxisVelocityRatio;
			return vel;
			}

			/// <summary>
			@@ -352,643 +454,300 @@
			/// <param name="nDirection">Motion Direction 0: Negative, 1: Positive</param>
			/// <param name="nMaxVel">max velocity</param>
			/// <returns></returns>
			public bool StartJog(int axisNum, int nDirection, int velocity)
			public bool JogMove(MovingOption optionPara)
			{
			GTSCardAPI.TJogPrm jogprm = new GTSCardAPI.TJogPrm();
			short rtn = GTSCardAPI.GT_PrfJog((short)IConfig.CardNum, (short)axisNum);
			jogprm.acc = 1;
			jogprm.dec = 1;
			GTSCardAPI.GT_SetJogPrm((short)IConfig.CardNum, (short)axisNum, ref jogprm);//设置jog运动参数
			GTSCardAPI.GT_SetVel((short)IConfig.CardNum, (short)axisNum, velocity);//设置目标速度
			int ret = GTSCardAPI.GT_Update((short)IConfig.CardNum, 1 << (axisNum - 1));//更新轴运动

			if (ret != (int)APS_Define.ResultSuccess)
			try
			{
			GTSCardAPI.TJogPrm jogprm = new GTSCardAPI.TJogPrm();
			short ret = 0;
			int repeatTime = 100;
			do
			{
			ret = GTSCardAPI.GT_PrfJog((short)IConfig.CardNum, (short)optionPara.AxisIndex);
			jogprm.acc = optionPara.VelocityPara.Acc;
			jogprm.dec = optionPara.VelocityPara.Dec;
			ret = GTSCardAPI.GT_SetJogPrm((short)IConfig.CardNum, (short)optionPara.AxisIndex, ref jogprm);//设置jog运动参数
			ret = GTSCardAPI.GT_SetVel((short)IConfig.CardNum, (short)optionPara.AxisIndex, optionPara.VelocityPara.Velocity);//设置目标速度
			ret = GTSCardAPI.GT_Update((short)IConfig.CardNum, 1 << (optionPara.AxisIndex - 1));//更新轴运动

			if (ret != (short)GTSRetCode.GRCRunOK)
			{
			LogAsync(DateTime.Now, "轴" + optionPara.AxisIndex + "APS_absolute_move异常", "错误码：" + ret + ";" + "重试次数：" + repeatTime);
			Thread.Sleep(10);
			}
			repeatTime--;
			} while (ret != (short)GTSRetCode.GRCRunOK && repeatTime > 0);
			return (ret == (short)GTSRetCode.GRCRunOK);
			}
			catch (Exception ex)
			{
			AllMoveStop(true);
			OnExceptionRaised?.Invoke(ex);
			return false;
			}
			return true;
			}

			/// <summary>
			/// Set Single Axis Do stop Jog Move
			/// </summary>
			/// <param name="axisNum">AxisNo</param>
			/// <returns></returns>
			public bool StopJog(int axisNum)
			{
			MoveStop();
			return IsStop((short)IConfig.CardNum, (short)axisNum);
			}

			/// <summary>
			/// Set Single Axis Do Rel Move
			/// 相对位置运动
			/// </summary>
			/// <param name="axisNum">AxisNo</param>
			/// <param name="nDistance">run distance</param>
			/// <returns></returns>
			public void MoveRel(int axisNum, int nDistance, int nMaxVel)
			public bool P2PMoveRel(MovingOption optionPara)
			{
			try
			{
			if (_isResetting)
			{
			LogAsync(DateTime.Now, "复位过程异常", "轴" + optionPara.AxisIndex + "试图在复位过程中运动");
			throw new Exception("轴" + optionPara.AxisIndex + "试图在复位过程中运动");
			}

			int repeatTime = 30;
			while (CurrentState != EnumHelper.DeviceState.DSOpen && repeatTime > 0)
			{
			Thread.Sleep(10);
			repeatTime--;
			}

			if (CurrentState == EnumHelper.DeviceState.DSExcept)
			{
			LogAsync(DateTime.Now, "板卡异常状态", "轴" + axisNum + "试图异常状态运动");
			return;
			LogAsync(DateTime.Now, "板卡异常状态", "轴" + optionPara.AxisIndex + "试图异常状态运动");
			return false;
			}

			if (CurrentState != EnumHelper.DeviceState.DSOpen)
			{
			return;
			LogAsync(DateTime.Now, "非正常状态异常", "轴" + optionPara.AxisIndex + "试图在非正常状态运动");
			throw new Exception("轴" + optionPara.AxisIndex + "试图在非正常状态运动", null);
			}

			int currentPosition = GetPosition(axisNum);

			if (OnAxisStartToCheckConfliction != null && OnAxisStartToCheckConfliction.Invoke(axisNum, currentPosition, currentPosition + nDistance))
			LogAsync(DateTime.Now, "轴" + optionPara.AxisIndex + "开始运动", "目标坐标：" + optionPara.Destination);
			short ret = 0;
			bool isSuccessSetAxisParam = false;
			int currentPosition = (int)GetPosition(optionPara.AxisIndex);
			int dPosition = optionPara.Destination + currentPosition;
			int timeout = optionPara.MovingTimeout;
			while (CurrentState == DeviceState.DSOpen)
			{
			return;
			//设置运动参数
			isSuccessSetAxisParam = SetAxisParam(optionPara);
			ret = GTSCardAPI.GT_SetPrfPos((short)IConfig.CardNum, (short)optionPara.AxisIndex, (int)(dPosition * IConfig.AxisVelocityRatio));// 设置规划位置
			ret = GTSCardAPI.GT_Update((short)IConfig.CardNum, 1 << (optionPara.AxisIndex - 1));//更新运动

			if (ret != (short)GTSRetCode.GRCRunOK)
			{
			LogAsync(DateTime.Now, "轴" + optionPara.AxisIndex + "APS_absolute_move异常", "错误码：" + ret + ";" + "重试次数：" + repeatTime);
			Thread.Sleep(50);
			}
			timeout -= 50;
			if ((ret == (short)GTSRetCode.GRCRunOK && isSuccessSetAxisParam) \|\| (optionPara.MovingTimeout > 0 && timeout < 0))
			{
			break;
			}
			}

			int ret = GTSCardAPI.GT_SetPos((short)IConfig.CardNum, (short)axisNum, nDistance * IConfig.AxisVelocityRatio);

			ret += GTSCardAPI.GT_Update((short)IConfig.CardNum, 1 << (axisNum - 1));
			if (ret != (Int32)APS_Define.ResultSuccess)
			//运动开始后检查运动是否停止
			bool isStop = false;
			repeatTime = 1000;
			do
			{
			throw new Exception("轴" + axisNum + "启动相对运动异常，错误码：" + ret);
			}
			isStop = IsStop((short)IConfig.CardNum, (short)optionPara.AxisIndex);
			Thread.Sleep(50);
			repeatTime--;
			} while (!isStop && repeatTime > 0);

			RunFinish(axisNum, false);
			return (ret == (short)GTSRetCode.GRCRunOK) && isStop;
			}
			catch (Exception ex)
			{
			MoveStop();
			AllMoveStop(true);
			OnExceptionRaised?.Invoke(ex);
			return false;
			}
			}

			/// <summary>
			/// Set Single Axis Do Absolute Move
			/// 绝对位置运动
			/// </summary>
			/// <param name="axisNum">AxisNo</param>
			/// <param name="nDistance">run distance</param>
			/// <param name="nMaxVel">max velocity</param>
			/// <returns></returns>
			public void MoveAbs(int axisNum, int nPosition, int nMaxVel)
			/// <param name="optionPara">运动参数对象</param>
			public bool P2PMoveAbs(MovingOption optionPara)
			{
			try
			{
			ReMove:
			MoveAbsAsync(axisNum, nPosition);

			var runFinish = Task.Run(() => RunFinish(axisNum), axisMoveCancelDict[axisNum].Token);
			try
			if (_isResetting)
			{
			runFinish.Wait(axisMoveCancelDict[axisNum].Token);
			LogAsync(DateTime.Now, "复位过程异常", "轴" + optionPara.AxisIndex + "试图在复位过程中运动");
			throw new Exception("轴" + optionPara.AxisIndex + "试图在复位过程中运动");
			}
			catch (OperationCanceledException ex)
			int repeatTime = 30;
			while (CurrentState != EnumHelper.DeviceState.DSOpen && repeatTime > 0)
			{
			goto ReMove;
			Thread.Sleep(10);
			repeatTime--;
			}
			if (CurrentState == EnumHelper.DeviceState.DSExcept)
			{
			LogAsync(DateTime.Now, "板卡异常状态", "轴" + optionPara.AxisIndex + "试图异常状态运动");
			return false;
			}

			//// 删除记录
			//if (currentCommandDic.ContainsKey(axisNum))
			//{
			// currentCommandDic.TryRemove(axisNum, out int[] temp);
			//}
			if (CurrentState != EnumHelper.DeviceState.DSOpen)
			{
			LogAsync(DateTime.Now, "非正常状态异常", "轴" + optionPara.AxisIndex + "试图在非正常状态运动");
			throw new Exception("轴" + optionPara.AxisIndex + "试图在非正常状态运动", null);
			}
			LogAsync(DateTime.Now, "轴" + optionPara.AxisIndex + "开始运动", "目标坐标：" + optionPara.Destination);
			short ret = 0;
			bool isSuccessSetAxisParam = false;
			int timeout = optionPara.MovingTimeout;
			while (CurrentState == DeviceState.DSOpen)
			{
			//设置运动参数
			isSuccessSetAxisParam = SetAxisParam(optionPara);
			ret = GTSCardAPI.GT_SetPrfPos((short)IConfig.CardNum, (short)optionPara.AxisIndex, (int)(optionPara.Destination * IConfig.AxisVelocityRatio));// 设置规划位置
			ret = GTSCardAPI.GT_Update((short)IConfig.CardNum, 1 << (optionPara.AxisIndex - 1));//更新运动

			if (ret != (short)GTSRetCode.GRCRunOK)
			{
			LogAsync(DateTime.Now, "轴" + optionPara.AxisIndex + "APS_absolute_move异常", "错误码：" + ret + ";" + "重试次数：" + repeatTime);
			Thread.Sleep(50);
			}
			timeout -= 50;
			if ((ret == (short)GTSRetCode.GRCRunOK && isSuccessSetAxisParam) \|\| (optionPara.MovingTimeout > 0 && timeout < 0))
			{
			break;
			}
			}

			bool isStop = false;
			repeatTime = 1000;
			do
			{
			isStop = IsStop((short)IConfig.CardNum, (short)optionPara.AxisIndex);
			Thread.Sleep(50);
			repeatTime--;
			} while (!isStop && repeatTime > 0);

			return (ret == (short)GTSRetCode.GRCRunOK) && isStop;
			}
			catch (Exception ex)
			{
			MoveStop();
			AllMoveStop(true);
			OnExceptionRaised?.Invoke(ex);
			}
			}

			static object moveLock = new object();

			/// <summary>
			/// 绝对运动（异步）
			/// </summary>
			/// <param name="axisNum"></param>
			/// <param name="nPosition"></param>
			public void MoveAbsAsync(int axisNum, int nPosition)
			{
			try
			{
			lock (moveLock)
			{
			axisImmediatePauseHandleDict[axisNum].WaitOne();
			_pauseHandle.WaitOne();

			int currentPosition = GetPosition(axisNum);
			if (OnAxisStartToCheckConfliction != null && OnAxisStartToCheckConfliction.Invoke(axisNum, currentPosition, nPosition))
			{
			return;
			}

			if (_isResetting)
			{
			LogAsync(DateTime.Now, "复位过程异常", "轴" + axisNum + "试图在复位过程中运动");
			throw new Exception("轴" + axisNum + "试图在复位过程中运动");
			}

			int repeatTime = 30;
			while (CurrentState != EnumHelper.DeviceState.DSOpen && repeatTime > 0)
			{
			Thread.Sleep(10);
			repeatTime--;
			}

			if (CurrentState == EnumHelper.DeviceState.DSExcept)
			{
			LogAsync(DateTime.Now, "板卡异常状态", "轴" + axisNum + "试图异常状态运动");
			return;
			}

			if (CurrentState != EnumHelper.DeviceState.DSOpen)
			{
			LogAsync(DateTime.Now, "非正常状态异常", "轴" + axisNum + "试图在非正常状态运动");
			throw new Exception("轴" + axisNum + "试图在非正常状态运动", null);
			}

			int ret = 0;
			repeatTime = 50;
			do
			{
			LogAsync(DateTime.Now, "轴" + axisNum + "启动运动", "目标坐标：" + nPosition);
			ret = GTSCardAPI.GT_SetPos((short)IConfig.CardNum, (short)axisNum, nPosition * IConfig.AxisVelocityRatio);

			ret += GTSCardAPI.GT_Update((short)IConfig.CardNum, 1 << (axisNum - 1));
			if (ret != (Int32)APS_Define.ResultSuccess)
			{
			LogAsync(DateTime.Now, "轴" + axisNum + "APS_absolute_move异常", "返回值：" + ret + "；重试次数：" + repeatTime);
			Thread.Sleep(50);
			}
			repeatTime--;
			} while (ret != (Int32)APS_Define.ResultSuccess && repeatTime > 0);

			if (ret != (Int32)APS_Define.ResultSuccess)
			{
			LogAsync(DateTime.Now, "轴" + axisNum + "启动绝对运动异常", "错误码：" + ret);
			throw new Exception("轴" + axisNum + "启动绝对运动异常，错误码：" + ret);
			}
			}
			}
			catch (Exception ex)
			{
			MoveStop();
			OnExceptionRaised?.Invoke(ex);
			}
			}

			Dictionary<int, AxisMovingStay> _axisStayDict = new Dictionary<int, AxisMovingStay>();

			private async void MoveAbsStay(int axisNum)
			{
			await Task.Run(() =>
			{
			while (CurrentState != EnumHelper.DeviceState.DSClose)
			{
			if (!_axisStayDict.ContainsKey(axisNum))
			{
			_axisStayDict[axisNum] = new AxisMovingStay();
			}

			_axisStayDict[axisNum].MoveHandle.WaitOne();
			MoveAbsAsync(axisNum, _axisStayDict[axisNum].Position);
			_axisStayDict[axisNum].MoveSendHandle.Set();
			}
			});
			}

			/// <summary>
			/// 动作结束
			/// </summary>
			/// <param name="axisNum"></param>
			/// <returns></returns>
			public void RunFinish(int axisNum, bool isAbs = true)
			{
			MOTION_IO_STATUS MotionIoSts = new MOTION_IO_STATUS();
			MOTION_BOOL_STATUS MotionSts = new MOTION_BOOL_STATUS();
			var axisSetting = IConfig.AxisSettings.FirstOrDefault(a => a.AxisIndex == axisNum);
			int startTime = System.Environment.TickCount;

			//MDN信号
			if (axisSetting.IsUseMDNStopSignal)
			{
			while (GetMotionIoStatus(axisNum, ref MotionIoSts) && GetMotionStatus(axisNum, ref MotionSts))
			{
			if (MotionIoSts.EMG)
			{
			LogAsync(DateTime.Now, "轴" + axisNum + "急停", "");
			throw new Exception("轴" + axisNum + "急停");
			}

			if (MotionSts.MDN)
			{
			int stopCode = -1;
			APS168.APS_get_stop_code(axisNum, ref stopCode);

			LogAsync(DateTime.Now, "轴" + axisNum + "StopCode：", stopCode.ToString());

			//0 正常停止 4 正极限 5 负极限
			if (new List<int>() { 0, 4, 5 }.Contains(stopCode))
			{
			if (new List<int>() { 4, 5 }.Contains(stopCode) && axisSetting.IsUseWarning)
			{
			MoveStop(true);
			OnExceptionRaised?.Invoke(new Exception("轴" + axisNum + "运动至极限位置，stopCode：" + stopCode.ToString(), null));
			return;
			}
			if (IConfig.ActionAfterDelay > 0)
			{
			Thread.Sleep(IConfig.ActionAfterDelay);
			}

			int feedBack = 0;
			GetPosition(axisNum, ref feedBack);
			LogAsync(DateTime.Now, "轴" + axisNum + "运动结束", "当前位置：" + feedBack);
			break;
			}
			}

			}
			}
			else //INP信号
			{
			while (GetMotionIoStatus(axisNum, ref MotionIoSts) && GetMotionStatus(axisNum, ref MotionSts))
			{
			if (MotionIoSts.EMG)
			{
			LogAsync(DateTime.Now, "轴" + axisNum + "急停", "");
			throw new Exception("轴" + axisNum + "急停");
			}


			if (MotionSts.MDN && MotionIoSts.INP)
			{
			int stopCode = -1;
			APS168.APS_get_stop_code(axisNum, ref stopCode);

			LogAsync(DateTime.Now, "轴" + axisNum + "StopCode：", stopCode.ToString());

			//0 正常停止 4 正极限 5 负极限
			if (new List<int>() { 0, 4, 5 }.Contains(stopCode))
			{
			if (new List<int>() { 4, 5 }.Contains(stopCode) && axisSetting.IsUseWarning)
			{
			MoveStop(true);
			OnExceptionRaised?.Invoke(new AMPRunException("轴" + axisNum + "运动至极限位置，stopCode：" + stopCode.ToString(), null));
			return;
			}

			if (IConfig.ActionAfterDelay > 0)
			{
			Thread.Sleep(IConfig.ActionAfterDelay);
			}

			int feedBack = 0;
			GetPosition(axisNum, ref feedBack);
			LogAsync(DateTime.Now, "轴" + axisNum + "运动结束", "当前位置：" + feedBack);
			break;
			}
			}

			}
			return false;
			}
			}

			/// <summary>
			/// Stop single axis move
			/// 某个轴运动停止
			/// </summary>
			/// <param name="axisNum">axisNo</param>
			/// <param name="option">0表示平滑停止，1表示紧急停止</param>
			/// <returns></returns>
			public void MoveStop(int axisNum, int option)
			public async Task<bool> MoveStop(int axisNum, int option)
			{
			int ret = GTSCardAPI.GT_Stop((short)IConfig.CardNum, 1 << (axisNum - 1), option);
			if (ret != (Int32)APS_Define.ResultSuccess)
			return await Task.Run(() =>
			{
			LogAsync(DateTime.Now, "轴" + axisNum + "运动停止异常", "错误码：" + ret);
			throw new Exception("轴" + axisNum + "运动停止异常，错误码：" + ret);
			}
			else
			{
			LogAsync(DateTime.Now, "轴" + axisNum + "运动停止", "");
			}
			}

			static object motionIOLock = new object();
			/// <summary>
			/// Get single Axis Motion_Io status and motion status
			/// </summary>
			/// <param name="nAxis"></param>
			/// <param name="nMotionSts"></param>
			/// <returns></returns>
			public bool GetMotionStatus(int nAxis, ref MOTION_BOOL_STATUS strcMotionSts)
			{
			lock (motionIOLock)
			{
			int nMotionSts = 0;
			nMotionSts = APS168.APS_motion_status(nAxis);
			if (nMotionSts < 0)
			bool isStop = false;
			if (option == 1)
			{
			return false;
			StateChange(EnumHelper.DeviceState.DSExcept);
			}
			strcMotionSts.ASTP = Convert.ToBoolean(nMotionSts & (1 << (int)MOTION_STATUS.ASTP));
			strcMotionSts.HMV = Convert.ToBoolean(nMotionSts & (1 << (int)MOTION_STATUS.HMV));
			strcMotionSts.MDN = Convert.ToBoolean(nMotionSts & (1 << (int)MOTION_STATUS.MDN));
			strcMotionSts.DIR = Convert.ToBoolean(nMotionSts & (1 << (int)MOTION_STATUS.DIR));
			}
			return true;
			}

			/// <summary>
			/// Get single Axis Motion_Io status and motion status
			/// </summary>
			/// <param name="nAxis"></param>
			/// <param name="nMotionIoSts"></param>
			/// <returns></returns>
			public bool GetMotionIoStatus(int nAxis, ref MOTION_IO_STATUS strcMotionIoSts)
			{
			lock (motionIOLock)
			{
			//Thread.Sleep(15);
			int nMotionIoSts = 0;
			nMotionIoSts = APS168.APS_motion_io_status(nAxis);
			if (nMotionIoSts < 0)
			var ret = GTSCardAPI.GT_Stop((short)IConfig.CardNum, 1 << (axisNum - 1), option);
			if (ret != (short)GTSRetCode.GRCRunOK)
			{
			return false;
			LogAsync(DateTime.Now, "轴" + axisNum + "运动停止异常", "错误码：" + ret);
			throw new Exception("轴" + axisNum + "运动停止异常，错误码：" + ret);
			}

			bool isAlarm = Convert.ToBoolean(nMotionIoSts & (1 << (int)MOTION_IOSTATUS.ALM));
			if (strcMotionIoSts.ALM != isAlarm)
			else
			{
			strcMotionIoSts.ALM = isAlarm;
			OnMotionAlarm?.Invoke(nAxis, isAlarm);
			LogAsync(DateTime.Now, "轴" + axisNum + "运动停止", "");
			}
			int repeatTime = 100;
			do
			{
			isStop = IsStop((short)IConfig.CardNum, (short)axisNum);
			Thread.Sleep(10);
			repeatTime--;
			} while (!isStop && repeatTime > 0);

			strcMotionIoSts.PEL = Convert.ToBoolean(nMotionIoSts & (1 << (int)MOTION_IOSTATUS.PEL));
			strcMotionIoSts.MEL = Convert.ToBoolean(nMotionIoSts & (1 << (int)MOTION_IOSTATUS.MEL));
			strcMotionIoSts.ORG = Convert.ToBoolean(nMotionIoSts & (1 << (int)MOTION_IOSTATUS.ORG));
			strcMotionIoSts.EMG = Convert.ToBoolean(nMotionIoSts & (1 << (int)MOTION_IOSTATUS.EMG));
			strcMotionIoSts.INP = Convert.ToBoolean(nMotionIoSts & (1 << (int)MOTION_IOSTATUS.INP));
			strcMotionIoSts.SVON = Convert.ToBoolean(nMotionIoSts & (1 << (int)MOTION_IOSTATUS.SVON));
			}
			return true;
			}

			public void MoveStop(bool emergencyStop = false)
			{
			int option = 0;
			if (emergencyStop)
			{
			option = 1;
			StateChange(EnumHelper.DeviceState.DSExcept);
			}

			IConfig.AxisSettings.Where(a => a.IsAxisEnabled).ToList().ForEach(axisNum =>
			{
			MoveStop(axisNum.AxisIndex, option);
			return (ret == (short)GTSRetCode.GRCRunOK) && isStop;
			});
			}

			/// <summary>
			/// 所有开启的轴停止
			/// </summary>
			/// <param name="emergencyStop"></param>
			public void AllMoveStop(bool emergencyStop = false)
			{
			int option = emergencyStop ? 1 : 0;
			List<Task<bool>> taskList = new List<Task<bool>>(); ;
			// 如果是多个轴的运动等每个轴运动结束
			IConfig.AxisSettings.Where(a => a.IsAxisEnabled).ToList().ForEach(axisNum =>
			{
			var task = MoveStop(axisNum.AxisIndex, option);
			taskList.Add(task);
			});
			Task.WaitAll(taskList.ToArray());
			var resultOK = taskList.All(u => u.GetAwaiter().GetResult());
			}

			/// <summary>
			/// 回原点
			/// </summary>
			/// <param name="cardn">卡号</param>
			/// <param name="movingOption">卡号</param>
			/// <param name="axisn">轴号</param>
			/// <param name="homests">轴回原点状态</param>
			public bool GoHome(short cardn, short axisn, short home_mode, short home_dir, int homeoffset)
			public bool GoHome(MovingOption movingOption)
			{
			try
			{
			GTSCardAPI.GT_ZeroPos(cardn, axisn, 1);
			GTSCardAPI.GT_ZeroPos((short)IConfig.CardNum, (short)movingOption.AxisIndex, 1);
			GTSCardAPI.THomePrm thomeprm;
			GTSCardAPI.THomeStatus homests;
			short rtn = GTSCardAPI.GT_GetHomePrm(cardn, axisn, out thomeprm);
			thomeprm.mode = home_mode;//回零方式
			thomeprm.moveDir = home_dir;//回零方向
			thomeprm.edge = 0;
			thomeprm.velHigh = 50;
			thomeprm.velLow = 50;
			thomeprm.acc = 50;
			thomeprm.dec = 50;
			thomeprm.searchHomeDistance = 9999999;//搜搜距离
			thomeprm.homeOffset = 0; //偏移距离
			thomeprm.escapeStep = 1000;
			rtn = GTSCardAPI.GT_GoHome(cardn, axisn, ref thomeprm); //启动回零
			short rtn = GTSCardAPI.GT_GetHomePrm((short)IConfig.CardNum, (short)movingOption.AxisIndex, out thomeprm);
			thomeprm.mode = movingOption.GoHomePara.HomeMode;//回零方式
			thomeprm.moveDir = movingOption.GoHomePara.HomeDir;//回零方向
			thomeprm.edge = movingOption.GoHomePara.Edge;
			thomeprm.velHigh = movingOption.GoHomePara.HighVelocity;
			thomeprm.velLow = movingOption.GoHomePara.LowVelocity;
			thomeprm.acc = movingOption.VelocityPara.Acc;
			thomeprm.dec = movingOption.VelocityPara.Dec;
			thomeprm.searchHomeDistance = movingOption.GoHomePara.SearchHomeDistance;//搜搜距离
			thomeprm.homeOffset = movingOption.GoHomePara.HomeOffset; //偏移距离
			thomeprm.escapeStep = movingOption.GoHomePara.EscapeStep;
			rtn = GTSCardAPI.GT_GoHome((short)IConfig.CardNum, (short)movingOption.AxisIndex, ref thomeprm); //启动回零

			while (true)
			bool isStop = false;
			int repeatTime = 1000;
			do
			{
			Thread.Sleep(5);
			GTSCardAPI.GT_GetHomeStatus(cardn, axisn, out homests);
			if (homests.run == 0)
			Thread.Sleep(10);
			GTSCardAPI.GT_GetHomeStatus((short)IConfig.CardNum, (short)movingOption.AxisIndex, out homests);

			isStop = homests.run == 0;
			if (isStop && homests.error == 0)
			{
			if (homests.error == 0)
			{
			Thread.Sleep(200);
			GTSCardAPI.GT_ZeroPos(cardn, axisn, 1);
			}
			return true;
			Thread.Sleep(200);
			GTSCardAPI.GT_ZeroPos((short)IConfig.CardNum, (short)movingOption.AxisIndex, 1);
			}
			}
			repeatTime--;
			} while (!isStop && repeatTime > 0);

			return isStop;
			}
			catch (Exception ex)
			{
			MoveStop();
			AllMoveStop(true);
			OnExceptionRaised?.Invoke(ex);
			return false;
			}
			}

			/// <summary>
			/// 回原点
			/// </summary>
			/// <param name="axisId"></param>
			public void StartHoming(int axisId)
			{
			try
			{
			//servo on
			APS168.APS_set_servo_on(axisId, 1);
			Thread.Sleep(500); // Wait stable.

			// 2. Start home move
			APS168.APS_home_move(axisId);

			WaitHomeFinish(axisId);

			axisDestination[axisId] = 0;
			}
			catch (Exception ex)
			{
			MoveStop();
			OnExceptionRaised?.Invoke(ex);
			}
			}

			/// <summary>
			/// 回原点
			/// </summary>
			/// <param name="axisId"></param>
			/// <param name="homeMode"></param>
			/// <param name="homeDir"></param>
			/// <param name="praCurve"></param>
			/// <param name="praAcc"></param>
			/// <param name="praVm"></param>
			public void StartHoming(int axisId, int homeMode, int homeDir, double praCurve, double praAcc, double praVm)
			{
			// 1. Select home mode and config home parameters
			APS168.APS_set_axis_param(axisId, (Int32)APS_Define.PRA_HOME_MODE, homeMode); // Set home mode
			APS168.APS_set_axis_param(axisId, (Int32)APS_Define.PRA_HOME_DIR, homeDir); // Set home direction
			APS168.APS_set_axis_param_f(axisId, (Int32)APS_Define.PRA_HOME_CURVE, praCurve); // Set acceleration paten (T-curve)
			APS168.APS_set_axis_param_f(axisId, (Int32)APS_Define.PRA_HOME_ACC, praAcc); // Set homing acceleration rate
			APS168.APS_set_axis_param_f(axisId, (Int32)APS_Define.PRA_HOME_VM, praVm); // Set homing maximum velocity.
			APS168.APS_set_axis_param_f(axisId, (Int32)APS_Define.PRA_HOME_VO, praVm / 5); // Set homing VO speed
			APS168.APS_set_axis_param_f(axisId, (Int32)APS_Define.PRA_HOME_EZA, 0); // Set EZ signal alignment (yes or no)
			APS168.APS_set_axis_param_f(axisId, (Int32)APS_Define.PRA_HOME_SHIFT, 0); // Set home position shfit distance.
			APS168.APS_set_axis_param_f(axisId, (Int32)APS_Define.PRA_HOME_POS, 0); // Set final home position.

			StartHoming(axisId);
			}

			/// <summary>
			/// 回原点结束
			/// </summary>
			/// <param name="axisNum"></param>
			/// <returns></returns>
			public void WaitHomeFinish(int axisNum)
			{
			MOTION_IO_STATUS MotionIoSts = new MOTION_IO_STATUS();
			MOTION_BOOL_STATUS MotionSts = new MOTION_BOOL_STATUS();
			var axisSetting = IConfig.AxisSettings.FirstOrDefault(a => a.AxisIndex == axisNum);
			int startTime = System.Environment.TickCount;
			while ((GetMotionIoStatus(axisNum, ref MotionIoSts)) && (GetMotionStatus(axisNum, ref MotionSts)))
			{
			if (MotionIoSts.EMG)
			{
			LogAsync(DateTime.Now, "轴复位中" + axisNum + "急停", "");
			throw new Exception("轴复位中" + axisNum + "急停");
			}

			if (axisSetting.HomeMode == 0)
			{
			if (!MotionSts.HMV && MotionIoSts.ORG)
			break;
			}
			else
			{
			if (!MotionSts.HMV)
			break;
			}

			if (axisSetting.TimeOutHome < System.Environment.TickCount - startTime)
			{
			LogAsync(DateTime.Now, "轴复位中" + axisNum + "回原点超时", "");
			MoveStop(axisNum);
			throw new Exception("轴复位中" + axisNum + "回原点超时");
			}
			}

			//ClearPosition(axisNum);
			}

			static object _ioLock = new object();
			/// <summary>
			/// 设置IO卡输出
			/// </summary>
			/// <param name="DINo">IO端口序号</param>
			/// <param name="Value">设置值(true:高电平， false:低电平)</param>
			/// <returns></returns>
			public bool SetOutput(int DINo, bool Value)
			{
			if (OnCheckOutputAllowed?.Invoke(DINo, Value, new Dictionary<int, int>(axisDestination.ToDictionary(u => u.Key, u => u.Value))) ?? false)
			{
			OnExceptionRaised?.Invoke(new AMPRunException(DINo + "输出" + Value.ToString() + "不被允许", null));
			return false;
			}

			int ret = -1;
			lock (_ioLock)
			{
			ret = APS168.APS_write_d_channel_output(0, 0, DINo, Value ? 1 : 0);
			}
			if (ret < 0)
			{
			return false;
			}
			return true;
			}

			/// <summary>
			/// 获取输入信号
			/// </summary>
			/// <param name="stateType"></param>
			/// <returns></returns>
			public bool[] GetInputState()
			{
			int diVaule = 0;

			lock (_ioLock)
			{
			APS168.APS_read_d_input(0, 0, ref diVaule);
			}
			return GetBoolSig(diVaule);
			//return new bool[16];
			}

			/// <summary>
			/// 获取输出信号
			/// </summary>
			/// <param name="stateType"></param>
			/// <returns></returns>
			public bool[] GetOutputState()
			{
			int doVaule = 0;

			lock (_ioLock)
			{
			APS168.APS_read_d_output(0, 0, ref doVaule);
			}

			return GetBoolSig(doVaule);

			}

			/// <summary>
			/// 将无符号整型转换为Bool型数组
			/// </summary>
			/// <param name="sigStr"></param>
			/// <returns></returns>
			private bool[] GetBoolSig(int sigStr)
			{
			bool[] state = new bool[32];

			for (int i = 0; i < 32; i++)
			{
			state[i] = (sigStr & (1 << i)) != 0;
			}
			return state;
			}

			/// <summary>
			/// 将bool数组转换成无符号整型
			/// </summary>
			/// <param name="sigArray"></param>
			/// <returns></returns>
			private int GetintSig(bool[] sigArray)
			{
			int state = -1;

			for (int i = 31; i > -1; i--)
			{
			state = (state << 1) + (sigArray[i] ? 1 : 0);
			}

			return state;
			}

			/// <summary>
			/// 读取输入
			/// 读取IO输入
			/// </summary>
			/// <param name="cardNum">卡号</param>
			/// <param name="index">输入口</param>
			@@ -997,148 +756,52 @@
			{
			int value;
			GTSCardAPI.GT_GetDi(cardNum, GTSCardAPI.MC_GPI, out value);
			if ((value & 1 << index) == 0) return true;//有输入返回true
			if ((value & (1 << index)) == 0) return true;//有输入返回true
			else return false; //无输入返回false
			}

			/// <summary>
			/// 输出
			/// 读取IO输出
			/// </summary>
			/// <param name="cardNum">卡号</param>
			/// <param name="index">输出口,返回1-16</param>
			/// <param name="value">false表示输出，true表示关闭</param>
			public void WriteOut(short cardNum, short index, bool value)
			{
			short outNum = (short)(index % 100 + 1);
			if (value)
			{
			GTSCardAPI.GT_SetDoBit(cardNum, GTSCardAPI.MC_GPO, outNum, 0);
			}
			else
			{
			GTSCardAPI.GT_SetDoBit(cardNum, GTSCardAPI.MC_GPO, outNum, 1);
			}
			}

			/// <summary>
			/// 停止某个轴
			/// </summary>
			/// <param name="cardNum">卡号</param>
			/// <param name="axisNum">轴号</param>
			/// <param name="option">0表示平滑停止，1表示紧急停止</param>
			public void Stop(short cardNum, short axisNum, short option)
			{
			GTSCardAPI.GT_Stop(cardNum, 1 << (axisNum - 1), option);
			}

			/// <summary>
			/// 停止某个轴（异步）
			/// </summary>
			/// <param name="cardNum">卡号</param>
			/// <param name="axisNum">轴号</param>
			/// <param name="option">0表示平滑停止，1表示紧急停止</param>
			public async Task StopAsync(short cardNum, short axisNum, short option)
			{
			await Task.Run(() =>
			{
			GTSCardAPI.GT_Stop(cardNum, 1 << (axisNum - 1), option);
			});
			}

			/// <summary>
			/// 停止某个轴
			/// </summary>
			/// <param name="cardNum"></param>
			/// <param name="axisNum">轴号</param>
			/// <param name="value">停止方式，false表示平滑停止，true表示紧急停止</param>
			public void Stop(short cardNum, short axisNum, bool emergencyStop)
			{
			if (emergencyStop)
			{
			GTSCardAPI.GT_Stop(cardNum, 1 << (axisNum - 1), 1 << (axisNum - 1));
			}
			else
			{
			GTSCardAPI.GT_Stop(cardNum, 1 << (axisNum - 1), 0);
			}
			}

			/// <summary>
			/// 停止全部轴
			/// </summary>
			/// <param name="cardNum"></param>
			/// <param name="value">停止方式，false表示平滑停止，true表示紧急停止</param>
			public void StopAll(short cardNum, bool value)
			{
			for (short i = 1; i <= GTSCardParameter.AxisCount; i++)
			{
			Stop(cardNum, i, value);
			}
			}

			/// <summary>
			/// IO输出
			/// </summary>
			/// <param name="cardNum">卡号</param>
			/// <param name="mdl">模块号</param>
			/// <param name="index">IO输出</param>
			/// <param name="value">true表示输出，false表示无输出</param>
			public void MC_WriteDigitalOutput(short cardNum, short mdl, short index, bool value)
			{
			if (value)
			{
			GTSCardAPI.GT_SetExtIoBit(cardNum, mdl, index, 0);
			}
			else
			{
			GTSCardAPI.GT_SetExtIoBit(cardNum, mdl, index, 1);
			}
			}

			/// <summary>
			/// 读取IO输出状态
			/// </summary>
			/// <param name="cardNum"></param>
			/// <param name="index"></param>
			/// <param name="index">io索引</param>
			/// <returns></returns>
			public bool GetDoSts(short cardNum, short index)
			public bool GetDoSts(short index)
			{
			short outNum = 0;
			int outSts;
			outNum = (short)(index % 100);
			GTSCardAPI.GT_GetDo(cardNum, GTSCardAPI.MC_GPO, out outSts);
			short outNum = (short)(index % 100);
			GTSCardAPI.GT_GetDo((short)IConfig.CardNum, GTSCardAPI.MC_GPO, out outSts);
			if ((outSts & (1 << outNum)) == 0) return true;
			else return false;
			}




			/// <summary>
			/// 读取当前值
			/// 按位设置数字 IO 输出状态
			/// </summary>
			/// <param name="cardNum">卡号</param>
			/// <param name="axisNum">轴号</param>
			/// <returns>返回当前值，单位毫米</returns>
			public double GetPosMM(short cardNum, short axisNum)
			/// <param name="index">输出口,返回1-16</param>
			/// <param name="value">false表示输出，true表示关闭</param>
			public override void WriteOutput(short index, IOValue value)
			{
			lock (lockObj)
			short outNum = (short)(index % 100 + 1);
			if ((int)value <= 1)
			{
			double prfpos = 0; uint pclock = 0;
			GTSCardAPI.GT_GetPrfPos(cardNum, axisNum, out prfpos, 1, out pclock);
			return prfpos / IConfig.AxisVelocityRatio;
			GTSCardAPI.GT_SetDoBit((short)IConfig.CardNum, GTSCardAPI.MC_GPO, outNum, (short)value);
			}
			else
			{
			var currentValue = (int)MonitorValues.FirstOrDefault(u => u.IONum == outNum && u.IOType == IOType.OUTPUT).Value;
			GTSCardAPI.GT_SetDoBit((short)IConfig.CardNum, GTSCardAPI.MC_GPO, outNum, (short)(currentValue == 1 ? 0 : 1));
			}
			}

			/// <summary>
			/// 读取轴状态，判断电机是否停止
			/// </summary>
			/// <param name="cardNum"></param>
			/// <param name="axisNum"></param>
			/// <param name="cardNum">板卡号</param>
			/// <param name="axisNum">轴号</param>
			/// <returns></returns>
			public bool IsStop(short cardNum, short axisNum)
			{
			lock (lockObj)
			lock (moveLock)
			{
			int sts = 0;
			uint pclock = 0;
			@@ -1147,16 +810,263 @@
			else return false; //运行中返回false
			}
			}

			#endregion

			public void Monitor()
			#region IMonitor

			public List<AxisMovingStatus> GetAxisMovingStatus()
			{
			throw new NotImplementedException();
			List<AxisMovingStatus> axisMovingStatusesList = new List<AxisMovingStatus>();
			foreach (var axisConfig in IConfig.AxisSettings.FindAll(u => u.IsAxisEnabled))
			{
			AxisMovingStatus axisMovingStatus = new AxisMovingStatus();
			axisMovingStatus.AxisIndex = axisConfig.AxisIndex;
			axisMovingStatus.AxisName = axisConfig.AxisName;
			axisMovingStatus.CurPosition = Convert.ToInt32(GetPosition(axisMovingStatus.AxisIndex));
			axisMovingStatus.Destination = Convert.ToInt32(GetPrfPosition(axisMovingStatus.AxisIndex));
			axisMovingStatus.CurVelocity = GetVelocity(axisMovingStatus.AxisIndex);
			axisMovingStatus.PrfVelocity = GetPrfVelocity(axisMovingStatus.AxisIndex);
			axisMovingStatusesList.Add(axisMovingStatus);

			}

			return axisMovingStatusesList;
			}

			public void ResetAlarm()

			public List<IOItem> GetMonitorValues()
			{
			throw new NotImplementedException();
			var result = new List<IOItem>();
			//读取IO输入
			int inValue;
			GTSCardAPI.GT_GetDi((short)IConfig.CardNum, GTSCardAPI.MC_GPI, out inValue);
			//读取IO输出
			int outValue;
			GTSCardAPI.GT_GetDo((short)IConfig.CardNum, GTSCardAPI.MC_GPO, out outValue);

			//解析结果
			for (var index = 1; index <= 16; index++)
			{
			IOItem inItem = new IOItem()
			{
			IONum = index,
			Value = (inValue & (1 << index)) == 0 ? IOValue.TRUE : IOValue.FALSE,
			IOType = IOType.INPUT
			};
			IOItem outItem = new IOItem()
			{
			IONum = index,
			Value = (outValue & (1 << index)) == 0 ? IOValue.TRUE : IOValue.FALSE,
			IOType = IOType.OUTPUT
			};
			result.Add(inItem);
			result.Add(outItem);
			}

			return result;
			}

			public async override void Monitor()
			{
			await Task.Run(() =>
			{
			while (CurrentState != EnumHelper.DeviceState.DSClose && CurrentState != EnumHelper.DeviceState.DSExcept && CurrentState != EnumHelper.DeviceState.DSUninit)
			{
			try
			{
			if (!IConfig.IsEnableMonitor)
			return;
			var newValues = GetMonitorValues();
			var newAxisMovingStatus = GetAxisMovingStatus();
			if (newValues == null \|\| newValues.Count == 0 \|\| newAxisMovingStatus == null \|\| newAxisMovingStatus.Count == 0)
			continue;

			Stopwatch sw = new Stopwatch();
			sw.Start();
			if (MonitorValues.Count == newValues.Count)
			{
			var tempNew = newValues.DeepSerializeClone();//clone
			var tempOld = MonitorValues.DeepSerializeClone();
			MonitorCheckAndInvoke(tempNew, tempOld);
			}

			AxisMovingOptionValues = new List<AxisMovingStatus>(newAxisMovingStatus);
			MonitorValues = new List<IOItem>(newValues);
			sw.Stop();

			if (sw.ElapsedMilliseconds > 20)
			{
			LogAsync(DateTime.Now, $"{this.Name}轮询时间：{sw.ElapsedMilliseconds}", "");
			}

			if (IConfig.MonitorInterval > 0)
			{
			Thread.Sleep(IConfig.MonitorInterval);
			}

			}
			catch (Exception ex)
			{
			if (CurrentState == DeviceState.DSOpen)
			{
			LogAsync(DateTime.Now, $"{this.Name}监听异常", ex.GetExceptionMessage());
			}
			}
			}
			});
			}

			public override void OnMethodInvoked(IAsyncResult ar)
			{
			MotionCardMonitorSet monitorSet = ar.AsyncState as MotionCardMonitorSet;
			ProcessResponse resValues = monitorSet.Response;
			if (resValues.ResultValue == (int)ReplyValue.IGNORE)
			{
			return;
			}

			Stopwatch sw = new Stopwatch();
			sw.Start();
			// 将指定IOItem写入板卡
			foreach (var replyIOData in monitorSet.ReplyIODatas)
			{
			//写入IO输出
			if (replyIOData.IOType == IOType.OUTPUT)
			{
			GTSCardAPI.GT_SetDoBit((short)IConfig.CardNum, GTSCardAPI.MC_GPI, (short)replyIOData.IONum, (short)replyIOData.Value);
			}
			// in只读不能写
			}
			sw.Stop();
			LogAsync(DateTime.Now, $"{Name}反馈完成，耗时{sw.ElapsedMilliseconds}ms", $"{resValues.GetDisplayText()}");
			}

			protected void MonitorCheckAndInvoke(List<IOItem> tempNew, List<IOItem> tempOld)
			{
			#region 警报信息
			Parallel.ForEach(IConfig.WarningSetCollection, wSet =>
			{
			MotionCardWarningSet warningSet = wSet as MotionCardWarningSet;

			bool isOn = (((int)((tempNew.FirstOrDefault(u => u.IONum == warningSet.TriggerIndex && u.IOType == warningSet.WarningIOModel)?.Value)) >> warningSet.TriggerIndex) & 1) == (warningSet.TriggerValue ? 1 : 0);

			if (warningSet.CurrentStatus != isOn)
			{
			warningSet.CurrentStatus = isOn;
			warningSet.TriggerTime = DateTime.Now;
			SaveAlarmCSVAsync(DateTime.Now, this.Name, warningSet);
			ExcuteMonitorAlarm(DateTime.Now, this, warningSet);
			}
			});
			#endregion

			#region 监听信息
			Parallel.ForEach(IConfig.MonitorSetCollection, mSet =>
			{
			MotionCardMonitorSet monitorSet = mSet as MotionCardMonitorSet;
			if (monitorSet.TriggerIndex < 0 \|\| monitorSet.TriggerIndex > tempNew.Count)
			{
			return;
			}

			var newIOItem = tempNew.FirstOrDefault(u => u.IONum == monitorSet.TriggerIndex);
			var oldIOItem = tempOld.FirstOrDefault(u => u.IONum == monitorSet.TriggerIndex);

			if (newIOItem?.Value != oldIOItem?.Value)
			{
			if (monitorSet.TriggerValue == -999 \|\| (int)newIOItem.Value == monitorSet.TriggerValue)
			{
			if (monitorSet.OpConfig == null)
			{
			monitorSet.OpConfig = new OperationConfigBase();
			}

			//monitorSet.OpConfig.InputPara = monitorSet.InputDataIndex.ConvertAll(index =>
			//{
			// return tempNew[index].Value;
			//}).ToList();

			ExcuteMonitorInvoke(DateTime.Now, monitorSet.InvokeDevice, this, monitorSet);
			}
			}
			});
			#endregion
			}

			public override void ResetAlarm()
			{
			int axis_sts;
			uint clk;
			var axisSettings = IConfig.AxisSettings.FindAll(u => u.IsAxisEnabled);
			GTSCardAPI.GT_ClrSts((short)IConfig.CardNum, 1, (short)axisSettings.Count);
			foreach (var axisSetting in axisSettings)
			{
			GTSCardAPI.GT_GetSts((short)IConfig.CardNum, (short)axisSetting.AxisIndex, out axis_sts, 1, out clk);
			if ((axis_sts & 0x200) == 0)
			{
			var rst = GTSCardAPI.GT_AxisOn((short)IConfig.CardNum, (short)axisSetting.AxisIndex);
			}
			// 位置请零
			GTSCardAPI.GT_ZeroPos((short)IConfig.CardNum, 1, (short)axisSettings.Count);
			// 正极限报警
			if ((axis_sts & 0x20) != 0)
			{
			// 负向移动
			MovingOption movingOption = new MovingOption();
			movingOption.AxisIndex = (short)axisSetting.AxisIndex;
			movingOption.Destination = -50; // 负向移动
			movingOption.VelocityPara.Velocity = 50;
			P2PMoveAbs(movingOption);
			}

			// 负极限报警
			if ((axis_sts & 0x40) != 0)
			{
			// 正向移动
			MovingOption movingOption = new MovingOption();
			movingOption.AxisIndex = (short)axisSetting.AxisIndex;
			movingOption.Destination = 50; // 负向移动
			movingOption.VelocityPara.Velocity = 50;
			P2PMoveAbs(movingOption);
			}
			}

			// 清除状态
			GTSCardAPI.GT_ClrSts((short)IConfig.CardNum, 1, (short)IConfig.AxisSettings.FindAll(u => u.IsAxisEnabled).Count);
			}

			object _alarmLock = new object();
			private async void SaveAlarmCSVAsync(DateTime now, string plcName, IWarningSet ws)
			{
			await Task.Run(() =>
			{
			lock (_alarmLock)
			{
			DirectoryInfo dir = new DirectoryInfo(this.IConfig.LogPath);
			if (!dir.Exists)
			{
			dir.Create();
			}

			string path = Path.Combine(IConfig.LogPath, $"Alarm_{Name}_{now.ToString("yyyyMMdd")}.csv");
			bool fileExist = File.Exists(path);

			using (StreamWriter writer = new StreamWriter(path, true, System.Text.Encoding.UTF8))
			{
			if (!fileExist)
			{
			writer.WriteLine("Time,Source,AlarmCode,AlarmDescription,AlarmStatus");
			}

			writer.WriteLine($"{now.ToString("HH:mm:ss.fff")},{plcName},{ws.WarningCode},{ws.WarningDescription},{(ws.CurrentStatus ? "报警" : "停止")}");

			writer.Flush();
			writer.Close();
			}
			}
			});
			}
			#endregion
			}
			}