using Bro.Common.Base;
|
using Bro.Common.Helper;
|
using Bro.Common.Interface;
|
using Bro.Common.Model;
|
using System;
|
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 : MotionCardBase
|
{
|
// 异常事件
|
//public Action<Exception> OnExceptionRaised;
|
|
public GTSCardInitialConfig IIConfig
|
{
|
get
|
{
|
return InitialConfig as GTSCardInitialConfig;
|
}
|
}
|
|
static object moveLock = new object();
|
/// <summary>
|
/// 是否复位标志
|
/// </summary>
|
bool _isResetting = false;
|
|
/// <summary>
|
/// 是否暂停中
|
/// </summary>
|
bool _isPause = false;
|
|
/// <summary>
|
/// 运动轴立即暂停
|
/// </summary>
|
Dictionary<int, ManualResetEvent> axisImmediatePauseHandleDict = new Dictionary<int, ManualResetEvent>();
|
Dictionary<int, bool> axisImmediatePauseFlag = new Dictionary<int, bool>();
|
Dictionary<int, bool> axisPauseResumeFlag = new Dictionary<int, bool>();
|
|
//Dictionary<int, CancellationTokenSource> axisMoveCancelDict = new Dictionary<int, CancellationTokenSource>();
|
|
public void SetResetFlag(bool isReset)
|
{
|
_isResetting = isReset;
|
}
|
|
public override List<AxisInfo> GetCurrentAxisInfo(params string[] axisName)
|
{
|
List<AxisInfo> axisInfos = new List<AxisInfo>();
|
IConfig.AxisSettings.FindAll(a => a.IsAxisEnabled).ForEach(axisSetting =>
|
{
|
AxisInfo axisInfo = new AxisInfo();
|
axisInfo.AxisName = axisSetting.AxisName;
|
var axisMovingStatus = AxisStatusList.FirstOrDefault(u => u.AxisIndex == axisSetting.AxisIndex);
|
axisInfo.AxisLocation = axisMovingStatus == null ? 0 : Convert.ToDouble(axisMovingStatus.CurPosition);
|
|
axisInfos.Add(axisInfo);
|
});
|
return axisInfos;
|
}
|
|
#region DeviceBase
|
|
protected override void Init()
|
{
|
InitialMotionCard();
|
axisImmediatePauseHandleDict = IConfig.AxisSettings.FindAll(a => a.IsAxisEnabled).ToDictionary(a => a.AxisIndex, a => new ManualResetEvent(true));
|
//axisMoveCancelDict = IConfig.AxisSettings.FindAll(a => a.IsAxisEnabled).ToDictionary(a => a.AxisIndex, a => new CancellationTokenSource());
|
|
//axisMoveCancelDict.Values.ToList().ForEach(c =>
|
//{
|
// c = new CancellationTokenSource();
|
//});
|
}
|
|
protected override void Pause()
|
{
|
|
}
|
|
protected override void Resume()
|
{
|
|
}
|
|
protected override void Start()
|
{
|
AllAxisOn();
|
|
MonitorPosition();
|
MonitorAxisStatus();
|
|
base.Start();
|
}
|
|
protected override void Stop()
|
{
|
AllMoveStop();
|
AllAxisOff();
|
}
|
|
/// <summary>
|
/// 设备 运行（执行 板卡系列的操作的 集合）
|
/// </summary>
|
/// <param name="config"></param>
|
/// <returns></returns>
|
public override ResponseMessage Run(IOperationConfig config)
|
{
|
ResponseMessage responseMessage = new ResponseMessage();
|
if (config is MotionCardOperationConfigBase motionCardOperationConfig)
|
{
|
foreach (var operationSet in motionCardOperationConfig.OperationCollection)
|
{
|
if (operationSet.DelayBefore > 0)
|
Thread.Sleep(operationSet.DelayBefore);
|
|
responseMessage = RunOperationSet(operationSet);
|
if (!responseMessage.Result)
|
{
|
return responseMessage;
|
}
|
|
if (operationSet.DelayAfter > 0)
|
Thread.Sleep(operationSet.DelayAfter);
|
}
|
}
|
return responseMessage;
|
}
|
|
/// <summary>
|
/// 执行 一个系列的操作
|
/// </summary>
|
private ResponseMessage RunOperationSet(MotionCardOperationSet operationSet)
|
{
|
ResponseMessage responseMessage = new ResponseMessage();
|
// 1.预检查
|
if (CurrentState == DeviceState.DSOpen)
|
{
|
foreach (var preCheck in operationSet.PreCheckIOCollection)
|
{
|
_pauseHandle.Wait();
|
|
IOValue? ioData = null;
|
if (CurrentState == DeviceState.DSOpen)
|
{
|
int timeout = operationSet.PreCheckIOTimeout;
|
|
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)
|
{
|
_pauseHandle.Wait();
|
|
if (CurrentState == DeviceState.DSOpen)
|
{
|
responseMessage = MoveToPoint(new MotionOperationCollection() { MovingOps = operationSet.MovingOps });
|
if (!responseMessage.Result)
|
{
|
return responseMessage;
|
}
|
}
|
}
|
|
|
// 3.IO输出 不需要超时
|
if (CurrentState == DeviceState.DSOpen)
|
{
|
|
foreach (var ioOutput in operationSet.IOOutputCollection)
|
{
|
_pauseHandle.Wait();
|
|
if (CurrentState == DeviceState.DSOpen)
|
{
|
WriteOutput((short)ioOutput.IOItem.IONum, ioOutput.CheckValue);
|
|
//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 ImmediatePause
|
ManualResetEventSlim _pauseHandle = new ManualResetEventSlim(true);
|
|
/// <summary>
|
/// 启动立即暂停
|
/// </summary>
|
public override void SetImmediatePause()
|
{
|
if (!_isResetting)
|
{
|
var immediatePauseAxis = IConfig.AxisSettings.FindAll(a => a.IsAxisEnabled && a.IsImmediatePause).Select(u => u.AxisIndex).ToList();
|
_pauseHandle.Reset();
|
immediatePauseAxis.ForEach(async axisIndex =>
|
{
|
axisImmediatePauseHandleDict[axisIndex].Reset();
|
axisImmediatePauseFlag[axisIndex] = true;
|
|
await MoveStop(axisIndex, 0);//所有轴都暂停
|
});
|
}
|
}
|
|
/// <summary>
|
/// 恢复立即暂停
|
/// </summary>
|
public override void ResetImmediatePause(bool isResumeMoving)
|
{
|
var immediatePauseAxis = IConfig.AxisSettings.FindAll(a => a.IsAxisEnabled && a.IsImmediatePause).Select(u => u.AxisIndex).ToList();
|
_pauseHandle.Set();
|
immediatePauseAxis.ForEach(axisIndex =>
|
{
|
axisImmediatePauseFlag[axisIndex] = false;
|
axisImmediatePauseHandleDict[axisIndex].Set();
|
if (isResumeMoving)
|
{
|
axisPauseResumeFlag[axisIndex] = true;
|
}
|
else
|
{
|
axisPauseResumeFlag[axisIndex] = false;
|
}
|
});
|
}
|
#endregion
|
|
#region GTSCard
|
|
/// <summary>
|
/// Load Motion Card parameter from file
|
/// </summary>
|
/// <param name="fileName">Invalid Parameter</param>
|
/// <returns></returns>
|
public void InitialMotionCard()
|
{
|
var res = GTSCardAPI.GT_Open((short)IConfig.CardNum, 0, 1); //打开运动控制器。参数必须为（0,1），不能修改。
|
res += GTSCardAPI.GT_LoadConfig((short)IConfig.CardNum, IConfig.InitialConfigFilePath);
|
ClearStatus(1, IConfig.AxisSettings.FindAll(u => u.IsAxisEnabled).Count);
|
if (res != (short)GTSRetCode.GRCRunOK)
|
{
|
throw new ProcessException("板卡载入配置文件异常，错误码：" + res);
|
}
|
}
|
|
public override bool AllAxisOn()
|
{
|
List<Task<bool>> taskList = new List<Task<bool>>(); ;
|
// 如果是多个轴的运动 等每个轴开启
|
IConfig.AxisSettings.FindAll(a => a.IsAxisEnabled).ForEach(axisNum =>
|
{
|
var task = AxisOnAsync(axisNum.AxisIndex);
|
taskList.Add(task);
|
});
|
Task.WaitAll(taskList.ToArray());
|
var resultOK = taskList.All(u => u.GetAwaiter().GetResult());
|
return resultOK;
|
}
|
|
public override bool AllAxisOff()
|
{
|
List<Task<bool>> taskList = new List<Task<bool>>(); ;
|
// 如果是多个轴的运动 等每个轴关闭
|
IConfig.AxisSettings.FindAll(a => a.IsAxisEnabled).ForEach(axisNum =>
|
{
|
var task = AxisOffAsync(axisNum.AxisIndex);
|
taskList.Add(task);
|
});
|
Task.WaitAll(taskList.ToArray());
|
var resultOK = taskList.All(u => u.GetAwaiter().GetResult());
|
return resultOK;
|
}
|
|
/// <summary>
|
/// 单个轴开启
|
/// </summary>
|
/// <returns></returns>
|
public override async Task<bool> AxisOnAsync(int axisNum)
|
{
|
return await Task.Run(() =>
|
{
|
var ret = GTSCardAPI.GT_AxisOn((short)IConfig.CardNum, (short)axisNum);
|
return ret == (short)GTSRetCode.GRCRunOK;
|
});
|
}
|
|
/// <summary>
|
/// 单个轴关闭
|
/// </summary>
|
/// <returns></returns>
|
public override async Task<bool> AxisOffAsync(int axisNum)
|
{
|
return await Task.Run(() =>
|
{
|
var ret = GTSCardAPI.GT_AxisOff((short)IConfig.CardNum, (short)axisNum);
|
return ret == (short)GTSRetCode.GRCRunOK;
|
});
|
}
|
|
/// <summary>
|
/// 点位到点位运动
|
/// </summary>
|
/// <param name="item">运动对象</param>
|
/// <returns>运动控制+停止判断</returns>
|
public override ResponseMessage MoveToPoint(IOperationConfig opConfig)
|
{
|
ResponseMessage responseMessage = new ResponseMessage();
|
if (opConfig is MotionOperationCollection gtsOperationCollection)
|
{
|
List<bool> resultList = new List<bool>();
|
Parallel.ForEach(gtsOperationCollection.MovingOps, movingOp =>
|
{
|
axisImmediatePauseFlag[movingOp.AxisIndex] = false;
|
axisPauseResumeFlag[movingOp.AxisIndex] = true;
|
resultList.Add(SingleAxisMoving(movingOp).Result);
|
});
|
responseMessage.Result = resultList.All(u => u == true);
|
if (!responseMessage.Result)
|
{
|
responseMessage.Message = $"点位运动异常,运动结果：{string.Join(" ", resultList.Select(u => u ? "1" : "0"))}";
|
}
|
}
|
return responseMessage;
|
}
|
|
/// <summary>
|
/// 点到点运动设置参数
|
/// </summary>
|
/// <param name="optionPara">运动参数对象</param>
|
/// <returns></returns>
|
private bool SetAxisParam(MovingOption optionPara)
|
{
|
List<short> resultCode = new List<short>();
|
GTSCardAPI.TTrapPrm trapprm = new GTSCardAPI.TTrapPrm();
|
short axisIndex = short.Parse(optionPara.AxisIndexStr);
|
resultCode.Add(GTSCardAPI.GT_PrfTrap((short)IConfig.CardNum, axisIndex));
|
|
if (optionPara.VelocityPara.Acc != 0 || optionPara.VelocityPara.Dec != 0)
|
{
|
resultCode.Add(GTSCardAPI.GT_GetTrapPrm((short)IConfig.CardNum, axisIndex, out trapprm));
|
trapprm.smoothTime = 1;
|
|
if (optionPara.VelocityPara.Acc != 0)
|
{
|
trapprm.acc = optionPara.VelocityPara.Acc;
|
}
|
|
if (optionPara.VelocityPara.Dec != 0)
|
{
|
trapprm.dec = optionPara.VelocityPara.Dec;
|
}
|
|
resultCode.Add(GTSCardAPI.GT_SetTrapPrm((short)IConfig.CardNum, axisIndex, ref trapprm));
|
}
|
|
if (optionPara.VelocityPara.Velocity != 0)
|
{
|
resultCode.Add(GTSCardAPI.GT_SetVel((short)IConfig.CardNum, axisIndex, optionPara.VelocityPara.Velocity * IConfig.AxisVelocityRatio));
|
}
|
|
var resultOK = resultCode.All(u => u == (short)GTSRetCode.GRCRunOK);
|
if (!resultOK)
|
{
|
//throw new ProcessException("轴" + optionPara.AxisIndex + "设置参数异常，错误码：" + string.Join(",", resultCode));
|
LogAsync(DateTime.Now, $"轴{optionPara.AxisIndex}设置参数异常，错误码：{string.Join(",", resultCode)}", "");
|
}
|
return true;
|
}
|
|
TaskFactory taskFactory = new TaskFactory(TaskCreationOptions.LongRunning, TaskContinuationOptions.LongRunning);
|
/// <summary>
|
/// 单个轴 运动(点到点 jog 回零...）
|
/// </summary>
|
/// <param name="optionPara">运动参数对象</param>
|
public override Task<bool> SingleAxisMoving(MovingOption optionPara)
|
{
|
return Task.Run(() =>
|
{
|
bool isSuccessAndStop = false;
|
do
|
{
|
axisImmediatePauseHandleDict[optionPara.AxisIndex].WaitOne();
|
|
if (axisPauseResumeFlag.ContainsKey(optionPara.AxisIndex) && !axisPauseResumeFlag[optionPara.AxisIndex])
|
return true;
|
|
try
|
{
|
if (IConfig.AxisSettings.FirstOrDefault(a => a.AxisIndex == optionPara.AxisIndex)?.IsAxisEnabled ?? false)
|
{
|
string motionType = optionPara.MoveMode == EnumHelper.MotionMode.Normal ? (optionPara.IsAbsolute ? "Abs" : "Rel") : optionPara.MoveMode.ToString();
|
|
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);
|
isSuccessAndStop = P2PGoHome(optionPara);
|
}
|
break;
|
case MotionMode.Jog:
|
{
|
isSuccessAndStop = JogMove(optionPara);
|
}
|
break;
|
}
|
}
|
}
|
catch (Exception ex)
|
{
|
isSuccessAndStop = false;
|
LogAsync(DateTime.Now, $"轴{optionPara.AxisIndex}运动异常", ex.GetExceptionMessage());
|
}
|
} while (axisImmediatePauseFlag.ContainsKey(optionPara.AxisIndex) && axisImmediatePauseFlag[optionPara.AxisIndex]);
|
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 ProcessException("轴" + axisNum + "获取规划位置异常，错误码：" + ret);
|
}
|
//var AxisRatio = IConfig.AxisSettings.FirstOrDefault(u => u.AxisIndex == axisNum) == null ? 1 : IConfig.AxisSettings.FirstOrDefault(u => u.AxisIndex == axisNum).AxisRatio;
|
position = prfpos;
|
return position;
|
}
|
|
/// <summary>
|
/// 获取目前当前位置
|
/// </summary>
|
/// <param name="axisNum">Axis number</param>
|
/// <returns></returns>
|
public double GetPosition(int axisNum)
|
{
|
//lock (moveLock)
|
{
|
double position = 0;
|
double pPos = 0;
|
var ret = GTSCardAPI.GT_GetPrfPos((short)IConfig.CardNum, (short)axisNum, out pPos, 1, out uint pclock);
|
if (ret != (short)GTSRetCode.GRCRunOK)
|
{
|
throw new ProcessException("轴" + axisNum + "获取目标位置异常，错误码：" + ret);
|
}
|
//var AxisRatio = IConfig.AxisSettings.FirstOrDefault(u => u.AxisIndex == axisNum) == null ? 1 : IConfig.AxisSettings.FirstOrDefault(u => u.AxisIndex == axisNum).AxisRatio;
|
position = pPos;
|
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 ProcessException("轴" + axisNum + "获取规划速度异常，错误码：" + ret);
|
}
|
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 ProcessException("轴" + axisNum + "获取当前速度异常，错误码：" + ret);
|
}
|
return vel;
|
}
|
|
/// <summary>
|
/// Set Single Axis Do Jog Move
|
/// </summary>
|
/// <param name="axisNum">AxisNo</param>
|
/// <param name="nDirection">Motion Direction 0: Negative, 1: Positive</param>
|
/// <param name="nMaxVel">max velocity</param>
|
/// <returns></returns>
|
public bool JogMove(MovingOption optionPara)
|
{
|
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 + "JogMove异常", "错误码：" + ret + ";" + "重试次数：" + repeatTime);
|
Thread.Sleep(10);
|
}
|
repeatTime--;
|
} while (ret != (short)GTSRetCode.GRCRunOK && repeatTime > 0);
|
return (ret == (short)GTSRetCode.GRCRunOK);
|
}
|
catch (Exception ex)
|
{
|
AllMoveStop(true);
|
OnExceptionOccured?.Invoke(DateTime.Now, ex);
|
return false;
|
}
|
}
|
|
/// <summary>
|
/// 相对位置运动
|
/// </summary>
|
/// <param name="axisNum">AxisNo</param>
|
/// <param name="nDistance">run distance</param>
|
/// <returns></returns>
|
public bool P2PMoveRel(MovingOption optionPara)
|
{
|
try
|
{
|
if (_isResetting)
|
{
|
LogAsync(DateTime.Now, "复位过程异常", "轴" + optionPara.AxisIndex + "试图在复位过程中运动");
|
throw new ProcessException("轴" + optionPara.AxisIndex + "试图在复位过程中运动");
|
}
|
|
int repeatTime = 30;
|
while (CurrentState != EnumHelper.DeviceState.DSOpen && repeatTime > 0)
|
{
|
Thread.Sleep(10);
|
repeatTime--;
|
}
|
|
if (CurrentState == EnumHelper.DeviceState.DSExcept)
|
{
|
LogAsync(DateTime.Now, "板卡异常状态", "轴" + optionPara.AxisIndex + "试图异常状态运动");
|
return false;
|
}
|
|
if (CurrentState != EnumHelper.DeviceState.DSOpen)
|
{
|
LogAsync(DateTime.Now, "非正常状态异常", "轴" + optionPara.AxisIndex + "试图在非正常状态运动");
|
|
return false;
|
//throw new ProcessException("轴" + optionPara.AxisIndex + "试图在非正常状态运动", null);
|
}
|
|
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;
|
var AxisRatio = IConfig.AxisSettings.FirstOrDefault(u => u.AxisIndex == optionPara.AxisIndex) == null ? 1 : IConfig.AxisSettings.FirstOrDefault(u => u.AxisIndex == optionPara.AxisIndex).AxisRatio;
|
while (CurrentState == DeviceState.DSOpen)
|
{
|
//设置 运动参数
|
isSuccessSetAxisParam = SetAxisParam(optionPara);
|
ret = GTSCardAPI.GT_SetPos((short)IConfig.CardNum, (short)optionPara.AxisIndex, (int)(dPosition));// 设置目的位置
|
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
|
{
|
Thread.Sleep(50);
|
isStop = IsStop((short)optionPara.AxisIndex);
|
repeatTime--;
|
} while (!isStop && repeatTime > 0);
|
|
return (ret == (short)GTSRetCode.GRCRunOK) && isStop;
|
}
|
catch (Exception ex)
|
{
|
AllMoveStop(true);
|
OnExceptionOccured?.Invoke(DateTime.Now, ex);
|
return false;
|
}
|
}
|
|
/// <summary>
|
/// 绝对位置运动
|
/// </summary>
|
/// <param name="optionPara">运动参数对象</param>
|
public bool P2PMoveAbs(MovingOption optionPara)
|
{
|
try
|
{
|
axisImmediatePauseHandleDict[optionPara.AxisIndex].WaitOne();
|
|
if (_isResetting)
|
{
|
LogAsync(DateTime.Now, "复位过程异常", "轴" + optionPara.AxisIndex + "试图在复位过程中运动");
|
throw new ProcessException("轴" + optionPara.AxisIndex + "试图在复位过程中运动");
|
}
|
int repeatTime = 30;
|
while (CurrentState != EnumHelper.DeviceState.DSOpen && repeatTime > 0)
|
{
|
Thread.Sleep(10);
|
repeatTime--;
|
}
|
if (CurrentState == EnumHelper.DeviceState.DSExcept)
|
{
|
LogAsync(DateTime.Now, "板卡异常状态", "轴" + optionPara.AxisIndex + "试图异常状态运动");
|
return false;
|
}
|
|
if (CurrentState != EnumHelper.DeviceState.DSOpen)
|
{
|
LogAsync(DateTime.Now, "非正常状态异常", "轴" + optionPara.AxisIndex + "试图在非正常状态运动");
|
|
return false;
|
//throw new ProcessException("轴" + optionPara.AxisIndex + "试图在非正常状态运动", null);
|
}
|
|
LogAsync(DateTime.Now, "轴" + optionPara.AxisIndex + "开始运动", "目标坐标：" + optionPara.Destination);
|
short ret = 0;
|
bool isSuccessSetAxisParam = false;
|
int timeout = optionPara.MovingTimeout;
|
//var AxisRatio = IConfig.AxisSettings.FirstOrDefault(u => u.AxisIndex == optionPara.AxisIndex) == null ? 1 : IConfig.AxisSettings.FirstOrDefault(u => u.AxisIndex == optionPara.AxisIndex).AxisRatio;
|
while (CurrentState == DeviceState.DSOpen && !_isPause)
|
{
|
//设置 运动参数
|
isSuccessSetAxisParam = SetAxisParam(optionPara);
|
ret = GTSCardAPI.GT_SetPos((short)IConfig.CardNum, (short)optionPara.AxisIndex, (int)(optionPara.Destination));// 设置目标位置
|
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;
|
while (!isStop && repeatTime > 0)
|
{
|
Thread.Sleep(50);
|
isStop = IsStop((short)optionPara.AxisIndex);
|
repeatTime--;
|
}
|
|
if (repeatTime <= 0)
|
{
|
LogAsync(DateTime.Now, "轴" + optionPara.AxisIndex + "APS_absolute_move未停止", "");
|
return false;
|
}
|
|
//return (ret == (short)GTSRetCode.GRCRunOK) && isStop;
|
return true;
|
}
|
catch (Exception ex)
|
{
|
AllMoveStop(true);
|
OnExceptionOccured?.Invoke(DateTime.Now, ex);
|
return false;
|
}
|
}
|
|
/// <summary>
|
/// 某个轴运动停止
|
/// </summary>
|
/// <param name="axisNum">axisNo</param>
|
/// <param name="option">0表示平滑停止，1表示紧急停止</param>
|
/// <returns></returns>
|
public override async Task<bool> MoveStop(int axisNum, int option)
|
{
|
return await Task.Run(() =>
|
{
|
bool isStop = false;
|
if (option == 1)
|
{
|
//StateChange(EnumHelper.DeviceState.DSExcept);
|
LogAsync(DateTime.Now, "急停停止", "");
|
}
|
var ret = GTSCardAPI.GT_Stop((short)IConfig.CardNum, 1 << (axisNum - 1), option);
|
if (ret != (short)GTSRetCode.GRCRunOK)
|
{
|
LogAsync(DateTime.Now, "轴" + axisNum + "运动停止异常", "错误码：" + ret);
|
throw new ProcessException("轴" + axisNum + "运动停止异常，错误码：" + ret);
|
}
|
else
|
{
|
LogAsync(DateTime.Now, "轴" + axisNum + "运动停止", "");
|
}
|
int repeatTime = 100;
|
do
|
{
|
Thread.Sleep(10);
|
isStop = IsStop((short)axisNum);
|
repeatTime--;
|
} while (!isStop && repeatTime > 0);
|
|
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="movingOption">卡号</param>
|
///// <param name="axisn">轴号</param>
|
///// <param name="homests">轴回原点状态</param>
|
//public bool GoHome(MovingOption movingOption)
|
//{
|
// try
|
// {
|
// PositionReset(movingOption.AxisIndex, 1);
|
// GTSCardAPI.THomePrm thomeprm;
|
// GTSCardAPI.THomeStatus homests;
|
// // 启动Home捕获
|
// short rtn = GTSCardAPI.GT_SetCaptureMode((short)IConfig.CardNum, (short)movingOption.AxisIndex, GTSCardAPI.CAPTURE_HOME);
|
// // 切换到点位运动模式
|
// rtn = GTSCardAPI.GT_PrfTrap((short)IConfig.CardNum, (short)movingOption.AxisIndex);
|
// // 读取点位模式运动参数
|
// 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); //启动回零
|
|
// bool isStop = false;
|
// int repeatTime = 1000;
|
// do
|
// {
|
// Thread.Sleep(10);
|
// GTSCardAPI.GT_GetHomeStatus((short)IConfig.CardNum, (short)movingOption.AxisIndex, out homests);
|
|
// isStop = homests.run == 0;
|
// if (isStop && homests.error == 0)
|
// {
|
// Thread.Sleep(200);
|
// PositionReset(movingOption.AxisIndex, 1);
|
// }
|
// repeatTime--;
|
// } while (!isStop && repeatTime > 0);
|
|
// return isStop;
|
// }
|
// catch (Exception ex)
|
// {
|
// AllMoveStop(true);
|
// OnExceptionOccured?.Invoke(DateTime.Now, ex);
|
// return false;
|
// }
|
//}
|
|
/// <summary>
|
/// P2P方式回原点
|
/// </summary>
|
/// <param name="movingOption">运动参数</param>
|
public bool P2PGoHome(MovingOption movingOption)
|
{
|
try
|
{
|
Thread.CurrentThread.Priority = ThreadPriority.AboveNormal;
|
|
var goHomePara = IConfig.AxisSettings.FirstOrDefault(u => u.AxisIndex == movingOption.AxisIndex).GoHomePara;
|
bool homeDirection = goHomePara.IsHomeDirPositive;
|
bool isRightLimitReached = false;
|
short capture = 0;
|
|
GTSCardAPI.TTrapPrm trapPrm;
|
|
// 切换到点位运动模式
|
short sRtn = GTSCardAPI.GT_PrfTrap((short)IConfig.CardNum, (short)movingOption.AxisIndex);
|
// 读取点位模式运动参数
|
sRtn = GTSCardAPI.GT_GetTrapPrm((short)IConfig.CardNum, (short)movingOption.AxisIndex, out trapPrm);
|
trapPrm.acc = movingOption.VelocityPara.Acc;
|
trapPrm.dec = movingOption.VelocityPara.Dec;
|
// 设置点位模式运动参数
|
sRtn = GTSCardAPI.GT_SetTrapPrm((short)IConfig.CardNum, (short)movingOption.AxisIndex, ref trapPrm);
|
// 设置点位模式目标速度，即回原点速度
|
sRtn = GTSCardAPI.GT_SetVel((short)IConfig.CardNum, (short)movingOption.AxisIndex, goHomePara.HomeVelocity);
|
|
do
|
{
|
PositionReset(movingOption.AxisIndex, 1);
|
ClearStatus(movingOption.AxisIndex, 1);
|
|
//LogAsync(DateTime.Now, $"{Name}位置置零", "");
|
|
if (goHomePara.IsCaptureMode)
|
{
|
//搜索距离 阶段1
|
// 启动Home捕获
|
sRtn = GTSCardAPI.GT_SetCaptureMode((short)IConfig.CardNum, (short)movingOption.AxisIndex, GTSCardAPI.CAPTURE_HOME);
|
}
|
|
// 设置点位模式目标位置，即原点搜索距离
|
sRtn = GTSCardAPI.GT_SetPos((short)IConfig.CardNum, (short)movingOption.AxisIndex, homeDirection ? 999999999 : -999999999);
|
// 启动运动
|
sRtn = GTSCardAPI.GT_Update((short)IConfig.CardNum, 1 << (movingOption.AxisIndex - 1));
|
|
int repeatTime = goHomePara.GoHomeTimeOut * 1000;
|
|
bool isStop = false;
|
int pos = 0;
|
uint clk;//时钟参数
|
|
int checkInterval = IConfig.MonitorInterval;
|
if (IConfig.MonitorInterval <= 0)
|
{
|
checkInterval = 10;
|
}
|
|
do
|
{
|
Thread.Sleep(checkInterval);
|
|
if (goHomePara.IsCaptureMode)
|
{
|
// 读取捕获状态
|
GTSCardAPI.GT_GetCaptureStatus((short)IConfig.CardNum, (short)movingOption.AxisIndex, out capture, out pos, 1, out clk);
|
}
|
else
|
{
|
GTSCardAPI.GT_GetDi((short)IConfig.CardNum, GTSCardAPI.MC_HOME, out int pValue);
|
capture = (short)((pValue & (1 << (movingOption.AxisIndex - 1))) == 0 ? 1 : 0);
|
//LogAsync(DateTime.Now, $"原点状态{pValue}，轴{movingOption.AxisIndex}原点{capture}", "");
|
}
|
isStop = IsStop((short)movingOption.AxisIndex);
|
repeatTime -= checkInterval;
|
} while (!(isStop || capture == 1 || repeatTime <= 0));
|
|
if (repeatTime <= 0)
|
{
|
MoveStop((short)movingOption.AxisIndex, 0);
|
throw new ProcessException($"运动轴{movingOption.AxisIndex} ，回原点超时异常");
|
}
|
|
var axisStatus = AxisStatusList.FirstOrDefault(u => u.AxisIndex == movingOption.AxisIndex);
|
|
//if (isStop)
|
//{
|
// LogAsync(DateTime.Now, $"轴{movingOption.AxisIndex}复位中停止", $"Capture状态{capture}");
|
//}
|
|
if (isStop && capture != 1)
|
{
|
if (((axisStatus.AxisStatus & 0x20) != 0) || ((axisStatus.AxisStatus & 0x40) != 0))
|
{
|
capture = 0;
|
|
//正限位
|
if ((axisStatus.AxisStatus & 0x20) != 0 && !goHomePara.IsCaptureDirPositive)
|
{
|
isRightLimitReached = true;
|
}
|
|
//负限位
|
if ((axisStatus.AxisStatus & 0x40) != 0 && goHomePara.IsCaptureDirPositive)
|
{
|
isRightLimitReached = true;
|
}
|
|
homeDirection = !homeDirection;
|
|
LogAsync(DateTime.Now, $"轴{movingOption.AxisIndex}极限位置换向", "");
|
}
|
|
ClearStatus(movingOption.AxisIndex, 1);
|
}
|
|
if (capture == 1)
|
{
|
if (!isRightLimitReached)
|
{
|
capture = 0;
|
ClearStatus(movingOption.AxisIndex, 1);
|
//GTSCardAPI.GT_SetCaptureMode((short)IConfig.CardNum, (short)movingOption.AxisIndex, GTSCardAPI.CAPTURE_HOME);
|
continue;
|
}
|
|
//先stop
|
MoveStop((short)movingOption.AxisIndex, 0);
|
ClearStatus((short)movingOption.AxisIndex, 1);
|
|
//已经捕获到Home才可以回零 阶段2
|
// 运动到"捕获位置+偏移量"
|
sRtn = GTSCardAPI.GT_SetPos((short)IConfig.CardNum, (short)movingOption.AxisIndex, pos + goHomePara.HomeOffset);
|
// 在运动状态下更新目标位置
|
sRtn = GTSCardAPI.GT_Update((short)IConfig.CardNum, 1 << (movingOption.AxisIndex - 1));
|
isStop = false;
|
|
repeatTime = 1000;
|
do
|
{
|
Thread.Sleep(20);
|
isStop = IsStop((short)movingOption.AxisIndex);
|
repeatTime--;
|
} while (!isStop && repeatTime > 0);
|
PositionReset(movingOption.AxisIndex, 1);
|
LogAsync(DateTime.Now, $"轴{movingOption.AxisIndex}复位完成，位置清零", "");
|
|
return (sRtn == (short)GTSRetCode.GRCRunOK) && isStop;
|
}
|
|
} while (!(capture == 1 && isRightLimitReached));
|
|
return false;
|
}
|
catch (Exception ex)
|
{
|
LogAsync(DateTime.Now, $"{Name}回原点异常", ex.GetExceptionMessage());
|
AllMoveStop(true);
|
OnExceptionOccured?.Invoke(DateTime.Now, ex);
|
return false;
|
}
|
finally
|
{
|
|
}
|
}
|
|
/// <summary>
|
/// 读取IO输入
|
/// </summary>
|
/// <param name="cardNum">卡号</param>
|
/// <param name="index">输入口</param>
|
/// <returns>有输入返回true，无输入返回false</returns>
|
public bool GetDi(short cardNum, short index)
|
{
|
int value;
|
GTSCardAPI.GT_GetDi(cardNum, GTSCardAPI.MC_GPI, out value);
|
if ((value & (1 << index)) == 0) return true;//有输入返回true
|
else return false; //无输入返回false
|
}
|
|
/// <summary>
|
/// 读取IO输出
|
/// </summary>
|
/// <param name="index">io索引</param>
|
/// <returns></returns>
|
public bool GetDoSts(short index)
|
{
|
int 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="index">输出口,返回1-16</param>
|
/// <param name="value">false表示关，true表示开，板卡要设置取反</param>
|
public override void WriteOutput(short index, IOValue value)
|
{
|
short outNum = (short)(index % 100 + 1);
|
if ((int)value <= 1)
|
{
|
GTSCardAPI.GT_SetDoBit((short)IConfig.CardNum, GTSCardAPI.MC_GPO, outNum, IConfig.IsOutputReversed ? (short)(value == IOValue.TRUE ? 0 : 1) : (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>
|
/// <returns></returns>
|
public bool IsStop(short axisNum)
|
{
|
int sts = AxisStatusList.FirstOrDefault(u => u.AxisIndex == axisNum).AxisStatus;
|
if ((sts & 0x400) == 0) return true;//停止返回true
|
else return false; //运行中返回false
|
}
|
|
/// <summary>
|
/// 读取轴状态
|
/// </summary>
|
/// <param name="axisNum">轴号</param>
|
/// <returns></returns>
|
public override int GetAxisStatus(int axisNum)
|
{
|
//lock (moveLock)
|
{
|
int sts = 0;
|
uint pclock = 0;
|
GTSCardAPI.GT_GetSts((short)IConfig.CardNum, (short)axisNum, out sts, 1, out pclock);
|
return sts;
|
}
|
}
|
|
public override bool ClearStatus(int startAxisIndex, int count)
|
{
|
var rtn = GTSCardAPI.GT_ClrSts((short)IConfig.CardNum, (short)startAxisIndex, (short)count);
|
return rtn == (short)GTSRetCode.GRCRunOK;
|
}
|
|
/// <summary>
|
/// 位置回零
|
/// </summary>
|
/// <param name="startAxisIndex"></param>
|
/// <param name="count"></param>
|
/// <returns></returns>
|
public override bool PositionReset(int startAxisIndex, int count)
|
{
|
//lock (moveLock)
|
{
|
var rtn = GTSCardAPI.GT_ZeroPos((short)IConfig.CardNum, (short)startAxisIndex, (short)count);
|
return rtn == (short)GTSRetCode.GRCRunOK;
|
}
|
}
|
|
#endregion
|
|
#region IMonitor
|
|
public List<AxisMovingStatus> GetAxisMovingStatus()
|
{
|
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);
|
axisMovingStatus.AxisStatus = GetAxisStatus(axisMovingStatus.AxisIndex);
|
|
axisMovingStatusesList.Add(axisMovingStatus);
|
|
}
|
|
return axisMovingStatusesList;
|
}
|
|
public List<IOItem> GetMonitorValues()
|
{
|
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 = 0; 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;
|
}
|
|
SpinWait _positionWait = new SpinWait();
|
private async void MonitorPosition()
|
{
|
await Task.Run(() =>
|
{
|
while (CurrentState != EnumHelper.DeviceState.DSClose && CurrentState != EnumHelper.DeviceState.DSExcept && CurrentState != EnumHelper.DeviceState.DSUninit)
|
{
|
try
|
{
|
if (!IConfig.IsEnableMonitor)
|
return;
|
|
AxisStatusList.ForEach(a =>
|
{
|
int curPosition = (int)GetPrfPosition(a.AxisIndex);
|
|
if (a.CurPosition != curPosition)
|
{
|
a.CurPosition = curPosition;
|
AxisPositionChanged(a.AxisIndex, curPosition);
|
}
|
});
|
|
Task.Delay(100).Wait();
|
|
//_positionWait.SpinOnce();
|
}
|
catch (Exception ex)
|
{
|
if (CurrentState == DeviceState.DSOpen)
|
{
|
LogAsync(DateTime.Now, $"{this.Name}监听轴信息异常", ex.GetExceptionMessage());
|
}
|
}
|
}
|
});
|
}
|
|
SpinWait _statusWait = new SpinWait();
|
private async void MonitorAxisStatus()
|
{
|
await Task.Run(() =>
|
{
|
while (CurrentState != EnumHelper.DeviceState.DSClose && CurrentState != EnumHelper.DeviceState.DSExcept && CurrentState != EnumHelper.DeviceState.DSUninit)
|
{
|
try
|
{
|
if (!IConfig.IsEnableMonitor)
|
return;
|
|
AxisStatusList.ForEach(a =>
|
{
|
int curStatus = GetAxisStatus(a.AxisIndex);
|
|
if (a.AxisStatus != curStatus)
|
{
|
int temp = a.AxisStatus;
|
a.AxisStatus = curStatus;
|
AxisStatusChanged(a.AxisIndex, temp, curStatus);
|
}
|
});
|
|
Thread.Sleep(10);
|
//Task.Delay(10).Wait();
|
}
|
catch (Exception ex)
|
{
|
if (CurrentState == DeviceState.DSOpen)
|
{
|
LogAsync(DateTime.Now, $"{this.Name}监听轴信息异常", ex.GetExceptionMessage());
|
}
|
}
|
}
|
});
|
}
|
|
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)
|
continue;
|
|
//Stopwatch sw = new Stopwatch();
|
//sw.Start();
|
if (MonitorValues.Count == newValues.Count)
|
{
|
//var tempNew = newValues.DeepSerializeClone();//clone
|
//var tempOld = MonitorValues.DeepSerializeClone();
|
var tempNew = new List<IOItem>(newValues);//clone
|
var tempOld = new List<IOItem>(MonitorValues);
|
MonitorCheckAndInvoke(tempNew, tempOld);
|
}
|
|
//if (AxisStatusList.Count == newAxisMovingStatus.Count)
|
//{
|
// var tempNew = new List<AxisMovingStatus>(newAxisMovingStatus);//clone
|
// var tempOld = new List<AxisMovingStatus>(AxisStatusList);
|
// AxisStatusCheck(tempNew, tempOld);
|
//}
|
|
//AxisStatusList = 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());
|
}
|
}
|
}
|
});
|
}
|
|
private async void AxisStatusCheck(List<AxisMovingStatus> tempNew, List<AxisMovingStatus> tempOld)
|
{
|
await Task.Run(() =>
|
{
|
foreach (var newSts in tempNew)
|
{
|
var oldSts = tempOld.FirstOrDefault(u => u.AxisIndex == newSts.AxisIndex);
|
if (oldSts != null)
|
{
|
if (oldSts.AxisStatus != newSts.AxisStatus)
|
{
|
AxisStatusChanged(newSts.AxisIndex, oldSts.AxisStatus, newSts.AxisStatus);
|
}
|
|
if (((newSts.AxisStatus >> 1 & 1) == 1) && ((oldSts.AxisStatus >> 1 & 1) == 0)) //初次报警
|
{
|
AxisAlarmRaised(newSts.AxisStatus, $"轴{newSts.AxisIndex}:{newSts.AxisName}轴伺服报警");
|
}
|
}
|
}
|
});
|
}
|
|
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 == IOValue.TRUE ? 1 : 0;
|
//}).ToList();
|
monitorSet.OpConfig.InputPara = new List<int>() { (int)newIOItem.Value };
|
|
ExcuteMonitorInvoke(DateTime.Now, monitorSet.InvokeDevice, this, monitorSet);
|
}
|
}
|
});
|
#endregion
|
}
|
|
public override void ResetAlarm()
|
{
|
int axis_sts;
|
var axisSettings = IConfig.AxisSettings.FindAll(u => u.IsAxisEnabled);
|
ClearStatus(1, axisSettings.Count);
|
|
if (AxisStatusList.Count == 0)
|
{
|
Thread.Sleep(10);
|
}
|
|
foreach (var axisSetting in axisSettings)
|
{
|
//axis_sts = GetAxisStatus((short)axisSetting.AxisIndex);
|
axis_sts = AxisStatusList.FirstOrDefault(u => u.AxisIndex == axisSetting.AxisIndex)?.AxisStatus ?? 0;
|
if ((axis_sts & 0x200) == 0)
|
{
|
var rst = GTSCardAPI.GT_AxisOn((short)IConfig.CardNum, (short)axisSetting.AxisIndex);
|
}
|
//// 所有位置请零
|
//PositionReset(1, 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);
|
}
|
}
|
|
// 清除状态
|
ClearStatus(1, axisSettings.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
|
}
|
}
|
