C# 研华运动控制卡(PCI-1285)轴控制

阿杰_Jay

已于 2024-12-10 13:22:43 修改

阅读量2k

点赞数 11

分类专栏： c# 文章标签： c# 开发语言

于 2023-12-29 09:38:28 首次发布

本文链接：https://blog.csdn.net/qq_42417134/article/details/135283559

版权

c# 专栏收录该内容

19 篇文章

订阅专栏

博客围绕C#开发语言展开，虽未给出具体内容，但C#是后端开发常用语言，在软件开发等领域有广泛应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

using CommonLib.Communication;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
using WCSPro.Model;

namespace IDCL.Axis
{
    /// <summary>
    /// 轴控制接口
    /// </summary>
    public interface IAxis : IDisposable
    {
        /// <summary>
        /// 获取轴信息对象
        /// </summary>
        /// <returns></returns>
        AxisInfo GetAxisInfo();

        /// <summary>
        /// 连接轴
        /// </summary>
        /// <param name="axis">操作轴信息对象</param>
        /// <returns></returns>
        bool Connect(AxisInfo axis);

        /// <summary>
        /// 断开轴
        /// </summary>
        void Disconnect();

        /// <summary>
        /// 获取轴参数
        /// </summary>
        /// <param name="axis">轴信息对象</param>
        /// <returns></returns>
        bool GetAxisParameter(AxisInfo axis);

        /// <summary>
        /// 设置轴参数
        /// </summary>
        /// <param name="axis">轴信息对象</param>
        /// <returns></returns>
        bool SetAxisParameter(AxisInfo axis);

        /// <summary>
        /// 获取轴状态
        /// </summary>
        /// <param name="axis"></param>
        /// <returns></returns>
        bool GetAxisState(AxisInfo axis);

        /// <summary>
        /// 复位
        /// </summary>
        /// <returns></returns>
        bool Reset();

        /// <summary>
        /// 前进
        /// </summary>
        /// <param name="distance">前进距离,单位毫米。</param>
        /// <param name="mod">移动模式("Abs"-绝对位置移动，"Rel"-相对位置移动)。</param>
        /// <returns></returns>
        bool Forward(decimal distance, string mod);

        /// <summary>
        /// 后退
        /// </summary>
        /// <param name="distance">后退距离，单位毫米。</param>
        /// <param name="mod">移动模式("Abs"-绝对位置移动，"Rel"-相对位置移动)。</param>
        /// <returns></returns>
        bool Backward(decimal distance, string mod);

        /// <summary>
        /// 停止
        /// </summary>
        /// <returns></returns>
        bool Stop();
    }
}

using DCL.Motion.Advantech;
using IDCL.Axis;
using IDCL.Motion.BaseModel;
using IDCL.Motion2;
using Prism.Common;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Resources;
using System.Text;
using System.Threading.Tasks;
using WCSPro.Model;

namespace DCL.Axis
{
    /// <summary>
    /// 研华运动控制卡(PCI-1285)轴控制实现类
    /// </summary>
    public class AdvMotPCI1285Axis : IAxis
    {
        public AdvMotPCI1285Axis(IMotion2 motion)
        {
            this.Motion = motion;
        }

        private IMotion2 Motion { get; set; }

        private AxisInfo Axis { get; set; }

        public AxisInfo GetAxisInfo()
        {
            return this.Axis;
        }

        public bool Connect(AxisInfo axis)
        {
            if (this.Motion == null) return false;
            MotionInfo motionInfo = axis.OtherInfo["MotionInfo"] as MotionInfo;
            if (motionInfo == null) return false;
            if (!this.Motion.Connect(motionInfo)) return false;
            this.Axis = axis;
            if (this.Axis != null && this.Axis.ConnectState == "Connected")
            {
                Disconnect();
            }
            IntPtr axHandle = IntPtr.Zero;
            IntPtr devHandle = new IntPtr(Convert.ToInt64(motionInfo.OtherInfo["Handle"]));
            ushort axIndex = Convert.ToUInt16(this.Axis.Code);
            var iRet = AdvMotAPI.Acm_AxOpen(devHandle, axIndex, ref axHandle);
            if (iRet != 0) return false;
            this.Axis.ConnectState = "Connected";
            this.Axis.OtherInfo["Handle"] = axHandle.ToInt64();
            return true;
        }

        public void Disconnect()
        {
            if (this.Axis == null) return;
            if (this.Axis.ConnectState == "UnConnected") return;
            IntPtr handle = new IntPtr(Convert.ToInt64(this.Axis.OtherInfo["Handle"]));
            ushort axisState = 0;
            //获取轴状态
            var iRet = AdvMotAPI.Acm_AxGetState(handle, ref axisState);
            if (iRet != 0) throw new Exception($"Failed to obtain axis status!");
            if (axisState == (ushort)AxisState.STA_AX_ERROR_STOP)
            {
                //重置轴异常状态
                iRet = AdvMotAPI.Acm_AxResetError(handle);
                if (iRet != 0) throw new Exception($"Reset axis failed!");
            }
            //停止轴运动
            iRet = AdvMotAPI.Acm_AxStopDec(handle);
            if (iRet != 0) throw new Exception("Failed to stop axis movement!");
            //关闭轴
            iRet = AdvMotAPI.Acm_AxClose(ref handle);
            if (iRet == 0)
            {
                this.Axis.OtherInfo["Handle"] = null;
                this.Axis.ConnectState = "UnConnected";
            }
            else
            {
                throw new Exception($"Close axis error({iRet})");
            }
        }


        public bool Reset()
        {
            if (this.Axis == null) return false;
            if (this.Axis.ConnectState == "UnConnected") return false;
            IntPtr handle = new IntPtr(Convert.ToInt64(this.Axis.OtherInfo["Handle"]));
            // 异常状态复位
            var iRet = AdvMotAPI.Acm_AxResetError(handle);
            if (iRet != 0) throw new Exception("Reset axis failed!");

            // todo 轴回原点

            // 复位脉冲计数器
            iRet = AdvMotAPI.Acm_AxSetCmdPosition(handle, 0);
            if (iRet != 0) throw new Exception("Reset axis failed!");
            iRet = AdvMotAPI.Acm_AxSetActualPosition(handle, 0);
            if (iRet != 0) throw new Exception("Reset axis failed!");
            return true;
        }

        public bool Forward(decimal distance, string mod)
        {
            if (this.Axis == null) return false;
            if (this.Axis.ConnectState == "UnConnected") return false;
            decimal factor = Convert.ToDecimal(this.Axis.OtherInfo["Factor"]);//获取脉冲与距离转换系数
            double pulseCount = Convert.ToDouble(distance * factor);//计算脉冲数
            IntPtr handle = new IntPtr(Convert.ToInt64(this.Axis.OtherInfo["Handle"]));//获取轴操作句柄
            uint iRet;
            iRet = AdvMotAPI.Acm_AxSetSvOn(handle, 1u);//开伺服
            if (iRet != 0) return false;
            if (mod == "Abs")
            {
                iRet = AdvMotAPI.Acm_AxMoveAbs(handle, pulseCount);//绝对移动
            }
            else
            {
                iRet = AdvMotAPI.Acm_AxMoveRel(handle, pulseCount);//相对移动
            }
            if (iRet != 0) return false;
            uint axState = WaitAxisStop(handle, 30 * 1000);//等待轴运动停止
            return axState == 1;//判断轴是否正常停止并返回
        }

        public bool Backward(decimal distance, string mod)
        {
            if (this.Axis == null) return false;
            if (this.Axis.ConnectState == "UnConnected") return false;
            decimal factor = Convert.ToDecimal(this.Axis.OtherInfo["Factor"]); //获取脉冲与距离转换系数
            double pulseCount = -1 * Convert.ToDouble(distance * factor); //计算脉冲数
            IntPtr handle = new IntPtr(Convert.ToInt64(this.Axis.OtherInfo["Handle"]));//获取轴操作句柄
            uint iRet;
            iRet = AdvMotAPI.Acm_AxSetSvOn(handle, 0u);//开伺服
            if (mod == "Abs")
            {
                iRet = AdvMotAPI.Acm_AxMoveAbs(handle, pulseCount);//绝对移动
            }
            else
            {
                iRet = AdvMotAPI.Acm_AxMoveRel(handle, pulseCount);//相对移动
            }
            if (iRet != 0) return false;
            uint axState = WaitAxisStop(handle, 30 * 1000);//等待轴运动停止
            return axState == 1;//判断轴是否正常停止并返回
        }

        /// <summary>
        /// 等待轴运动停止
        /// </summary>
        /// <param name="handle">轴操作句柄</param>
        /// <param name="timeout">超时时间，单位毫秒。</param>
        /// <returns></returns>
        private uint WaitAxisStop(IntPtr handle, int timeout)
        {
            ushort axState = 0;
            Stopwatch sw = Stopwatch.StartNew();
            while (sw.ElapsedMilliseconds <= timeout)
            {
                AdvMotAPI.Acm_AxGetState(handle, ref axState);
                if (axState == 1 || axState == 3)
                {
                    return axState;
                }
            }
            sw.Stop();
            return axState;
        }

        public bool Stop()
        {
            if (this.Axis == null) return false;
            if (this.Axis.ConnectState == "UnConnected") return false;
            IntPtr handle = new IntPtr(Convert.ToInt64(this.Axis.OtherInfo["Handle"]));//获取轴操作句柄
            var iRet = AdvMotAPI.Acm_AxStopDec(handle);//停止轴运动
            if (iRet != 0)
            {
                throw new Exception("Stop axis failed!");
            }
            uint axState = WaitAxisStop(handle, 30 * 1000);//等待轴运动停止
            return axState == 1;//判断轴是否正常停止并返回
        }

        public bool GetAxisParameter(AxisInfo axis)
        {
            if (this.Axis == null) return false;
            if (this.Axis.ConnectState == "UnConnected") return false;
            IntPtr handle = new IntPtr(Convert.ToInt64(this.Axis.OtherInfo["Handle"]));//获取轴操作句柄
            double value = 0;
            uint iRet = AdvMotAPI.Acm_GetF64Property(handle, PropertyID.PAR_AxVelLow, ref value);
            if (iRet != 0) throw new Exception("Failed to obtain axis parameters!");
            axis.OtherInfo["VelL"] = value;

            iRet = AdvMotAPI.Acm_GetF64Property(handle, PropertyID.PAR_AxVelHigh, ref value);
            if (iRet != 0) throw new Exception("Failed to obtain axis parameters!");
            axis.OtherInfo["VelH"] = value;

            iRet = AdvMotAPI.Acm_GetF64Property(handle, PropertyID.PAR_AxAcc, ref value);
            if (iRet != 0) throw new Exception("Failed to obtain axis parameters!");
            axis.OtherInfo["Acc"] = value;

            iRet = AdvMotAPI.Acm_GetF64Property(handle, PropertyID.PAR_AxDec, ref value);
            if (iRet != 0) throw new Exception("Failed to obtain axis parameters!");
            axis.OtherInfo["Dec"] = value;

            iRet = AdvMotAPI.Acm_GetF64Property(handle, PropertyID.PAR_AxJerk, ref value);
            if (iRet != 0) throw new Exception("Failed to obtain axis parameters!");
            axis.OtherInfo["Jerk"] = value;

            return true;
        }

        public bool SetAxisParameter(AxisInfo axis)
        {
            if (this.Axis == null) return false;
            if (this.Axis.ConnectState == "UnConnected") return false;
            double velL = Convert.ToDouble(axis.OtherInfo["VelL"]);
            double velH = Convert.ToDouble(axis.OtherInfo["VelH"]);
            double acc = Convert.ToDouble(axis.OtherInfo["Acc"]);
            double dec = Convert.ToDouble(axis.OtherInfo["Dec"]);
            double jerk = Convert.ToDouble(axis.OtherInfo["Jerk"]);
            IntPtr handle = new IntPtr(Convert.ToInt64(this.Axis.OtherInfo["Handle"]));//获取轴操作句柄
            var iRet = AdvMotAPI.Acm_SetF64Property(handle, PropertyID.PAR_AxVelLow, velL);
            if (iRet != 0) throw new Exception("Failed to set axis parameters!");
            iRet = AdvMotAPI.Acm_SetF64Property(handle, PropertyID.PAR_AxVelHigh, velH);
            if (iRet != 0) throw new Exception("Failed to set axis parameters!");
            iRet = AdvMotAPI.Acm_SetF64Property(handle, PropertyID.PAR_AxAcc, acc);
            if (iRet != 0) throw new Exception("Failed to set axis parameters!");
            iRet = AdvMotAPI.Acm_SetF64Property(handle, PropertyID.PAR_AxDec, dec);
            if (iRet != 0) throw new Exception("Failed to set axis parameters!");
            iRet = AdvMotAPI.Acm_SetF64Property(handle, PropertyID.PAR_AxJerk, jerk);
            if (iRet != 0) throw new Exception("Failed to set axis parameters!");
            return GetAxisParameter(axis);
        }

        public void Dispose()
        {
            Disconnect();
            this.Axis = null;
            this.Motion.Dispose();
        }

        public bool GetAxisState(AxisInfo axis)
        {
            if (this.Axis == null) return false;
            if (this.Axis.ConnectState == "UnConnected") return false;
            IntPtr handle = new IntPtr(Convert.ToInt64(this.Axis.OtherInfo["Handle"]));//获取轴操作句柄
            ushort axState = 0;
            var iRet = AdvMotAPI.Acm_AxGetState(handle, ref axState);
            if (iRet == 0)
            {
                axis.AxisState = ((AxisState)axState).ToString();
                return true;
            }
            else
            {
                throw new Exception("Failed to obtain axis status!");
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WCSPro.Model;

namespace IDCL.Axis
{
    /// <summary>
    /// 三轴(模组)接口
    /// </summary>
    public interface IXYZAxes : IDisposable
    {
        /// <summary>
        /// 初始化(包含连接)
        /// </summary>
        /// <returns></returns>
        bool Init();

        /// <summary>
        /// 回零
        /// </summary>
        /// <returns></returns>
        bool Home();

        /// <summary>
        /// 定位到晶圆圆心(扫描基点)
        /// </summary>
        /// <returns></returns>
        bool ToCenter();

        /// <summary>
        /// 设置X轴参数
        /// </summary>
        /// <param name="axisName">轴名称("X","Y","Z")</param>
        /// <param name="parameterName">参数名，详见实现类。</param>
        /// <param name="parameterValue">参数值，详见实现类。</param>
        /// <returns></returns>
        bool SetAxisParameters(string axisName, string parameterName, string parameterValue);

        /// <summary>
        /// X轴移动
        /// </summary>
        /// <param name="distance">移动距离(mm)，正数为正方向，负数为负方向。</param>
        /// <param name="mod">移动模式("Abs"-绝对位置移动，"Rel"-相对位置移动)。</param>
        /// <returns></returns>
        bool XMove(decimal distance, string mod);

        /// <summary>
        /// Y轴移动
        /// </summary>
        /// <param name="distance">移动距离(mm)，正数为正方向，负数为负方向。</param>
        /// <param name="mod">移动模式("Abs"-绝对位置移动，"Rel"-相对位置移动)。</param>
        /// <returns></returns>
        bool YMove(decimal distance, string mod);

        /// <summary>
        /// Z轴移动
        /// </summary>
        /// <param name="distance">移动距离(mm)，正数为正方向，负数为负方向。</param>
        /// <param name="mod">移动模式("Abs"-绝对位置移动，"Rel"-相对位置移动)。</param>
        /// <returns></returns>
        bool ZMove(decimal distance, string mod);

        /// <summary>
        /// 位置移动
        /// </summary>
        /// <param name="pos">位置信息</param>
        /// <returns></returns>
        bool PositionMove(XYZAxesPosition pos);

        /// <summary>
        /// 停止
        /// </summary>
        /// <returns></returns>
        bool Stop();

        /// <summary>
        /// 清除错误
        /// </summary>
        /// <param name="axisName">轴名称("X"、"Y"、"X")，可空，如果为空则复位所有轴的错误。</param>
        /// <returns></returns>
        bool RestError(string axisName);

        /// <summary>
        /// 读取XYZ的位置
        /// </summary>
        /// <param name="mode">位置模式。"Cmd"-command position、"Actual"-actual position。</param>
        /// <returns>返回一个包含Key为"X"、"Y"、"Z"的字典。值单位为毫秒，如果值为null表示该点读取失败。</returns>
        Dictionary<string, decimal?> GetXYZPosition(string mode);

        /// <summary>
        /// 获取三轴状态
        /// </summary>
        /// <returns>
        /// 返回一个包含Key为"X"、"Y"、"Z"的字典。如果返回null表示获取失败。
        /// 研华：状态详见AdvMotAPI类的Acm_AxGetState函数说明。
        /// </returns>
        Dictionary<string, string> GetXYZStates();
    }
}

using Aitex.Core.Backend;
using CommonLib.SerializerUtils;
using DCL.Motion.Advantech;
using IDCL.Axis;
using IDCL.IMotionDCL;
using IDCL.Motion2;
using Prism.Ioc;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
using WCSPro.IDAL;
using WCSPro.Model;

namespace DCL.Axis
{
    /// <summary>
    /// 三轴模组控制实现类
    /// </summary>
    public class XYZAxes : IXYZAxes
    {
        public XYZAxes(IContainerProvider provider)
        {
            Motion = provider.Resolve<IMotionCard>("Advantech");
            PositionDAL = provider.Resolve<IXYZAxesPositionDAL>();
        }

        public void Dispose()
        {

        }

        /// <summary>
        /// XYZ轴字典(// todo 轴名称对应轴号)
        /// </summary>
        private Dictionary<string, uint> Axes { get; set; } = new Dictionary<string, uint>()
        {
            { "X", 1u },
            { "Y", 2u },
            { "Z", 3u },
        };

        private IMotionCard Motion { get; }

        private IXYZAxesPositionDAL PositionDAL { get; }

        public bool Init()
        {
            var ls = this.Motion.GetCardNames();
            if (ls == null || ls.Count == 0) return false;
            string cfgFile = Path.Combine(AppContext.BaseDirectory, "Config", "Motion.cfg");
            if (!File.Exists(cfgFile)) return false;
            if (!this.Motion.Init(ls[0], cfgFile)) return false;
            //直接把三轴的伺服全部打开
            if (!this.Motion.SetSVState(Axes["X"], "Open")) return false;
            if (!this.Motion.SetSVState(Axes["Y"], "Open")) return false;
            if (!this.Motion.SetSVState(Axes["Z"], "Open")) return false;
            return true;
        }

        /// <summary>
        /// 设置轴参数
        /// </summary>
        /// <param name="axisName">轴名称("X","Y","Z")</param>
        /// <param name="parameterName">
        /// 参数名。
        /// AxVelLow：轴的起始速度，单位：PPU/S。
        /// AxVelHigh：轴的运行速度，单位：PPU/s。
        /// AxAcc：轴的加速度。单位：PPU/s2。
        /// AxDec：轴的减速度。单位：PPU/s2。
        /// AxJerk：速度类型(0：T型、1：S型)。
        /// </param>
        /// <param name="parameterValue">参数值</param>
        /// <returns></returns>
        public bool SetAxisParameters(string axisName, string parameterName, string parameterValue)
        {
            string sAxis = axisName.ToUpper();
            return this.Motion.SetAxisParameters(Axes[sAxis], parameterName, parameterValue);
        }

        private uint homeMod = 11u;
        private uint dirX = 1u;
        private uint dirY = 1u;
        private uint dirZ = 1u;

        public bool Home()
        {
            if (!this.Motion.AxisHome(Axes["Z"], homeMod, dirZ)) return false;
            var bRet = WaitTrue(() =>//先保证Z轴归零
            {
                var r = this.Motion.GetAxisState(Axes["Z"]);
                return r == AxisState.STA_AX_READY.ToString();
            }, 1000 * 60);
            if (!bRet) return false;//Z轴归零失败
            if (!this.Motion.AxisHome(Axes["X"], homeMod, dirX)) return false;
            if (!this.Motion.AxisHome(Axes["Y"], homeMod, dirY)) return false;
            bRet = WaitTrue(() =>//再确认XY轴归零状态
            {
                var rX = this.Motion.GetAxisState(Axes["X"]);
                bool bX = rX == AxisState.STA_AX_READY.ToString();
                if (!bX) return false;
                var rY = this.Motion.GetAxisState(Axes["Y"]);
                return rY == AxisState.STA_AX_READY.ToString();
            }, 1000 * 60);
            return bRet;
        }

        public bool Stop()
        {
            if (!this.Motion.AxisStop(Axes["X"], "EMO")) return false;
            if (!this.Motion.AxisStop(Axes["Y"], "EMO")) return false;
            if (!this.Motion.AxisStop(Axes["Z"], "EMO")) return false;
            var bRet = WaitTrue(() =>//确认XY轴是否已停止
            {
                var rX = this.Motion.GetAxisState(Axes["X"]);
                bool bX = rX == AxisState.STA_AX_READY.ToString();
                if (!bX) return false;
                var rY = this.Motion.GetAxisState(Axes["Y"]);
                var bY = rY == AxisState.STA_AX_READY.ToString();
                if (!bY) return false;
                var rZ = this.Motion.GetAxisState(Axes["Z"]);
                return rZ == AxisState.STA_AX_READY.ToString();
            }, 1000 * 60);
            return bRet;
        }

        public bool ToCenter()
        {
            var pos = PositionDAL.GetPositionByName("Center");
            if (pos == null) return false;
            return PositionMove(pos);
            先Z轴归零
            //if (this.Motion.AxisHome(Axes["Z"], homeMod, dirZ)) return false;
            //var bRet = WaitTrue(() =>//先保证Z轴在零点先移动XY轴
            //{
            //    var r = this.Motion.GetAxisState(Axes["Z"]);
            //    return r == AxisState.STA_AX_READY.ToString();
            //}, 1000 * 60);
            //if (!bRet) return false;//Z轴归零失败

            //decimal x = 20; // todo X轴圆心位置
            //decimal y = 20; // todo Y轴圆心位置
            //decimal z = 20; // todo Z轴圆心位置

            //if (!this.Motion.AxisMove(Axes["X"], x, "Abs")) return false;
            //if (!this.Motion.AxisMove(Axes["Y"], y, "Abs")) return false;
            //if (!this.Motion.AxisMove(Axes["Z"], z, "Abs")) return false;
            //bRet = WaitTrue(() =>//确认XY轴是否已停止
            //{
            //    var rX = this.Motion.GetAxisState(Axes["X"]);
            //    bool bX = rX == AxisState.STA_AX_READY.ToString();
            //    if (!bX) return false;
            //    var rY = this.Motion.GetAxisState(Axes["Y"]);
            //    var bY = rY == AxisState.STA_AX_READY.ToString();
            //    if (!bY) return false;
            //    var rZ = this.Motion.GetAxisState(Axes["Z"]);
            //    return rZ == AxisState.STA_AX_READY.ToString();
            //}, 1000 * 60);
            //return bRet;
        }

        public bool XMove(decimal distance, string mod)
        {
            decimal coefficient = 0.001m;//一个脉冲走0，001mm
            if (!this.Motion.AxisMove(Axes["X"], distance / coefficient, mod)) return false;

            return WaitTrue(() =>//先保证Z轴在零点先移动XY轴
            {
                var r = this.Motion.GetAxisState(Axes["X"]);
                return r == AxisState.STA_AX_READY.ToString();
            }, 1000 * 60);
        }

        public bool YMove(decimal distance, string mod)
        {
            decimal coefficient = 0.001m;//一个脉冲走0，001mm
            if (!this.Motion.AxisMove(Axes["Y"], distance / coefficient, mod)) return false;

            return WaitTrue(() =>//先保证Z轴在零点先移动XY轴
            {
                var r = this.Motion.GetAxisState(Axes["Y"]);
                return r == AxisState.STA_AX_READY.ToString();
            }, 1000 * 60);
        }

        public bool ZMove(decimal distance, string mod)
        {
            decimal coefficient = 0.001m;//一个脉冲走0，001mm
            if (!this.Motion.AxisMove(Axes["Z"], distance / coefficient, mod)) return false;

            return WaitTrue(() =>//先保证Z轴在零点先移动XY轴
            {
                var r = this.Motion.GetAxisState(Axes["Z"]);
                return r == AxisState.STA_AX_READY.ToString();
            }, 1000 * 60);
        }

        public bool PositionMove(XYZAxesPosition pos)
        {
            decimal coefficientX = 0.001m;
            decimal coefficientY = 0.001m;
            decimal coefficientZ = 0.001m;

            //先Z轴归零
            if (this.Motion.AxisHome(Axes["Z"], homeMod, dirZ)) return false;
            var bRet = WaitTrue(() =>//先保证Z轴在零点先移动XY轴
            {
                var r = this.Motion.GetAxisState(Axes["Z"]);
                return r == AxisState.STA_AX_READY.ToString();
            }, 1000 * 60);

            //再动XY轴
            if (!this.Motion.AxisMove(Axes["X"], pos.DistanceX / coefficientX, "Abs")) return false;
            if (!this.Motion.AxisMove(Axes["Y"], pos.DistanceY / coefficientY, "Abs")) return false;
            bRet = WaitTrue(() =>//确认XY轴是否已停止
            {
                var rX = this.Motion.GetAxisState(Axes["X"]);
                bool bX = rX == AxisState.STA_AX_READY.ToString();
                if (!bX) return false;
                var rY = this.Motion.GetAxisState(Axes["Y"]);
                return rY == AxisState.STA_AX_READY.ToString();
            }, 1000 * 60);

            if (!bRet) return false;

            //最后动Z轴
            if (!this.Motion.AxisMove(Axes["Z"], pos.DistanceZ / coefficientZ, "Abs")) return false;
            bRet = WaitTrue(() =>//确认Z轴是否已停止
            {
                var rZ = this.Motion.GetAxisState(Axes["Z"]);
                return rZ == AxisState.STA_AX_READY.ToString();
            }, 1000 * 60);
            return bRet;
        }

        public Dictionary<string, decimal?> GetXYZPosition(string mode)
        {
            decimal coefficientX = mode.ToUpper() == "ACTUAL" ? 0.001m / 0.8192m : 0.001m;//一个脉冲走0，001mm
            decimal coefficientY = mode.ToUpper() == "ACTUAL" ? 0.001m / 0.8192m : 0.001m;//一个脉冲走0，001mm
            decimal coefficientZ = mode.ToUpper() == "ACTUAL" ? 0.001m / 0.8192m : 0.001m;//一个脉冲走0，001mm
            Dictionary<string, decimal?> oRet = new Dictionary<string, decimal?>();
            oRet["X"] = this.Motion.GetAxisPosition(Axes["X"], mode) * coefficientX;
            oRet["Y"] = this.Motion.GetAxisPosition(Axes["Y"], mode) * coefficientY;
            oRet["Z"] = this.Motion.GetAxisPosition(Axes["Z"], mode) * coefficientZ;
            if (oRet["X"].HasValue) oRet["X"] = Math.Round(oRet["X"].Value, 2, MidpointRounding.AwayFromZero);
            if (oRet["Y"].HasValue) oRet["Y"] = Math.Round(oRet["Y"].Value, 2, MidpointRounding.AwayFromZero);
            if (oRet["Z"].HasValue) oRet["Z"] = Math.Round(oRet["Z"].Value, 2, MidpointRounding.AwayFromZero);
            return oRet;
        }

        /// <summary>
        /// 等待业务返回true
        /// </summary>
        /// <param name="fun">等待逻辑</param>
        /// <param name="timeout">超时时间</param>
        /// <returns></returns>
        private bool WaitTrue(Func<bool> fun, int timeout)
        {
            Stopwatch sw = Stopwatch.StartNew();
            while (sw.ElapsedMilliseconds <= timeout)
            {
                if (fun()) return true;
            }
            return false;
        }

        public bool RestError(string axisName)
        {
            if (string.IsNullOrWhiteSpace(axisName))
            {
                if (!this.Motion.AxisResetError(Axes["X"])) return false;
                if (!this.Motion.AxisResetError(Axes["Y"])) return false;
                return this.Motion.AxisResetError(Axes["Z"]);
            }
            else
            {
                var axName = axisName.ToUpper();
                if (!this.Axes.ContainsKey(axName)) return false;
                return this.Motion.AxisResetError(Axes[axName]);
            }
        }

        /// <summary>
        /// 获取三轴状态
        /// </summary>
        /// <returns>
        /// 返回一个包含Key为"X"、"Y"、"Z"的字典。如果返回null表示获取失败。
        /// 研华：状态详见AdvMotAPI类的Acm_AxGetState函数说明。
        /// </returns>
        public Dictionary<string, string> GetXYZStates()
        {
            Dictionary<string, string> oRet = new Dictionary<string, string>();

            string state = this.Motion.GetAxisState(Axes["X"]);
            if (string.IsNullOrWhiteSpace(state)) return null;
            oRet["X"] = state;

            state = this.Motion.GetAxisState(Axes["Y"]);
            if (string.IsNullOrWhiteSpace(state)) return null;
            oRet["Y"] = state;

            state = this.Motion.GetAxisState(Axes["Z"]);
            if (string.IsNullOrWhiteSpace(state)) return null;
            oRet["Z"] = state;

            return oRet;

        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace IDCL.IMotionDCL
{
    /// <summary>
    /// 运动控制卡接口
    /// </summary>
    public interface IMotionCard : IDisposable
    {
        /// <summary>
        /// 初始化运动控制卡
        /// </summary>
        /// <param name="parameters">初始化参数，详见实现类</param>
        /// <returns>布尔值</returns>
        bool Init(params object[] parameters);

        /// <summary>
        /// 获取所有运动控制卡名称集合
        /// </summary>
        /// <returns>运动控制卡名称集合</returns>
        List<string> GetCardNames();

        /// <summary>
        /// 获取运动控制卡名称
        /// </summary>
        /// <returns>运动控制卡名称(当板卡被释放时获取为空字符串)</returns>
        string GetCardName();

        /// <summary>
        /// 设置指定轴的伺服状态
        /// </summary>
        /// <param name="axSN">轴序号(从1开始)</param>
        /// <param name="state">伺服状态。"Open"-打开伺服、"Close"-关闭伺服。</param>
        /// <returns>布尔值</returns>
        bool SetSVState(uint axSN, string state);

        /// <summary>
        /// 设置轴参数
        /// </summary>
        /// <param name="axSN">轴序号(从1开始)</param>
        /// <param name="parameterName">参数名(详见实现类)</param>
        /// <param name="parameterValue">参数值(详见实现类)</param>
        /// <returns></returns>
        bool SetAxisParameters(uint axSN, string parameterName, string parameterValue);

        /// <summary>
        /// 复位轴错误
        /// </summary>
        /// <param name="axSN">轴序号(从1开始)</param>
        /// <returns></returns>
        bool AxisResetError(uint axSN);

        /// <summary>
        /// 获取轴状态
        /// </summary>
        /// <param name="axSN">轴序号(从1开始)</param>
        /// <returns>状态字符串，获取制作返回空字符串。</returns>
        string GetAxisState(uint axSN);

        /// <summary>
        /// 获取轴位置
        /// </summary>
        /// <param name="axSN">轴序号(从1开始)</param>
        /// <param name="model">位置模式(详见实现类)</param>
        /// <returns>distance</returns>
        decimal? GetAxisPosition(uint axSN, string model);


        /// <summary>
        /// 指定轴归零
        /// </summary>
        /// <param name="axSN">轴序号(从1开始</param>
        /// <param name="mod">回零模式，详见实现类</param>
        /// <param name="dir">回零方向，0-正方向、1-负方向。</param>
        /// <returns></returns>
        bool AxisHome(uint axSN, uint mod, uint dir);

        /// <summary>
        /// 设置轴位置(不运动，只是设置寄存器)
        /// </summary>
        /// <param name="axSN">轴序号(从1开始)</param>
        /// <param name="distance">距离值，负数为反向位置，正数为正向位置，单位待定。</param>
        /// <param name="model">位置模式(详见实现类)</param>
        /// <returns></returns>
        bool SetAxisPosition(uint axSN, decimal distance, string model);

        /// <summary>
        /// 轴移动
        /// </summary>
        /// <param name="axSN">轴序号(从1开始)</param>
        /// <param name="ppu">移动距离(脉冲数)，负数为反向移动，正数为正向移动。</param>
        /// <param name="model">移动模式。"Rel"-相对距离移动、"Abs"-绝对距离移动。</param>
        /// <returns>布尔值</returns>
        bool AxisMove(uint axSN, decimal ppu, string model);

        /// <summary>
        /// 伺服转动
        /// </summary>
        /// <param name="axSN">轴序号(从1开始)</param>
        /// <param name="model">转动方向。"+"：表示正方向，"-"：表示反方向</param>
        /// <returns></returns>
        bool AxisRun(uint axSN, string model);

        /// <summary>
        /// 指定轴停止
        /// </summary>
        /// <param name="axSN">轴序号(从1开始)</param>
        /// <param name="model">停止模式。"DES"-减速停止、EMO-立即停止</param>
        /// <returns>布尔值</returns>
        bool AxisStop(uint axSN, string model);

    }
}

using CommonLib.LogUtils.Log4netIoC;
using IDCL.IMotionDCL;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DCL.MotionDCL.Advantech
{
    /// <summary>
    /// 研华PCI1285运动控制卡
    /// </summary>
    public class AdvMotPCI1285 : IMotionCard
    {
        public AdvMotPCI1285(ILogger<AdvMotPCI1285> logger)
        {
            this.Logger = logger;
        }

        /// <summary>
        /// 释放资源
        /// </summary>
        public void Dispose()
        {
            bool bRet = false;
            bRet = this.CloseAxes(); // 关闭所有轴(轴缓存)
            if (!bRet) return;
            CloseCard(); // 关闭板卡
        }

        /// <summary>
        /// 初始化运动控制卡
        /// </summary>
        /// <param name="parameters">第一个参数为板卡名称，第二个参数为初始化文件存放路径</param>
        /// <returns>布尔值</returns>
        public bool Init(params object[] parameters)
        {
            try
            {
                if (CardHandle != IntPtr.Zero) return true; //判断是否已初始化过
                if (parameters.Length < 2) return false; //判断初始化参数长度是否正确
                string cardName = parameters[0].ToString().ToUpper(); //板名称(大写)
                string initFilePath = parameters[1].ToString(); //板卡初始化加载文件路径

                var ls = AdvMotAPI.GetCardInfoList(); //获取所有板卡信息结构体集合
                if (ls == null || ls.Length <= 0) return false;
                this.CardInfo = ls.Single(t => t.DeviceName.ToUpper() == cardName); //得到当前板卡信息结构体

                CardHandle = OpenCard(); //打开板卡
                if (CardHandle == IntPtr.Zero) return false;
                if (!OpenAxes()) return false;

                var iRet = AdvMotAPI.Acm_DevLoadConfig(CardHandle, initFilePath); //加载初始化文件
                if (iRet != 0) throw new Exception("加载Init初始化文件失败！");

                return true; //打开所有轴
            }
            catch (Exception ex)
            {
                this.Dispose();
                if (this.CardInfo.HasValue) CardInfo = null;
                string err =
                    $"类：{this.GetType()}。\r\n方法：{System.Reflection.MethodBase.GetCurrentMethod()}\r\n错误信息：{ex.Message}";
                Logger.Error(err, ex);
                return false;
            }
        }

        public List<string> GetCardNames()
        {
            var ls = AdvMotAPI.GetCardInfoList(); //获取所有板卡信息结构体集合
            if (ls == null || ls.Length <= 0) return null;
            return ls.Select(t => t.DeviceName).ToList();
        }

        public string GetCardName()
        {
            return CardInfo == null ? string.Empty : CardInfo?.DeviceName;
        }

        public bool SetSVState(uint axSN, string state)
        {
            if (!AxesCache.ContainsKey(axSN)) return false;
            if (AxesCache[axSN] == IntPtr.Zero) return false;
            uint iState = state.ToUpper() == "OPEN" ? 1u : 0u;
            var iRet = AdvMotAPI.Acm_AxSetSvOn(AxesCache[axSN], iState);
            return iRet == 0;
        }

        /// <summary>
        /// 设置轴参数
        /// </summary>
        /// <param name="axSN">轴序号(从1开始)</param>
        /// <param name="parameterName">
        /// 参数名。
        /// AxVelLow：轴的起始速度，单位：PPU/S。
        /// AxVelHigh：轴的运行速度，单位：PPU/s。
        /// AxAcc：轴的加速度。单位：PPU/s2。
        /// AxDec：轴的减速度。单位：PPU/s2。
        /// AxJerk：速度类型(0：T型、1：S型)，类型double。
        /// </param>
        /// <param name="parameterValue">参数值</param>
        /// <returns></returns>
        public bool SetAxisParameters(uint axSN, string parameterName, string parameterValue)
        {
            if (!AxesCache.ContainsKey(axSN)) return false;
            if (AxesCache[axSN] == IntPtr.Zero) return false;
            AdvMotAPI.PropertyID propertyId = (AdvMotAPI.PropertyID)Enum.Parse(typeof(AdvMotAPI.PropertyID), $"PAR_{parameterName}");
            double value = Convert.ToDouble(parameterValue);
            var iRet = AdvMotAPI.Acm_SetF64Property(AxesCache[axSN], propertyId, value);
            return iRet == 0;
        }

        public bool AxisResetError(uint axSN)
        {
            if (!AxesCache.ContainsKey(axSN)) return false;
            if (AxesCache[axSN] == IntPtr.Zero) return false;
            var iRet = AdvMotAPI.Acm_AxResetError(AxesCache[axSN]);
            return iRet == 0;
        }

        /// <summary>
        /// 获取轴状态
        /// </summary>
        /// <param name="axSN">轴序号(从1开始)</param>
        /// <returns>返回AxisState枚举类型字符串</returns>
        public string GetAxisState(uint axSN)
        {
            if (!AxesCache.ContainsKey(axSN)) return string.Empty;
            if (AxesCache[axSN] == IntPtr.Zero) return string.Empty;
            ushort iState = 0;
            var iRet = AdvMotAPI.Acm_AxGetState(AxesCache[axSN], ref iState);
            if (iRet != 0) return string.Empty;
            return ((AdvMotAPI.AxisState)iState).ToString();
        }

        /// <summary>
        /// 获取轴位置
        /// </summary>
        /// <param name="axSN">轴序号(从1开始)</param>
        /// <param name="model">位置模式。"Cmd"-command position、"Actual"-actual position。</param>
        /// <returns>distance</returns>
        public decimal? GetAxisPosition(uint axSN, string model)
        {
            double? ret;
            switch (model.ToUpper())
            {
                default:
                    ret = null;
                    break;
                case "CMD":
                    ret = GetAxisCommandPosition(axSN);
                    break;
                case "ACTUAL":
                    ret = GetAxisActualPosition(axSN);
                    break;
            }

            return ret.HasValue ? Convert.ToDecimal(ret.Value) : (decimal?)null;
        }

        /// <summary>
        /// 设置轴位置(不运动，只是设置寄存器)
        /// </summary>
        /// <param name="axSN">轴序号(从1开始)</param>
        /// <param name="distance">距离值，负数为反向位置，正数为正向位置，单位待定。</param>
        /// <param name="model">位置模式。"Cmd"-command position、"Actual"-actual position。</param>
        /// <returns></returns>
        public bool SetAxisPosition(uint axSN, decimal distance, string model) => model.ToUpper() switch
        {
            "CMD" => SetAxisCommandPosition(axSN, Convert.ToDouble(distance)),
            "ACTUAL" => SetAxisActualPosition(axSN, Convert.ToDouble(distance)),
            _ => false,
        };

        /// <summary>
        /// 回零
        /// </summary>
        /// <param name="axSN">轴序号(从1开始)</param>
        /// <param name="mod">
        /// 回零模式：
        /// 0：MODE1_Abs ；
        /// 1：MODE2_Lmt ；
        /// 2：MODE3_Ref ；
        /// 3：MODE4_Abs_Ref ；
        /// 4：MODE5_Abs_NegRef ；
        /// 5：MODE6_Lmt_Ref ；
        /// 6：MODE7_AbsSearch ；
        /// 7：MODE8_LmtSearch ；
        /// 8：MODE9_AbsSearch_Ref ；
        /// 9：MODE10_AbsSearch_NegRef ；
        /// 10：MODE11_LmtSearch_Ref ；
        /// 11：MODE12_AbsSearchReFind ；
        /// 12：MODE13_LmtSearchReFind ；
        /// 13：MODE14_AbsSearchReFind_Ref ；
        /// 14：MODE15_AbsSearchReFind_NegRef ；
        /// 15：MODE16_LmtSearchReFind_Ref。
        /// </param>
        /// <param name="dir">方向，0-正方向、1-负方向。</param>
        /// <returns></returns>
        public bool AxisHome(uint axSN, uint mod, uint dir)
        {
            if (!AxesCache.ContainsKey(axSN)) return false;
            if (AxesCache[axSN] == IntPtr.Zero) return false;

            //var iRet = AdvMotAPI.Acm_SetU32Property(AxesCache[axSN], AdvMotAPI.PropertyID.PAR_AxHomeExSwitchMode, 0u);
            //if (iRet != 0) return false;
            //iRet = AdvMotAPI.Acm_SetU32Property(AxesCache[axSN], AdvMotAPI.PropertyID.PAR_AxHomeCrossDistance, 1u);
            //if (iRet != 0) return false;

            var iRet = AdvMotAPI.Acm_AxHome(AxesCache[axSN], mod, dir);
            return iRet == 0;
        }

        public bool AxisMove(uint axSN, decimal distance, string model) => model.ToUpper() switch
        {
            "REL" => AxisRelativeMove(axSN, Convert.ToDouble(distance)),
            "ABS" => AxisAbsoluteMove(axSN, Convert.ToDouble(distance)),
            _ => false,
        };

        public bool AxisRun(uint axSN, string model)
        {
            if (!AxesCache.ContainsKey(axSN)) return false;
            if (AxesCache[axSN] == IntPtr.Zero) return false;
            ushort direction = (ushort)(model == "-" ? 1 : 0);
            var iRet = AdvMotAPI.Acm_AxMoveVel(AxesCache[axSN], direction);
            return iRet == 0;
        }

        public bool AxisStop(uint axSN, string model) => model.ToUpper() switch
        {
            "DES" => AxisStopDec(axSN),
            "EMO" => AxisStopEmg(axSN),
            _ => false,
        };


        #region 内部成员 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

        private ILogger<AdvMotPCI1285> Logger { get; }

        /// <summary>
        /// 板卡信息结构体对象
        /// </summary>
        private AdvMotAPI.DEV_LIST? CardInfo { get; set; } = null;

        /// <summary>
        /// 板卡句柄
        /// </summary>
        private IntPtr CardHandle { get; set; } = IntPtr.Zero;

        /// <summary>
        /// 打开板卡
        /// </summary>
        /// <returns></returns>
        private IntPtr OpenCard()
        {
            if (!CardInfo.HasValue) return IntPtr.Zero;
            IntPtr handle = IntPtr.Zero;
            var iRet = AdvMotAPI.Acm_DevOpen(CardInfo.Value.DeviceNum, ref handle);
            if (iRet != 0) return IntPtr.Zero;
            return handle;
        }

        /// <summary>
        /// 关闭板卡
        /// </summary>
        /// <returns>布尔</returns>
        private bool CloseCard()
        {
            if (CardHandle == IntPtr.Zero) return true;
            IntPtr handle = CardHandle;
            var iRet = AdvMotAPI.Acm_DevClose(ref handle);
            if (iRet != 0) return false;
            CardHandle = IntPtr.Zero;
            this.CardInfo = null;
            return true;
        }

        /// <summary>
        /// 获取轴(电机)数量
        /// </summary>
        /// <returns></returns>
        private uint GetAxisCount()
        {
            if (CardHandle == IntPtr.Zero) return 0;
            uint retCount = 0;
            var iRet = AdvMotAPI.Acm_GetU32Property(CardHandle, AdvMotAPI.PropertyID.FT_DevAxesCount, ref retCount);
            if (iRet != 0) return 0;
            return retCount;
        }

        /// <summary>
        /// 轴缓存(key为轴序号从1开始，value为轴操作句柄)
        /// </summary>
        private Dictionary<uint, IntPtr> AxesCache { get; set; } = new Dictionary<uint, IntPtr>();

        /// <summary>
        /// 打开板卡下的所有轴
        /// </summary>
        /// <returns>布尔值</returns>
        private bool OpenAxes()
        {
            try
            {
                uint axisCount = GetAxisCount();
                if (axisCount == 0) return false;
                for (uint i = 1; i <= axisCount; i++)
                {
                    IntPtr handle = IntPtr.Zero;
                    ushort axisIndex = Convert.ToUInt16(i - 1);
                    var iRet = AdvMotAPI.Acm_AxOpen(this.CardHandle, axisIndex, ref handle);
                    if (iRet != 0) throw new Exception($"打开索引为{axisIndex}的轴失败！");
                    iRet = AdvMotAPI.Acm_SetF64Property(handle, AdvMotAPI.PropertyID.PAR_AxJerk, 0d);
                    if (iRet != 0) throw new Exception($"设置索引为{axisIndex}的轴速度曲线的类型失败！");
                    AxesCache.Add(i, handle);
                }
                return true;
            }
            catch (Exception ex)
            {
                CloseAxes();
                string err =
                    $"类：{this.GetType()}。\r\n方法：{System.Reflection.MethodBase.GetCurrentMethod()}\r\n错误信息：{ex.Message}";
                Logger.Error(err, ex);
                return false;
            }
        }

        /// <summary>
        /// 关闭板卡下的所已打开的轴
        /// </summary>
        /// <returns></returns>
        private bool CloseAxes()
        {
            if (AxesCache == null || AxesCache.Count == 0) return true; //没有打开的轴直接返回true

            var removeItems = new List<KeyValuePair<uint, IntPtr>>();
            foreach (var item in AxesCache)
            {
                if (item.Value == IntPtr.Zero) continue;
                IntPtr handle = item.Value; // 记录一下Value
                var iRet = AdvMotAPI.Acm_AxClose(ref handle); // 关闭轴
                if (iRet == 0) removeItems.Add(item); //记录需要移除的对象
            }

            //移除所有记录到的对象
            foreach (var removeItem in removeItems)
            {
                AxesCache.Remove(removeItem.Key);
            }

            return AxesCache.Count == 0;
        }

        /// <summary>
        /// Get current command position of the specified axis
        /// </summary>
        /// <param name="axSN">轴序号(从1开始)</param>
        /// <returns>distance</returns>
        private double? GetAxisCommandPosition(uint axSN)
        {
            if (!AxesCache.ContainsKey(axSN)) return null;
            if (AxesCache[axSN] == IntPtr.Zero) return null;
            double distance = 0;
            var iRet = AdvMotAPI.Acm_AxGetCmdPosition(AxesCache[axSN], ref distance);
            return iRet == 0 ? distance : (double?)null;
        }

        /// <summary>
        /// Get actual position of the specified axis
        /// </summary>
        /// <param name="axSN">轴序号(从1开始)</param>
        /// <returns>distance</returns>
        private double? GetAxisActualPosition(uint axSN)
        {
            if (!AxesCache.ContainsKey(axSN)) return null;
            if (AxesCache[axSN] == IntPtr.Zero) return null;
            double distance = 0;
            var iRet = AdvMotAPI.Acm_AxGetActualPosition(AxesCache[axSN], ref distance);
            return iRet == 0 ? distance : (double?)null;
        }

        /// <summary>
        /// Set current command position of the specified axis
        /// </summary>
        /// <param name="axSN">轴序号(从1开始)</param>
        /// <param name="distance">距离值，负数为反向位置，正数为正向位置，单位待定。</param>
        /// <returns>布尔值</returns>
        private bool SetAxisCommandPosition(uint axSN, double distance)
        {
            if (!AxesCache.ContainsKey(axSN)) return false;
            if (AxesCache[axSN] == IntPtr.Zero) return false;
            var iRet = AdvMotAPI.Acm_AxSetCmdPosition(AxesCache[axSN], distance);
            return iRet == 0;
        }

        /// <summary>
        /// Set actual position of the specified axis
        /// </summary>
        /// <param name="axSN">轴序号(从1开始)</param>
        /// <param name="distance">距离值，负数为反向位置，正数为正向位置，单位待定。</param>
        /// <returns>布尔值</returns>
        private bool SetAxisActualPosition(uint axSN, double distance)
        {
            if (!AxesCache.ContainsKey(axSN)) return false;
            if (AxesCache[axSN] == IntPtr.Zero) return false;
            var iRet = AdvMotAPI.Acm_AxSetActualPosition(AxesCache[axSN], distance);
            return iRet == 0;
        }

        /// <summary>
        /// 轴绝对移动
        /// </summary>
        /// <param name="axSN">轴序号(从1开始)</param>
        /// <param name="distance">移动距离，负数为反向移动，正数为正向移动，单位待定</param>
        /// <returns>布尔值</returns>
        private bool AxisAbsoluteMove(uint axSN, double distance)
        {
            if (!AxesCache.ContainsKey(axSN)) return false;
            if (AxesCache[axSN] == IntPtr.Zero) return false;
            var iRet = AdvMotAPI.Acm_AxMoveAbs(AxesCache[axSN], distance);
            return iRet == 0;
        }

        /// <summary>
        /// 轴相对移动
        /// </summary>
        /// <param name="axSN">轴序号(从1开始)</param>
        /// <param name="distance">移动距离(脉冲数)，负数为反向移动，正数为正向移动，单位待定</param>
        /// <returns>布尔值</returns>
        private bool AxisRelativeMove(uint axSN, double distance)
        {
            if (!AxesCache.ContainsKey(axSN)) return false;
            if (AxesCache[axSN] == IntPtr.Zero) return false;
            var iRet = AdvMotAPI.Acm_AxMoveRel(AxesCache[axSN], distance);
            return iRet == 0;
        }

        /// <summary>
        /// 轴减速停止
        /// </summary>
        /// <param name="axSN">轴序号(从1开始)</param>
        /// <returns>布尔值</returns>
        private bool AxisStopDec(uint axSN)
        {
            if (!AxesCache.ContainsKey(axSN)) return false;
            if (AxesCache[axSN] == IntPtr.Zero) return false;
            var iRet = AdvMotAPI.Acm_AxStopDec(AxesCache[axSN]);
            return iRet == 0;
        }

        /// <summary>
        /// 轴立即停止
        /// </summary>
        /// <param name="axSN">轴序号(从1开始)</param>
        /// <returns>布尔值</returns>
        private bool AxisStopEmg(uint axSN)
        {
            if (!AxesCache.ContainsKey(axSN)) return false;
            if (AxesCache[axSN] == IntPtr.Zero) return false;
            var iRet = AdvMotAPI.Acm_AxStopEmg(AxesCache[axSN]);
            return iRet == 0;
        }
        #endregion 内部成员 <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
    }
}

using DCL.Motion.Advantech;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;

namespace DCL.MotionDCL.Advantech
{
    /// <summary>
    /// 研华运动控制卡API
    /// </summary>
    public static partial class AdvMotAPI
    {
        /// <summary>
        /// 支持最大卡数量
        /// </summary>
        private const uint MaxCardCount = 100;

        /// <summary>
        /// 获取板卡列表
        /// </summary>
        /// <param name="DevList">指针指向返回可用设备信息列表。</param>
        /// <param name="MaxEntries">需要获取的最大设备计数。</param>
        /// <param name="OutEntries">指向实际返回的设备数的指针。</param>
        /// <returns></returns>
        [DllImport("ADVMOT.dll", CallingConvention = CallingConvention.StdCall)]
        private static extern uint Acm_GetAvailableDevs(IntPtr DevList, uint MaxEntries, ref uint OutEntries);

        /// <summary>
        /// 获取板卡信息列表
        /// </summary>
        /// <returns>DEV_LIST结构体数组</returns>
        public static DEV_LIST[] GetCardInfoList()
        {
            DEV_LIST[] devList = new DEV_LIST[MaxCardCount];
            int cb = Marshal.SizeOf(typeof(AdvMotAPI.DEV_LIST)) * devList.Length;
            IntPtr devListHandle = Marshal.AllocHGlobal(cb);
            uint retCount = 0; //实际返回的板卡数量
            var iRet = Acm_GetAvailableDevs(devListHandle, MaxCardCount, ref retCount);
            if (iRet != 0 || retCount <= 0)
            {
                Marshal.FreeHGlobal(devListHandle);
                return null;
            }

            for (int i = 0; i < devList.Length; i++)
            {
                IntPtr ptr = new IntPtr(devListHandle.ToInt64() + Marshal.SizeOf(typeof(DEV_LIST)) * i);
                ref DEV_LIST reference = ref devList[i];
                reference = (DEV_LIST)Marshal.PtrToStructure(ptr, typeof(DEV_LIST));
            }

            Marshal.FreeHGlobal(devListHandle);
            return devList.Take((int)retCount).ToArray();
        }

        /// <summary>
        /// 打开板卡
        /// </summary>
        /// <param name="DeviceNumber">设备编号</param>
        /// <param name="DeviceHandle">返回一个指针，指向设备句柄。</param>
        /// <returns></returns>
        [DllImport("ADVMOT.dll", CallingConvention = CallingConvention.StdCall, EntryPoint = "Acm_DevOpen")]
        public static extern uint Acm_DevOpen(uint DeviceNumber, ref IntPtr DeviceHandle);

        /// <summary>
        /// 关闭板卡
        /// </summary>
        /// <param name="DeviceHandle">指针指向设备句柄。</param>
        /// <returns></returns>
        [DllImport("ADVMOT.dll", CallingConvention = CallingConvention.StdCall, EntryPoint = "Acm_DevClose")]
        public static extern uint Acm_DevClose(ref IntPtr DeviceHandle);

        /// <summary>
        /// 加载配置文件
        /// </summary>
        /// <param name="DeviceHandle">指针指向设备句柄。</param>
        /// <param name="ConfigPath">指针指向保存配置文件路径的字符串。</param>
        /// <returns></returns>
        [DllImport("ADVMOT.dll", CallingConvention = CallingConvention.StdCall, EntryPoint = "Acm_DevLoadConfig")]
        public static extern uint Acm_DevLoadConfig(IntPtr DeviceHandle, string ConfigPath);

        /// <summary>
        /// 通过分配的 PropertyID 获取属性 （特性属性、配置属性或参数属性）值。
        /// </summary>
        /// <param name="Handle">对象句柄。 该句柄可以是来自 Acm_DevOpen 的设备句柄，或来自 Acm_AxOpen 的轴句柄，或来自Acm_GpAddAxis 的群组句柄。</param>
        /// <param name="PropertyID">要查询的属性ID(PropertyID枚举类型)。</param>
        /// <param name="Value">指向实际返回的属性值的指针。</param>
        /// <returns></returns>
        [DllImport("ADVMOT.dll", CallingConvention = CallingConvention.StdCall, EntryPoint = "Acm_GetU32Property")]
        public static extern uint Acm_GetU32Property(IntPtr Handle, PropertyID PropertyID, ref uint Value);

        /// <summary>
        /// 打开轴
        /// </summary>
        /// <param name="DeviceHandle"> 来自 Acm_DevOpen 的设备句柄。</param>
        /// <param name="PhyAxis">物理轴编号(从0开始)。</param>
        /// <param name="AxisHandle">返回一个指针，指向轴句柄。</param>
        /// <returns></returns>
        [DllImport("ADVMOT.dll", CallingConvention = CallingConvention.StdCall, EntryPoint = "Acm_AxOpen")]
        public static extern uint Acm_AxOpen(IntPtr DeviceHandle, ushort PhyAxis, ref IntPtr AxisHandle);

        /// <summary>
        /// 命令轴开始回原点运动，典型原点运动的 16 种类型组成扩展原点。
        /// </summary>
        /// <param name="AxisHandle">来自 Acm_AxOpen 的轴句柄。</param>
        /// <param name="homeMode">
        /// HomeMode：
        /// 0：MODE1_Abs ；
        /// 1：MODE2_Lmt ；
        /// 2：MODE3_Ref ；
        /// 3：MODE4_Abs_Ref ；
        /// 4：MODE5_Abs_NegRef ；
        /// 5：MODE6_Lmt_Ref ；
        /// 6：MODE7_AbsSearch ；
        /// 7：MODE8_LmtSearch ；
        /// 8：MODE9_AbsSearch_Ref ；
        /// 9：MODE10_AbsSearch_NegRef ；
        /// 10：MODE11_LmtSearch_Ref ；
        /// 11：MODE12_AbsSearchReFind ；
        /// 12：MODE13_LmtSearchReFind ；
        /// 13：MODE14_AbsSearchReFind_Ref ；
        /// 14：MODE15_AbsSearchReFind_NegRef ；
        /// 15：MODE16_LmtSearchReFind_Ref。
        /// </param>
        /// <param name="DirMode">方向，0-正方向、1-负方向。</param>
        /// <returns></returns>
        [DllImport("ADVMOT.dll", CallingConvention = CallingConvention.StdCall, EntryPoint = "Acm_AxHome")]
        public static extern uint Acm_AxHome(IntPtr AxisHandle, uint homeMode, uint DirMode);

        /// <summary>
        /// 获取轴状态。
        /// </summary>
        /// <param name="AxisHandle">来自 Acm_AxOpen 的轴句柄。</param>
        /// <param name="State">轴状态。
        /// 0：STA_AxDisable ---- 轴被禁用，用户可打开并激活。
        /// 1：STA_AxReady ---- 轴已准备就绪，等待新的命令。
        /// 2：STA_Stopping ---- 轴停止。
        /// 3：STA_AxErrorStop ---- 出现错误，轴停止
        /// 4：STA_AxHoming ---- 轴正在执行返回原点运动。
        /// 5：STA_AxPtpMotion ---- 轴正在执行 PTP 运动。
        /// 6：STA_AxContiMotion ---- 轴正在执行连续运动。
        /// 7：STA_AxSyncMotion ---- 轴在一个群组中，群组正在执行插补运动；或轴是一个从轴，正在执行 E-cam/E-gear/Gantry 运动。
        /// 8：STA_AX_EXT_JOG ---- 轴由外部信号控制。当外部信号激活时，轴将执行 JOG 模式运动。
        /// 9：STA_AX_EXT_MPG ---- 轴由外部信号控制。当外部信号激活时，轴将执行 MPG 模式运动
        /// </param>
        /// <returns></returns>
        [DllImport("ADVMOT.dll", CallingConvention = CallingConvention.StdCall, EntryPoint = "Acm_AxGetState")]
        public static extern uint Acm_AxGetState(IntPtr AxisHandle, ref ushort State);

        /// <summary>
        /// 复位轴的状态。如果轴处于“ErrorStop”状态，则调用该函数后状态将变为“Ready”。
        /// </summary>
        /// <param name="AxisHandle">来自 Acm_AxOpen 的轴句柄</param>
        /// <returns></returns>
        [DllImport("ADVMOT.dll", CallingConvention = CallingConvention.StdCall, EntryPoint = "Acm_AxResetError")]
        public static extern uint Acm_AxResetError(IntPtr AxisHandle);

        /// <summary>
        /// 命令轴减速停止。
        /// </summary>
        /// <param name="AxisHandle">来自 Acm_AxOpen 的轴句柄。</param>
        /// <returns></returns>
        [DllImport("ADVMOT.dll", CallingConvention = CallingConvention.StdCall, EntryPoint = "Acm_AxStopDec")]
        public static extern uint Acm_AxStopDec(IntPtr AxisHandle);

        /// <summary>
        /// 命令轴立即停止
        /// </summary>
        /// <param name="AxisHandle">来自 Acm_AxOpen 的轴句柄。</param>
        /// <returns></returns>
        [DllImport("ADVMOT.dll", EntryPoint = "Acm_AxStopEmg", CallingConvention = CallingConvention.StdCall)]
        public static extern uint Acm_AxStopEmg(IntPtr AxisHandle);

        /// <summary>
        /// 关闭已经打开的轴。
        /// </summary>
        /// <param name="AxisHandle">指针指向轴句柄。</param>
        /// <returns></returns>
        [DllImport("ADVMOT.dll", CallingConvention = CallingConvention.StdCall, EntryPoint = "Acm_AxClose")]
        public static extern uint Acm_AxClose(ref IntPtr AxisHandle);

        /// <summary>
        /// 设定属性值为无符号 32 位整型的属性
        /// </summary>
        /// <param name="Handle">对象句柄。该句柄可以是来自 Acm_DevOpen 的设备句柄，或来自 Acm_AxOpen 的轴句柄，或来自 Acm_GpAddAxis 的群组句柄</param>
        /// <param name="PropertyID">要设置的属性 ID</param>
        /// <param name="Value">设置的属性值</param>
        /// <returns></returns>
        [DllImport("ADVMOT.dll", CallingConvention = CallingConvention.StdCall, EntryPoint = "Acm_SetU32Property")]
        public static extern uint Acm_SetU32Property(IntPtr Handle, PropertyID PropertyID, uint Value);

        /// <summary>
        /// 设置属性
        /// </summary>
        /// <param name="Handle">来自 Acm_AxOpen 的轴句柄。</param>
        /// <param name="PropertyID">要设置的属性ID(PropertyID枚举类型)。</param>
        /// <param name="Value">设置的属性值</param>
        /// <returns></returns>
        [DllImport("ADVMOT.dll", CallingConvention = CallingConvention.StdCall, EntryPoint = "Acm_SetF64Property")]
        public static extern uint Acm_SetF64Property(IntPtr Handle, PropertyID PropertyID, double Value);

        /// <summary>
        /// 读取属性
        /// </summary>
        /// <param name="Handle">对象句柄。该句柄可以是来自 Acm_DevOpen 的设备句柄，或来自 Acm_AxOpen 的轴句柄，或来自Acm_GpAddAxis 的群组句柄。</param>
        /// <param name="PropertyID">要获取的属性 ID</param>
        /// <param name="Value">属性的返回值</param>
        /// <returns></returns>
        [DllImport("ADVMOT.dll", CallingConvention = CallingConvention.StdCall, EntryPoint = "Acm_GetF64Property")]
        public static extern uint Acm_GetF64Property(IntPtr Handle, PropertyID PropertyID, ref double Value);

        /// <summary>
        /// 相对移动
        /// </summary>
        /// <param name="AxisHandle">来自 Acm_AxOpen 的轴句柄</param>
        /// <param name="Distance">相对距离 （单位 = PPU</param>
        /// <returns></returns>
        [DllImport("ADVMOT.dll", CallingConvention = CallingConvention.StdCall, EntryPoint = "Acm_AxMoveRel")]
        public static extern uint Acm_AxMoveRel(IntPtr AxisHandle, double Distance);

        /// <summary>
        /// 绝对移动
        /// </summary>
        /// <param name="AxisHandle">来自 Acm_AxOpen 的轴句柄</param>
        /// <param name="Position">绝对位置 （单位 = PPU）</param>
        /// <returns></returns>
        [DllImport("ADVMOT.dll", CallingConvention = CallingConvention.StdCall, EntryPoint = "Acm_AxMoveAbs")]
        public static extern uint Acm_AxMoveAbs(IntPtr AxisHandle, double Position);

        /// <summary>
        /// 命令轴按照规定速度进行没有终点的运动。
        /// 速度曲线由以下属性决定：PAR_AxVelLow、PAR_AxVelHigh、PAR_AxAcc、PAR_AxDec 和 PAR_AxJerk。
        /// </summary>
        /// <param name="AxisHandle">来自 Acm_AxOpen 的轴句柄</param>
        /// <param name="Direction">方向：0-正方向、1-负方向</param>
        /// <returns></returns>
        [DllImport("ADVMOT.dll", CallingConvention = CallingConvention.StdCall, EntryPoint = "Acm_AxMoveVel")]
        public static extern uint Acm_AxMoveVel(IntPtr AxisHandle, ushort Direction);

        /// <summary>
        /// 获取轴实际位置
        /// </summary>
        /// <param name="AxisHandle">来自 Acm_AxOpen 的轴句柄</param>
        /// <param name="Position">返回实际位置 （单位：PPU）</param>
        /// <returns></returns>
        [DllImport("ADVMOT.dll", CallingConvention = CallingConvention.StdCall, EntryPoint = "Acm_AxGetActualPosition")]
        public static extern uint Acm_AxGetActualPosition(IntPtr AxisHandle, ref double Position);

        /// <summary>
        /// 获取轴理论位置
        /// </summary>
        /// <param name="AxisHandle">来自 Acm_AxOpen 的轴句柄</param>
        /// <param name="Position">返回理论位置 （单位：PPU）</param>
        /// <returns></returns>
        [DllImport("ADVMOT.dll", CallingConvention = CallingConvention.StdCall, EntryPoint = "Acm_AxGetCmdPosition")]
        public static extern uint Acm_AxGetCmdPosition(IntPtr AxisHandle, ref double Position);

        /// <summary>
        /// 设置指定轴的理论位置
        /// </summary>
        /// <param name="AxisHandle">来自 Acm_AxOpen 的轴句柄</param>
        /// <param name="Position">新的理论位置 （单位：PPU）</param>
        /// <returns></returns>
        [DllImport("ADVMOT.dll", CallingConvention = CallingConvention.StdCall, EntryPoint = "Acm_AxSetCmdPosition")]
        public static extern uint Acm_AxSetCmdPosition(IntPtr AxisHandle, double Position);

        /// <summary>
        /// 设置指定轴的实际位置
        /// </summary>
        /// <param name="AxisHandle">来自 Acm_AxOpen 的轴句柄</param>
        /// <param name="Position">新的实际位置 （单位：PPU）</param>
        /// <returns></returns>
        [DllImport("ADVMOT.dll", CallingConvention = CallingConvention.StdCall, EntryPoint = "Acm_AxSetActualPosition")]
        public static extern uint Acm_AxSetActualPosition(IntPtr AxisHandle, double Position);

        /// <summary>
        ///  打开 / 关闭伺服驱动器
        /// </summary>
        /// <param name="AxisHandle">来自 Acm_AxOpen 的轴句柄</param>
        /// <param name="OnOff">
        /// 设置 SVON 信号的动作。
        /// 0：关闭、
        /// 1：打开。
        /// </param>
        /// <returns></returns>
        [DllImport("ADVMOT.dll", CallingConvention = CallingConvention.StdCall, EntryPoint = "Acm_AxSetSvOn")]
        public static extern uint Acm_AxSetSvOn(IntPtr AxisHandle, uint OnOff);

        /// <summary>
        /// 添加一个轴到指定群组
        /// </summary>
        /// <param name="GroupHandle">指针指向群组句柄 （Null 或无）</param>
        /// <param name="AxisHandle">来自 Acm_AxOpen 的轴句柄</param>
        /// <returns></returns>
        [DllImport("ADVMOT.dll", CallingConvention = CallingConvention.StdCall, EntryPoint = "Acm_GpAddAxis")]
        public static extern uint Acm_GpAddAxis(ref IntPtr GroupHandle, IntPtr AxisHandle);

        /// <summary>
        /// 从指定群组中移除一个轴
        /// </summary>
        /// <param name="GroupHandle">来自 Acm_GpAddaxis 的群组句柄</param>
        /// <param name="AxisHandle">来自 Acm_AxOpen 的轴句柄</param>
        /// <returns></returns>
        [DllImport("ADVMOT.dll", CallingConvention = CallingConvention.StdCall, EntryPoint = "Acm_GpRemAxis")]
        public static extern uint Acm_GpRemAxis(IntPtr GroupHandle, IntPtr AxisHandle);

        /// <summary>
        /// 移除群组中的所有轴并关闭群组句柄
        /// </summary>
        /// <param name="GroupHandle">来自 Acm_GpAddaxis 的群组句柄</param>
        /// <returns></returns>
        [DllImport("ADVMOT.dll", CallingConvention = CallingConvention.StdCall, EntryPoint = "Acm_GpClose")]
        public static extern uint Acm_GpClose(ref IntPtr GroupHandle);

        /// <summary>
        /// 复位群组状态
        /// </summary>
        /// <param name="GroupHandle">来自 Acm_GpAddaxis 的群组句柄</param>
        /// <returns></returns>
        [DllImport("ADVMOT.dll", CallingConvention = CallingConvention.StdCall, EntryPoint = "Acm_GpResetError")]
        public static extern uint Acm_GpResetError(IntPtr GroupHandle);

        /// <summary>
        /// 获取群组的当前状态
        /// </summary>
        /// <param name="GroupHandle">来自 Acm_GpAddaxis 的群组句柄</param>
        /// <param name="GroupState">
        /// 群组状态：
        /// 0：STA_GP_DISABLE、
        /// 1：STA_GP_READY、
        /// 2：STA_GP_STOPPING、
        /// 3：STA_GP_ERROR_STOP、
        /// 4：STA_GP_MOTION、
        /// 5：STA_GP_AX_MOTION （不支持）、
        /// 6：STA_GP_MOTION_PATH
        /// </param>
        /// <returns></returns>
        [DllImport("ADVMOT.dll", CallingConvention = CallingConvention.StdCall, EntryPoint = "Acm_GpGetState")]
        public static extern uint Acm_GpGetState(IntPtr GroupHandle, ref GroupState GroupState);

        /// <summary>
        /// 命令群组执行相对线性插补
        /// </summary>
        /// <param name="GroupHandle">来自 Acm_GpAddaxis 的群组句柄</param>
        /// <param name="DistanceArray">群组中轴的距离阵列，阵列元素的每个值都表示轴的相对位置</param>
        /// <param name="ArrayElements">阵列中的元素个数 （该个数必须等于该群组中的轴个数，否则将返回群组中的轴个数）</param>
        /// <returns></returns>
        [DllImport("ADVMOT.dll", CallingConvention = CallingConvention.StdCall, EntryPoint = "Acm_GpMoveLinearRel")]
        public static extern uint Acm_GpMoveLinearRel(IntPtr GroupHandle, double[] DistanceArray,
            ref uint ArrayElements);

        /// <summary>
        /// 命令群组执行绝对线性插补
        /// </summary>
        /// <param name="GroupHandle">来自 Acm_GpAddaxis 的群组句柄</param>
        /// <param name="PositionArray">群组中轴的位置阵列，阵列元素的每个值都表示轴的绝对位置</param>
        /// <param name="ArrayElements">阵列中的元素个数（该个数必须等于该群组中的轴个数，否则将返回群组中的轴个数</param>
        /// <returns></returns>
        [DllImport("ADVMOT.dll", CallingConvention = CallingConvention.StdCall, EntryPoint = "Acm_GpMoveLinearAbs")]
        public static extern uint Acm_GpMoveLinearAbs(IntPtr GroupHandle, double[] PositionArray,
            ref uint ArrayElements);

        /// <summary>
        /// 命令该群组中的轴立刻停止 （无减速）
        /// </summary>
        /// <param name="GroupHandle">来自 Acm_GpAddaxis 的群组句柄</param>
        /// <returns></returns>
        [DllImport("ADVMOT.dll", CallingConvention = CallingConvention.StdCall, EntryPoint = "Acm_GpStopEmg")]
        public static extern uint Acm_GpStopEmg(IntPtr GroupHandle);
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;

namespace DCL.MotionDCL.Advantech
{
    public static partial class AdvMotAPI
    {
        /*=============================================*/
        /*||定义研华运动控制卡API所用到的结构体和枚举||*/
        /*=============================================*/

        /// <summary>
        /// 研华板卡信息结构体
        /// </summary>
        public struct DEV_LIST
        {
            public uint DeviceNum;

            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 50)]
            public string DeviceName;

            public short NumofSubDevice;
        }

        /// <summary>
        /// 研华板卡API返回代码(错误代码)
        /// </summary>
        public enum ErrorCode : uint
        {
            SUCCESS = 0u,
            WARNING = 0x10000000u,
            InvalidDevNumber = 0x80000000u,
            DevRegDataLost = 2147483649u,
            LoadDllFailed = 2147483650u,
            GetProcAddrFailed = 2147483651u,
            MemAllocateFailed = 2147483652u,
            InvalidHandle = 2147483653u,
            CreateFileFailed = 2147483654u,
            OpenEventFailed = 2147483655u,
            EventTimeOut = 2147483656u,
            InvalidInputParam = 2147483657u,
            PropertyIDNotSupport = 2147483658u,
            PropertyIDReadOnly = 2147483659u,
            ConnectWinIrqFailed = 2147483660u,
            InvalidAxCfgVel = 2147483661u,
            InvalidAxCfgAcc = 2147483662u,
            InvalidAxCfgDec = 2147483663u,
            InvalidAxCfgJerk = 2147483664u,
            InvalidAxParVelLow = 2147483665u,
            InvalidAxParVelHigh = 2147483666u,
            InvalidAxParAcc = 2147483667u,
            InvalidAxParDec = 2147483668u,
            InvalidAxParJerk = 2147483669u,
            InvalidAxPulseInMode = 2147483670u,
            InvalidAxPulseOutMode = 2147483671u,
            InvalidAxAlarmEn = 2147483672u,
            InvalidAxAlarmLogic = 2147483673u,
            InvalidAxInPEn = 2147483674u,
            InvalidAxInPLogic = 2147483675u,
            InvalidAxHLmtEn = 2147483676u,
            InvalidAxHLmtLogic = 2147483677u,
            InvalidAxHLmtReact = 2147483678u,
            InvalidAxSLmtPEn = 2147483679u,
            InvalidAxSLmtPReact = 2147483680u,
            InvalidAxSLmtPValue = 2147483681u,
            InvalidAxSLmtMEn = 2147483682u,
            InvalidAxSLmtMReact = 2147483683u,
            InvalidAxSLmtMValue = 2147483684u,
            InvalidAxOrgLogic = 2147483685u,
            InvalidAxOrgEnable = 2147483686u,
            InvalidAxEzLogic = 2147483687u,
            InvalidAxEzEnable = 2147483688u,
            InvalidAxEzCount = 2147483689u,
            InvalidAxState = 2147483690u,
            InvalidAxInEnable = 2147483691u,
            InvalidAxSvOnOff = 2147483692u,
            InvalidAxDistance = 2147483693u,
            InvalidAxPosition = 2147483694u,
            InvalidAxHomeModeKw = 2147483695u,
            InvalidAxCntInGp = 2147483696u,
            AxInGpNotFound = 2147483697u,
            AxIsInOtherGp = 2147483698u,
            AxCannotIntoGp = 2147483699u,
            GpInDevNotFound = 2147483700u,
            InvalidGpCfgVel = 2147483701u,
            InvalidGpCfgAcc = 2147483702u,
            InvalidGpCfgDec = 2147483703u,
            InvalidGpCfgJerk = 2147483704u,
            InvalidGpParVelLow = 2147483705u,
            InvalidGpParVelHigh = 2147483706u,
            InvalidGpParAcc = 2147483707u,
            InvalidGpParDec = 2147483708u,
            InvalidGpParJerk = 2147483709u,
            JerkNotSupport = 2147483710u,
            ThreeAxNotSupport = 2147483711u,
            DevIpoNotFinished = 2147483712u,
            InvalidGpState = 2147483713u,
            OpenFileFailed = 2147483714u,
            InvalidPathCnt = 2147483715u,
            InvalidPathHandle = 2147483716u,
            InvalidPath = 2147483717u,
            IoctlError = 2147483718u,
            AmnetRingUsed = 2147483719u,
            DeviceNotOpened = 2147483720u,
            InvalidRing = 2147483721u,
            InvalidSlaveIP = 2147483722u,
            InvalidParameter = 2147483723u,
            InvalidGpCenterPosition = 2147483724u,
            InvalidGpEndPosition = 2147483725u,
            InvalidAddress = 2147483726u,
            DeviceDisconnect = 2147483727u,
            DataOutBufExceeded = 2147483728u,
            SlaveDeviceNotMatch = 2147483729u,
            SlaveDeviceError = 2147483730u,
            SlaveDeviceUnknow = 2147483731u,
            FunctionNotSupport = 2147483732u,
            InvalidPhysicalAxis = 2147483733u,
            InvalidVelocity = 2147483734u,
            InvalidAxPulseInLogic = 2147483735u,
            InvalidAxPulseInSource = 2147483736u,
            InvalidAxErcLogic = 2147483737u,
            InvalidAxErcOnTime = 2147483738u,
            InvalidAxErcOffTime = 2147483739u,
            InvalidAxErcEnableMode = 2147483740u,
            InvalidAxSdEnable = 2147483741u,
            InvalidAxSdLogic = 2147483742u,
            InvalidAxSdReact = 2147483743u,
            InvalidAxSdLatch = 2147483744u,
            InvalidAxHomeResetEnable = 2147483745u,
            InvalidAxBacklashEnable = 2147483746u,
            InvalidAxBacklashPulses = 2147483747u,
            InvalidAxVibrationEnable = 2147483748u,
            InvalidAxVibrationRevTime = 2147483749u,
            InvalidAxVibrationFwdTime = 2147483750u,
            InvalidAxAlarmReact = 2147483751u,
            InvalidAxLatchLogic = 2147483752u,
            InvalidFwMemoryMode = 2147483753u,
            InvalidConfigFile = 2147483754u,
            InvalidAxEnEvtArraySize = 2147483755u,
            InvalidAxEnEvtArray = 2147483756u,
            InvalidGpEnEvtArraySize = 2147483757u,
            InvalidGpEnEvtArray = 2147483758u,
            InvalidIntervalData = 2147483759u,
            InvalidEndPosition = 2147483760u,
            InvalidAxisSelect = 2147483761u,
            InvalidTableSize = 2147483762u,
            InvalidGpHandle = 2147483763u,
            InvalidCmpSource = 2147483764u,
            InvalidCmpMethod = 2147483765u,
            InvalidCmpPulseMode = 2147483766u,
            InvalidCmpPulseLogic = 2147483767u,
            InvalidCmpPulseWidth = 2147483768u,
            InvalidPathFunctionID = 2147483769u,
            SysBufAllocateFailed = 2147483770u,
            SpeedFordFunNotSupported = 2147483771u,
            InvalidNormVector = 2147483772u,
            InvalidCmpTimeTableCount = 2147483773u,
            InvalidCmpTime = 2147483774u,
            FWDownLoading = 2147483775u,
            FWVersionNotMatch = 2147483776u,
            InvalidAxHomeVelLow = 2147483777u,
            InvalidAxHomeVelHigh = 2147483778u,
            InvalidAxHomeAcc = 2147483779u,
            InvalidAxHomeDec = 2147483780u,
            InvalidAxHomeJerk = 2147483781u,
            InvalidAxJogVelLow = 2147483782u,
            InvalidAxJogVelHigh = 2147483783u,
            InvalidAxJogAcc = 2147483784u,
            InvalidAxJogDec = 2147483785u,
            InvalidAxJogJerk = 2147483786u,
            InvalidAxKillDec = 2147483787u,
            NotOpenAllAxes = 2147483788u,
            NotSetServoComPort = 2147483789u,
            OpenComPortFailed = 2147483790u,
            ReadComPortTimeOut = 2147483791u,
            SetComPortStateFailed = 2147483792u,
            ServoTypeNotSupport = 2147483793u,
            ReadComBufFailed = 2147483794u,
            InvalidAxMaxErrorCnt = 2147483795u,
            SlaveIOUpdateError = 2147483798u,
            NoSlaveDevFound = 2147483799u,
            MasterDevNotOpen = 2147483800u,
            MasterRingNotOpen = 2147483801u,
            InvalidAxCfgJogPAssign = 2147483803u,
            InvalidAxCfgJogNAssign = 2147483804u,
            InvalidAxCfgCamDOAssign = 2147483805u,
            InvalidAxCfgIN1StopAssign = 2147483806u,
            InvalidDIPort = 2147483848u,
            InvalidDOPort = 2147483849u,
            InvalidDOValue = 2147483850u,
            CreateEventFailed = 2147483851u,
            CreateThreadFailed = 2147483852u,
            InvalidHomeModeEx = 2147483853u,
            InvalidDirMode = 2147483854u,
            AxHomeMotionFailed = 2147483855u,
            ReadFileFailed = 2147483856u,
            PathBufIsFull = 2147483857u,
            PathBufIsEmpty = 2147483858u,
            GetAuthorityFailed = 2147483859u,
            GpIDAllocatedFailed = 2147483860u,
            FirmWareDown = 2147483861u,
            InvalidGpRadius = 2147483862u,
            InvalidAxCmd = 2147483863u,
            InvalidAxExtDrv = 2147483864u,
            InvalidGpMovCmd = 2147483865u,
            SpeedCurveNotSupported = 2147483866u,
            InvalidCounterNo = 2147483867u,
            InvalidPathMoveMode = 2147483868u,
            PathSelStartCantRunInSpeedForwareMode = 2147483869u,
            InvalidCamTableID = 2147483870u,
            InvalidCamPointRange = 2147483871u,
            CamTableIsEmpty = 2147483872u,
            InvalidPlaneVector = 2147483873u,
            MasAxIDSameSlvAxID = 2147483874u,
            InvalidGpRefPlane = 2147483875u,
            InvalidAxModuleRange = 2147483876u,
            DownloadFileFailed = 2147483877u,
            InvalidFileLength = 2147483878u,
            InvalidCmpCnt = 2147483879u,
            JerkExceededMaxValue = 2147483880u,
            AbsMotionNotSupport = 2147483881u,
            InvalidAiRange = 2147483882u,
            AIScaleFailed = 2147483883u,
            AxInRobot = 2147483884u,
            Invalid3DArcFlat = 2147483885u,
            InvalidIpoMap = 2147483886u,
            DataSizeNotCorrect = 2147483887u,
            AxisNotFound = 2147483888u,
            InvalidPathVelHigh = 2147483889u,
            InvalidRbParVelLow = 2147483898u,
            InvalidRbParVelHigh = 2147483899u,
            InvalidRbParAcc = 2147483900u,
            InvalidRbParDec = 2147483901u,
            InvalidRbParJerk = 2147483902u,
            InvalidRbState = 2147483903u,
            InvalidRbHandle = 2147483904u,
            InvalidRbRadius = 2147483905u,
            InvalidRbMovCmd = 2147483906u,
            NotOpenRobot = 2147483907u,
            InvalidRbPoint = 2147483908u,
            RbAngleExceeded = 2147483909u,
            GetDIOFalied = 2147483948u,
            InvalidRingBufferCmd = 2147483949u,
            InvalidAoRange = 2147483950u,
            RingBufferOverFlow = 2147483951u,
            RbAreaExceeded = 2147483952u,
            InvalidAiValue = 2147483953u,
            InvalidAoValue = 2147483954u,
            NoPreScanData = 2147483955u,
            GroupNotAssigned = 2147483956u,
            AxisNotOpened = 2147483957u,
            DataCntExceeded = 2147483958u,
            HLmtPExceeded = 2147491840u,
            HLmtNExceeded = 2147491841u,
            SLmtPExceeded = 2147491842u,
            SLmtNExceeded = 2147491843u,
            AlarmHappened = 2147491844u,
            EmgHappened = 2147491845u,
            TimeLmtExceeded = 2147491846u,
            DistLmtExceeded = 2147491847u,
            InvalidPositionOverride = 2147491848u,
            OperationErrorHappened = 2147491849u,
            SimultaneousStopHappened = 2147491850u,
            OverflowInPAPB = 2147491851u,
            OverflowInIPO = 2147491852u,
            STPHappened = 2147491853u,
            SDHappened = 2147491854u,
            AxsiNoCmpDataLeft = 2147491855u,
            DevEvtTimeOut = 2147500033u,
            DevNoEvt = 2147500034u,
            Warning_AxWasInGp = 268435457u,
            Warning_GpInconsistRate = 268435458u,
            Warning_GpInconsistPPU = 268435459u,
            Warning_GpMoveDistanceCanntBeZero = 268435460u,
            Warning_GpExisted = 268435461u,
            ERR_SYS_TIME_OUT = 2147504129u,
            Dsp_PropertyIDNotSupport = 2147504130u,
            Dsp_PropertyIDReadOnly = 2147504131u,
            Dsp_InvalidParameter = 2147504132u,
            Dsp_DataOutBufExceeded = 2147504133u,
            Dsp_FunctionNotSupport = 2147504134u,
            Dsp_InvalidConfigFile = 2147504135u,
            Dsp_InvalidIntervalData = 2147504136u,
            Dsp_InvalidTableSize = 2147504137u,
            Dsp_InvalidTableID = 2147504138u,
            Dsp_DataIndexExceedBufSize = 2147504139u,
            Dsp_InvalidCompareInterval = 2147504140u,
            Dsp_InvalidCompareRange = 2147504141u,
            Dsp_PropertyIDWriteOnly = 2147504142u,
            Dsp_NcError = 2147504143u,
            Dsp_CamTableIsInUse = 2147504144u,
            Dsp_EraseBlockFailed = 2147504145u,
            Dsp_ProgramFlashFailed = 2147504146u,
            Dsp_WatchdogError = 2147504147u,
            Dsp_ReadPrivateOverMaxTimes = 2147504148u,
            Dsp_InvalidPrivateID = 2147504149u,
            Dsp_DataNotReady = 2147504150u,
            Dsp_LastOperationNotOver = 2147504151u,
            Dsp_WritePrivateTimeout = 2147504152u,
            Dsp_FwIsDownloading = 2147504153u,
            Dsp_FwDownloadStepError = 2147504160u,
            Dsp_InvalidDiLtcChanelID = 2147504161u,
            Dsp_InvalidDoCmpChanelID = 2147504162u,
            Dsp_InvalidDevPptValue = 2147504163u,
            Dsp_CmpCannotLinkMultiLtc = 2147504164u,
            Dsp_SDIOLinkError = 2147504165u,
            InvalidVerScanTable = 2147504166u,
            InvalidVerEnablePos = 2147504167u,
            VerMovLimitExceeded = 2147504168u,
            Dsp_InvalidTableName = 2147504169u,
            Dsp_MIOInvalidSer = 2147504176u,
            Dsp_SDIInvalidSer = 2147504177u,
            Plink_SynTimeTooShort = 2147504178u,
            Dsp_LinkObjectExisted = 2147504179u,
            Dsp_InvalidAxCfgVel = 2147504385u,
            Dsp_InvalidAxCfgAcc = 2147504386u,
            Dsp_InvalidAxCfgDec = 2147504387u,
            Dsp_InvalidAxCfgJerk = 2147504388u,
            Dsp_InvalidAxParVelLow = 2147504389u,
            Dsp_InvalidAxParVelHigh = 2147504390u,
            Dsp_InvalidAxParAcc = 2147504391u,
            Dsp_InvalidAxParDec = 2147504392u,
            Dsp_InvalidAxParJerk = 2147504393u,
            Dsp_InvalidAxPptValue = 2147504394u,
            Dsp_InvalidAxState = 2147504395u,
            Dsp_InvalidAxSvOnOff = 2147504396u,
            Dsp_InvalidAxDistance = 2147504397u,
            Dsp_InvalidAxPosition = 2147504398u,
            Dsp_InvalidAxHomeMode = 2147504399u,
            Dsp_InvalidPhysicalAxis = 2147504400u,
            Dsp_HLmtPExceeded = 2147504401u,
            Dsp_HLmtNExceeded = 2147504402u,
            Dsp_SLmtPExceeded = 2147504403u,
            Dsp_SLmtNExceeded = 2147504404u,
            Dsp_AlarmHappened = 2147504405u,
            Dsp_EmgHappened = 2147504406u,
            Dsp_CmdValidOnlyInConstSec = 2147504407u,
            Dsp_InvalidAxCmd = 2147504408u,
            Dsp_InvalidAxHomeDirMode = 2147504409u,
            Dsp_AxisMustBeModuloAxis = 2147504410u,
            Dsp_AxIdCantSameAsMasId = 2147504411u,
            Dsp_CantResetPosiOfMasAxis = 2147504412u,
            Dsp_InvalidAxExtDrvOperation = 2147504413u,
            Dsp_AxAccExceededMaxAcc = 2147504414u,
            Dsp_AxVelExceededMaxVel = 2147504415u,
            Dsp_NotEnoughPulseForChgV = 2147504416u,
            Dsp_NewVelMustGreaterThanVelLow = 2147504417u,
            Dsp_InvalidAxGearMode = 2147504418u,
            Dsp_InvalidGearRatio = 2147504419u,
            Dsp_InvalidPWMDataCount = 2147504420u,
            Dsp_InvalidAxPWMFreq = 2147504421u,
            Dsp_InvalidAxPWMDuty = 2147504422u,
            Dsp_AxGantryExceedMaxDiffValue = 2147504423u,
            Dsp_ChannelIsDisable = 2147504424u,
            Dsp_ChannelBufferIsFull = 2147504425u,
            Dsp_ChannelBufferIsEmpty = 2147504432u,
            Dsp_InvalidDoChannelID = 2147504433u,
            Dsp_LatchHappened = 2147504434u,
            Dsp_InvalidAxKillDec = 2147504435u,
            Dsp_InvalidAxJogVelLow = 2147504436u,
            Dsp_InvalidAxJogVelHigh = 2147504437u,
            Dsp_InvalidAxJogAcc = 2147504438u,
            Dsp_InvalidAxJogDec = 2147504439u,
            Dsp_InvalidAxJogJerk = 2147504440u,
            Dsp_InvalidAxHomeVelLow = 2147504441u,
            Dsp_InvalidAxHomeVelHigh = 2147504448u,
            Dsp_InvalidAxHomeAcc = 2147504449u,
            Dsp_InvalidAxHomeDec = 2147504450u,
            Dsp_InvalidAxHomeJerk = 2147504451u,
            Dsp_PosErrorCntExceed = 2147504452u,
            Dsp_InvalidAxCounterMax = 2147504453u,
            Dsp_InvalidAxOverflowMode = 2147504454u,
            Dsp_ImposeTimeLongerPTP = 2147504455u,
            Dsp_AxAngExceededMaxRotationAng = 2147504456u,
            Dsp_AxAreaExceeded = 2147504457u,
            Dsp_AxDiStopAct = 2147504464u,
            Dsp_InvalidAxCntInGp = 2147504641u,
            Dsp_AxInGpNotFound = 2147504642u,
            Dsp_AxIsInOtherGp = 2147504643u,
            Dsp_AxCannotIntoGp = 2147504644u,
            Dsp_GpInDevNotFound = 2147504645u,
            Dsp_InvalidGpCfgVel = 2147504646u,
            Dsp_InvalidGpCfgAcc = 2147504647u,
            Dsp_InvalidGpCfgDec = 2147504648u,
            Dsp_InvalidGpCfgJerk = 2147504649u,
            Dsp_InvalidGpParVelLow = 2147504650u,
            Dsp_InvalidGpParVelHigh = 2147504651u,
            Dsp_InvalidGpParAcc = 2147504652u,
            Dsp_InvalidGpParDec = 2147504653u,
            Dsp_InvalidGpParJerk = 2147504654u,
            Dsp_JerkNotSupport = 2147504655u,
            Dsp_ThreeAxNotSupport = 2147504656u,
            Dsp_DevIpoNotFinished = 2147504657u,
            Dsp_InvalidGpState = 2147504658u,
            Dsp_OpenFileFailed = 2147504659u,
            Dsp_InvalidPathCnt = 2147504660u,
            Dsp_InvalidPathHandle = 2147504661u,
            Dsp_InvalidPath = 2147504662u,
            Dsp_GpSlavePositionOverMaster = 2147504663u,
            Dsp_GpPathBufferOverflow = 2147504665u,
            Dsp_InvalidPathFunctionID = 2147504666u,
            Dsp_SysBufAllocateFailed = 2147504667u,
            Dsp_InvalidGpCenterPosition = 2147504668u,
            Dsp_InvalidGpEndPosition = 2147504669u,
            Dsp_InvalidGpCmd = 2147504670u,
            Dsp_AxHasBeenInInGp = 2147504671u,
            Dsp_InvalidPathRange = 2147504672u,
            Dsp_InvalidNormVector = 2147504673u,
            Dsp_RbInvalidMode = 2147505408u,
            Dsp_RbInvalidGpid = 2147505409u,
            Dsp_RbInvalidArmLength = 2147505410u,
            Dsp_RbInvalidAxesNum = 2147505411u,
            Dsp_RbInvalidHandDir = 2147505412u,
            Dsp_RbAreaExceeded = 2147505413u,
            Dsp_RbAngleExceeded = 2147505414u,
            Dsp_RbSwLmtNotEnabled = 2147505415u,
            Dsp_RbVectorDistExceededZTargetDist = 2147505416u,
            Dsp_RbInvalidPoint = 2147505417u,
            Dsp_RbInvalidCurrentHandDir = 2147505418u,
            Dsp_RbInvalidCoordinateSystem = 2147505419u,
            Dsp_RbInvalidCoordinateAxis = 2147505420u,
            Dsp_RbSpeedTooHigh = 2147505421u,
            Dsp_RbInvalidState = 2147505422u,
            Dsp_RbEmgHappened = 2147505423u,
            Dsp_RbAlmHappened = 2147505424u,
            Dsp_RbSLmtPExceeded = 2147505425u,
            Dsp_RbSLmtNExceeded = 2147505426u,
            GmError = 2164260864u,
            Gm_CodeError = 2164261120u,
            Gm_SystemError = 2164261376u,
            Gm_InvalidCharacter = 2164261121u,
            Gm_InvalidCode = 2164261122u,
            Gm_InvalidGCode = 2164261123u,
            Gm_InvalidMCode = 2164261124u,
            Gm_GroupCodeAlreadyExist = 2164261125u,
            Gm_MissingNumber = 2164261126u,
            Gm_MissingFWord = 2164261127u,
            Gm_MissingSWord = 2164261128u,
            Gm_MissingOWord = 2164261129u,
            Gm_MissingNWord = 2164261130u,
            Gm_MissingLWord = 2164261131u,
            Gm_MissingPWord = 2164261132u,
            Gm_MissingQWord = 2164261133u,
            Gm_MissingRWord = 2164261134u,
            Gm_MissingEWord = 2164261135u,
            Gm_MissingHWord = 2164261136u,
            Gm_MissingDWord = 2164261137u,
            Gm_MissingTWord = 2164261138u,
            Gm_MissingAxisWord = 2164261139u,
            Gm_MissingSubAxisWord = 2164261140u,
            Gm_InvalidFValue = 2164261141u,
            Gm_InvalidSValue = 2164261142u,
            Gm_InvalidOValue = 2164261143u,
            Gm_InvalidNValue = 2164261144u,
            Gm_InvalidLValue = 2164261145u,
            Gm_InvalidPValue = 2164261146u,
            Gm_InvalidQValue = 2164261147u,
            Gm_InvalidRValue = 2164261148u,
            Gm_InvalidEValue = 2164261149u,
            Gm_InvalidHValue = 2164261151u,
            Gm_InvalidDValue = 2164261152u,
            Gm_InvalidTValue = 2164261153u,
            Gm_InvalidAxisValue = 2164261154u,
            Gm_InvalidSubAxisValue = 2164261155u,
            Gm_OverloadAxisNum = 2164261156u,
            Gm_InvalidAxisNumber = 2164261157u,
            Gm_MacroNotFound = 2164261158u,
            Gm_InvalidGMSHandle = 2164261377u,
            Gm_InvalidThreadHandle = 2164261378u,
            Gm_SystemNotReady = 2164261379u,
            Gm_NotEnoughMemory = 2164261380u,
            Gm_InvalidPatternId = 2164261381u,
            Gm_InvalidBreakPoint = 2164261382u,
            Gm_InvalidMacroNumber = 2164261383u,
            Gm_CodeOverload = 2164261384u,
            Gm_MacroOverload = 2164261385u,
            Gm_InvalidFeedRate = 2164261386u,
            Gm_InvalidModuleRange = 2164261387u,
            Gm_RadiusCompensationAlreadyOn = 2164261388u,
            Gm_OverCut = 2164261389u,
            Gm_WrongRefPlane = 2164261390u,
            Gm_DllNotFound = 2164261391u,
            Gm_Ax_ErrorStop = 2164261392u,
            Gm_OverrunDwell = 2164261393u,
            Gm_InvalidSetCoordinate = 2164261394u,
            Gm_OverrunAxisNum = 2164261395u,
            Gm_InvalidG29 = 2164261396u,
            Gm_BothOfGCodeUseAxisWords = 2164261397u,
            Gm_NotFoundNext = 2164261398u,
            Gm_ArcAxisNumError = 2164261399u,
            Gm_OverrunContiAxis = 2164261400u,
            Gm_ContiArcAxisError = 2164261401u,
            Gm_G272829CanNotBeConti = 2164261402u,
            Gm_CheckHomeFailed = 2164261403u,
            Gm_StackOverflow = 2164261404u,
            Gm_StackUnderflow = 2164261405u,
            Gm_InvalidAxHomeMode = 2164261406u,
            Gm_OverrunFilePath = 2164261407u,
            Gm_OverrunLineText = 2164261408u,
            Gm_InvalidSSTA = 2164261409u,
            Gm_InfineLoop = 2164261410u,
            Gm_InvalidDoDevice = 2164261411u,
            Gm_InvalidDoChannel = 2164261412u,
            Gm_InvalidDoLevel = 2164261413u,
            Gm_InvalidDiDevice = 2164261414u,
            Gm_InvalidDiChannel = 2164261415u,
            Gm_InvalidDiLevel = 2164261416u,
            Gm_RunCustomMcodeError = 2164261417u,
            Gm_ZeroVector = 2164261418u,
            Gm_LineParallel = 2164261419u,
            Gm_InvalidBufferLength = 2164261420u,
            GmInvalidOptionPauseParam = 2164261421u,
            GmInvalidOptionSkip = 2164261422u,
            GmWaitDiTimeOut = 2164261423u,
            GmCannotInvokeMacroInMacro = 2164261424u,
            GmThreadTimeOut = 2164261425u,
            Gm_InvalidDiValue = 2164261426u,
            Gm_BeOverCutted = 2164261427u,
            Gm_RadiusCompensationCannotWithG2G3 = 2164261428u,
            Gm_InvalidPpointID = 2164261429u,
            Gm_InvalidFilePath = 2164261430u,
            Gm_InvalidFileFormat = 2164261431u,
            Gm_PpointHasNotSet = 2164261432u,
            Gm_PpointLenNotEqualWithAxesNum = 2164261433u,
            Gm_PpointAndNonPCannotBeMixed = 2164261434u,
            Gm_StartPosCannotEqualWithEndPos = 2164261435u,
            Gm_InvalidBoolID = 2164261436u,
            Gm_BoolHasNotSet = 2164261437u,
            Gm_IfBlockNotCorrect = 2164261438u,
            Gm_IfBlockFlowError = 2164261439u,
            Gm_InvalidParameter = 2164261440u,
            ComponentError = 2181038080u,
            InvalidAxPPU = 2181038080u,
            InvalidAxPulseInMaxFreq = 2181038081u,
            InvalidAxHomeCrossDistance = 2181038082u,
            InvalidAxHomeExSwitchMode = 2181038083u,
            InvalidAxOrgReact = 2181038084u,
            InvalidAxBacklashVel = 2181038085u,
            InvalidAxExtMasterSrc = 2181038086u,
            InvalidAxExtSelEnable = 2181038087u,
            InvalidAxExtPulseInMode = 2181038088u,
            InvalidAxExtPulseNum = 2181038089u,
            InvalidAxExtPresetNum = 2181038090u,
            InvalidAxAuxOutEnable = 2181038091u,
            InvalidAxAuxOutTime = 2181038092u,
            InvalidAxGenDoEnable = 2181038093u,
            InvalidAxCompareEnable = 2181038094u,
            InvalidAxLatchEnable = 2181038095u,
            InvalidAxIN1Enable = 2181038096u,
            InvalidAxIN1Logic = 2181038097u,
            InvalidAxIN1React = 2181038098u,
            InvalidAxIN2Enable = 2181038099u,
            InvalidAxIN2Logic = 2181038100u,
            InvalidAxIN2React = 2181038101u,
            InvalidAxIN4Enable = 2181038102u,
            InvalidAxIN4Logic = 2181038103u,
            InvalidAxIN4React = 2181038104u,
            InvalidAxIN5Enable = 2181038105u,
            InvalidAxIN5Logic = 2181038106u,
            InvalidAxIN5React = 2181038107u,
            InvalidAxLatchBufEnable = 2181038108u,
            InvalidAxLatchBufMinDist = 2181038109u,
            InvalidAxLatchBufEventNum = 2181038110u,
            InvalidAxLatchBufSource = 2181038111u,
            InvalidAxLatchBufAxisID = 2181038112u,
            InvalidAxLatchBufEdge = 2181038113u,
            InvalidAxHomeOffsetDistance = 2181038114u,
            InvalidAxHomeOffsetVel = 2181038115u,
            InvalidAxCmpPulseWidthEx = 2181038116u,
            InvalidAxPelToleranceEnable = 2181038117u,
            InvalidAxPelToleranceValue = 2181038118u,
            InvalidAxMelToleranceEnable = 2181038119u,
            InvalidAxMelToleranceValue = 2181038120u,
            InvalidAxSwPelToleranceEnable = 2181038121u,
            InvalidAxSwPelToleranceValue = 2181038122u,
            InvalidAxSwMelToleranceEnable = 2181038123u,
            InvalidAxSwMelToleranceValue = 2181038124u,
            InvalidAxALMFilterTime = 2181038125u,
            InvalidAxLMTPFilterTime = 2181038126u,
            InvalidAxLMTNFilterTime = 2181038127u,
            InvalidAxIN1FilterTime = 2181038128u,
            InvalidAxIN2FilterTime = 2181038129u,
            InvalidAxORGFilterTime = 2181038130u,
            InvalidAxIN4FilterTime = 2181038131u,
            InvalidAxIN5FilterTime = 2181038132u,
            InvalidAxPPUDenominator = 2181038133u,
            InvalidAxPulseOutReverse = 2181038134u,
            InvalidAxGantryMaxDiffValue = 2181038135u,
            InvalidAxJogVLTime = 2181038136u,
            InvalidAxCamDOEnable = 2181038137u,
            InvalidAxCamDOLogic = 2181038138u,
            InvalidAxCamDOCmpSrc = 2181038139u,
            InvalidAxCamDOMode = 2181038140u,
            InvalidAxCamDODir = 2181038141u,
            InvalidAxCamDOLoLimit = 2181038142u,
            InvalidAxCamDOHiLimit = 2181038143u,
            InvalidAxSimStartSource = 2181038144u,
            InvalidAxPelLogic = 2181038145u,
            InvalidAxMelLogic = 2181038146u,
            InvalidMultiCmpDeviation = 2181038147u,
            InvalidAxParJerkFactor = 2181038148u,
            DialogNotOpen = 2181038281u,
            WriteFileStreamFailed = 2181038282u,
            FileNameIsNull = 2181038283u,
            InvalidFileFormat = 2181038284u,
            FileIsExisted = 2181038285u,
            FileIsNotExists = 2181038286u,
            InvalidDirectory = 2181038287u,
            LoadDxfFileFailed = 2181038288u,
            ECTError = 2197815296u,
            EC_GetNICNumberFailed = 2197815296u,
            EC_GetNICInfoFailed = 2197815297u,
            EC_OpenMasterDevFailed = 2197815298u,
            EC_GetSlaveFailed = 2197815299u,
            EC_StartOpModeFailed = 2197815300u,
            EC_CloseDeviceFailed = 2197815301u,
            EC_MemAllocateFailed = 2197815302u,
            EC_InvalidNicIndex = 2197815303u,
            EC_OpenDevFailed = 2197815304u,
            EC_ReadFileFailed = 2197815305u,
            EC_GetNicInfoFailed = 2197815306u,
            EC_GetSDOFailed = 2197815307u,
            EC_InvalidParameter = 2197815308u,
            EC_GetPDOOffsetFailed = 2197815309u,
            EC_InitialMappingInfoFalied = 2197815310u,
            EC_InitResourceFailed = 2197815311u,
            EC_SetSDOFailed = 2197815312u,
            EC_InvalidPortType = 2197815313u,
            EC_SetCycleTimeFailed = 2197815314u,
            EC_InvalidAoRange = 2197815315u,
            EC_InvalidAiRange = 2197815316u,
            EC_GetSlaveInfoFaied = 2197815317u,
            EC_GetNetWorkStateFaied = 2197815318u,
            EC_RegisterEventFailed = 2197815319u,
            EC_InvalidIntegrationTime = 2197815320u,
            EC_InvalidAIEnable = 2197815321u,
            EC_InvalidDIFilter = 2197815322u,
            EC_SetSlaveStateFailed = 2197815323u,
            EC_ZeroCalibrationFailed = 2197815324u,
            EC_InvalidMasterHandle = 2197815325u,
            EC_InvalidENIFile = 2197815326u,
            EC_InvalidCaliType = 2197815327u,
            EC_SetCaliValueFailed = 2197815328u,
            EC_AOCalibrationFailed = 2197815329u,
            EC_InvalidIOMapping = 2197815330u,
            EC_PortIndexGreaterThanPortNum = 2197815331u,
            EC_ChannelIDGreaterThanChannelNum = 2197815332u,
            EC_InputIndexGreaterThanInputNum = 2197815333u,
            EC_OutputIndexGreaterThanOutputNum = 2197815334u,
            EC_SetEnableFailed = 2197815335u,
            EC_SetAIRangeFailed = 2197815336u,
            EC_SetIntegrationTimeFailed = 2197815337u,
            EC_PropertyNotSupported = 2197815338u,
            EC_SlaveIDConflicted = 2197815339u,
            EC_SpanCalibrationFailed = 2197815340u,
            EC_InvalidAiValue = 2197815341u,
            EC_InvalidAoValue = 2197815342u,
            EC_GetModuleFailed = 2197815343u,
            EC_InvalidCntEnable = 2197815344u,
            EC_InvalidCntPulseInMode = 2197815345u,
            EC_InvalidCntInitValue = 2197815346u,
            EC_InvalidCntMaxValue = 2197815347u,
            EC_InvalidCntOverflowMode = 2197815348u,
            EC_InvalidCntLatchEnable = 2197815349u,
            EC_InvalidCntLatchEdge = 2197815350u,
            EC_InvalidCntCmpEnable = 2197815351u,
            EC_InvalidCntCmpMethod = 2197815352u,
            EC_InvalidCmpDoEnable = 2197815353u,
            EC_InvalidCmpDoMode = 2197815354u,
            EC_InvalidCmpDoLogic = 2197815355u,
            EC_InvalidCmpDoPulseWidth = 2197815356u,
            EC_AxCntExceeded = 2197815357u,
            EC_FWUpgraded = 2197815358u,
            EC_InvalidCntPulseInLogic = 2197815359u,
            EC_InvalidCntPulseInMaxFreq = 2197815360u,
            EC_InvalidCntMultiCmpDeviation = 2197815361u,
            EC_InvalidAoEnable = 2197815362u,
            EC_InvalidDoEnable = 2197815363u,
            EC_InvalidCntLatchLogic = 2197815364u,
            EC_InvalidCmpDoLinkPulseIn = 2197815365u,
            EC_InvalidDoOutputMode = 2197815366u,
            EC_InvalidDoLogic = 2197815367u,
            EC_InvalidDoPulseWidth = 2197815368u,
            EC_InvalidDoDelayTime = 2197815369u,
            EC_InvalidDoLinkCmpDo = 2197815370u,
            EC_UnequalCmpDataNumbers = 2197815371u,
            ECTDevError = 2197880832u,
            ECAT_MasterEcatError = 2197880833u,
            ECAT_SlaveDisconnect_R0 = 2197880834u,
            ECAT_SlaveDisconnect_R1 = 2197880835u,
            ECAT_R0_CHECK_OP_TIMEOUT = 2197880836u,
            ECAT_R0_PH_INIT_TIMEOUT = 2197880837u,
            ECAT_R0_START_TIMEOUT = 2197880838u,
            ECAT_R0_GET_SLAVE_ID_TIMEOUT = 2197880839u,
            ECAT_SlaveLostPDOArriveWarnThreshold_R0 = 2197880840u,
            ECAT_SlaveLostPDOArriveWarnThreshold_R1 = 2197880841u,
            ECAT_SlaveModeChange_R0 = 2197880842u,
            ECAT_SlaveModeChange_R1 = 2197880843u,
            ECAT_SlaveLostFrame_R0 = 2197880844u,
            ECAT_SlaveLostFrame_R1 = 2197880845u,
            ECAT_ReconnectError_R0 = 2197880846u,
            ECAT_ReconnectError_R1 = 2197880847u,
            ECAT_R1_CHECK_OP_TIMEOUT = 2197880848u,
            ECAT_R1_INIT_TIMEOUT = 2197880849u,
            ECAT_R1_START_TIMEOUT = 2197880850u,
            ECAT_R1_GET_SLAVE_ID_TIMEOUT = 2197880851u,
            ECAT_R0_GET_DEVICE_TYPE_FAILED = 2197880852u,
            ECAT_R1_GET_DEVICE_TYPE_FAILED = 2197880853u,
            ECAT_SlaveCountNotMatch_R0 = 2197880854u,
            ECAT_SlaveCountNotMatch_R1 = 2197880855u,
            ECTDevSDOError = 2197946368u,
            ECAT_SDO_ToggleBitNotChanged = 2197967616u,
            ECAT_SDO_ProtocolTimeout = 2197967872u,
            ECAT_SDO_CommandNotValidOrUnknown = 2197967873u,
            ECAT_SDO_OutOfMemory = 2197967877u,
            ECAT_SDO_UnsupportedAccess = 2197971200u,
            ECAT_SDO_WriteOnlyObject = 2197971201u,
            ECAT_SDO_ReadOnlyObject = 2197971202u,
            ECAT_SDO_ObjectNotExist = 2197971456u,
            ECAT_SDO_MappedToPDOFailed = 2197972033u,
            ECAT_SDO_ExceedPdoLength = 2197972034u,
            ECAT_SDO_ParameterIncompatibility = 2197972035u,
            ECAT_SDO_InternalIncompatibility = 2197972039u,
            ECAT_SDO_HardwareError = 2197972480u,
            ECAT_SDO_LengthNotMatch = 2197972752u,
            ECAT_SDO_LengthTooHigh = 2197972754u,
            ECAT_SDO_LengthTooLow = 2197972755u,
            ECAT_SDO_SubindexNotExist = 2197973265u,
            ECAT_SDO_ValueRangeExceeded = 2197973296u,
            ECAT_SDO_WrittenTooHigh = 2197973297u,
            ECAT_SDO_WrittenTooLow = 2197973298u,
            ECAT_SDO_MaximumLessMinimum = 2197973302u,
            ECAT_SDO_GeneralError = 2197979136u,
            ECAT_SDO_ErrorStoredToApplication = 2197979168u,
            ECAT_SDO_ErrorStoredOfLocalControl = 2197979169u,
            ECAT_SDO_ErrorStoredOfPresentDeviceState = 2197979170u,
            ECAT_SDO_DynamicGenerationFails = 2197979171u,
            ECTMotionError = 2198011904u,
            ECAT_MOTION_MASTER_NULL = 2198011905u,
            ECAT_MOTION_SCAN_BUSY = 2198011906u,
            ECAT_MOTION_DOMAIN_FAILED = 2198011907u,
            ECAT_MOTION_SLAVE_NOT_SUPPORT = 2198011908u,
            ECAT_MOTION_SLAVE_CONFIG_FAILED = 2198011909u,
            ECAT_MOTION_ACTIVE_FAILED = 2198011910u,
            ECAT_MOTION_DOMAN_DATA_FAILED = 2198011911u,
            ECTIOError = 2198077440u,
            ECAT_IO_MASTER_NULL = 2198077441u,
            ECAT_IO_SCAN_BUSY = 2198077442u,
            ECAT_IO_DOMAIN_FAILED = 2198077443u,
            ECAT_IO_SLAVE_NOT_SUPPORT = 2198077444u,
            ECAT_IO_SLAVE_CONFIG_FAILED = 2198077445u,
            ECAT_IO_ACTIVE_FAILED = 2198077446u,
            ECAT_IO_DOMAN_DATA_FAILED = 2198077447u,
            ECAT_IO_SLAVE_RESCAN = 2198077449u,
            ECTAxError = 2198142976u,
            ECAT_AxRetryError = 2198142977u,
            ECAT_AxResetCounterError = 2198142978u,
            ECAT_AxCmdErrorProtection = 2198142979u,
            ECAT_AxSlaveALM = 2198142980u,
            ECAT_AxFollowError = 2198142981u,
            ECAT_AxHomeError = 2198142982u,
            ECAT_AxSlaveStateChanged = 2198142983u,
            ECAT_AxSlaveDoNotReady = 2198142984u,
            ECTAxOPERATIONMODE = 2198142992u,
            ECTAxHOMEOFFSET = 2198143008u,
            ECTAxHOMEMODE = 2198143024u,
            ECAT_HM_OPMODE_ProtocolTimeout = 2198142993u,
            ECAT_HM_OPMODE_ObjectNotExist = 2198142994u,
            ECAT_HM_OPMODE_SubindexNotExist = 2198142995u,
            ECAT_HM_OPMODE_ValueRangeExceeded = 2198142996u,
            ECAT_HM_OPMODE_WrittenTooHigh = 2198142997u,
            ECAT_HM_OPMODE_WrittenTooLow = 2198142998u,
            ECAT_HM_OPMODE_MaximumLessMinimum = 2198142999u,
            ECAT_HM_OPMODE_OTHER = 2198143000u,
            ECAT_HM_OFFSET_ProtocolTimeout = 2198143009u,
            ECAT_HM_OFFSET_ObjectNotExist = 2198143010u,
            ECAT_HM_OFFSET_SubindexNotExist = 2198143011u,
            ECAT_HM_OFFSET_ValueRangeExceeded = 2198143012u,
            ECAT_HM_OFFSET_WrittenTooHigh = 2198143013u,
            ECAT_HM_OFFSET_WrittenTooLow = 2198143014u,
            ECAT_HM_OFFSET_MaximumLessMinimum = 2198143015u,
            ECAT_HM_OFFSET_OTHER = 2198143016u,
            ECAT_HM_MODE_ProtocolTimeout = 2198143025u,
            ECAT_HM_MODE_ObjectNotExist = 2198143026u,
            ECAT_HM_MODE_SubindexNotExist = 2198143027u,
            ECAT_HM_MODE_ValueRangeExceeded = 2198143028u,
            ECAT_HM_MODE_WrittenTooHigh = 2198143029u,
            ECAT_HM_MODE_WrittenTooLow = 2198143030u,
            ECAT_HM_MODE_MaximumLessMinimum = 2198143031u,
            ECAT_HM_MODE_OTHER = 2198143032u,
            ECTMotionConnError = 2198208512u,
            ECTIOConnError = 2198274048u,
            ECAT_DriveError = 2198863872u,
            ECAT_MotionConnStatus = 2214592512u,
            ECAT_IoConnStatus = 2231369728u
        }

        /// <summary>
        /// 研华板卡IO状态枚举
        /// </summary>
        public enum Ax_Motion_IO : uint
        {
            AX_MOTION_IO_RDY = 1u,
            AX_MOTION_IO_ALM = 2u,
            AX_MOTION_IO_LMTP = 4u,
            AX_MOTION_IO_LMTN = 8u,
            AX_MOTION_IO_ORG = 0x10u,
            AX_MOTION_IO_DIR = 0x20u,
            AX_MOTION_IO_EMG = 0x40u,
            AX_MOTION_IO_PCS = 0x80u,
            AX_MOTION_IO_ERC = 0x100u,
            AX_MOTION_IO_EZ = 0x200u,
            AX_MOTION_IO_CLR = 0x400u,
            AX_MOTION_IO_LTC = 0x800u,
            AX_MOTION_IO_SD = 0x1000u,
            AX_MOTION_IO_INP = 0x2000u,
            AX_MOTION_IO_SVON = 0x4000u,
            AX_MOTION_IO_ALRM = 0x8000u,
            AX_MOTION_IO_SLMTP = 0x10000u,
            AX_MOTION_IO_SLMTN = 0x20000u,
            AX_MOTION_IO_CMP = 0x40000u,
            AX_MOTION_IO_CAMDO = 0x80000u,
            AX_MOTION_IO_MAXTORLMT = 0x100000u
        }

        /// <summary>
        /// 研华板卡API中用到的属性枚举
        /// </summary>
        public enum PropertyID : uint
        {
            FT_Dev_ID = 0u,
            PAR_Dev_ID = 101u,
            CFG_Dev_ID = 201u,
            FT_Ax_ID = 301u,
            PAR_Ax_ID = 401u,
            CFG_Ax_ID = 501u,
            FT_Gp_ID = 601u,
            PAR_Gp_ID = 701u,
            CFG_Gp_ID = 801u,
            PAR_RB_ID = 1000u,
            CFG_RB_ID = 1200u,
            FT_CH_ID = 1300u,
            PAR_CH_ID = 1400u,
            CFG_CH_ID = 1500u,
            FT_DevIpoTypeMap = 0u,

            /// <summary>
            /// 设备轴数(Acm_GetU32Property)。
            /// </summary>
            FT_DevAxesCount = 1u,
            FT_DevFunctionMap = 2u,
            FT_DevOverflowCntr = 3u,
            FT_MasCyclicCnt_R0 = 4u,
            FT_MasCyclicCnt_R1 = 5u,
            FT_DevMDAQTypeMap = 6u,
            FT_DevMDAQTrigMap = 7u,
            FT_DevMDAQMaxChan = 8u,
            FT_DevMDAQMaxBufCount = 9u,
            FT_DevLTCBufMaxCount = 10u,
            FT_DevVersion = 11u,
            FT_DevEmgMap = 12u,
            FT_DevSupportAxesCount = 13u,
            FT_AresVariableCount = 14u,
            FT_AresSupportProcessCount = 0xFu,
            FT_ECAT_Version = 0x10u,
            FT_DevPulseInMap = 17u,
            FT_DevPulseInModeMap = 18u,
            FT_DevCompareMap = 19u,
            FT_DevLatchMap = 20u,
            FT_DevExtDriveMap = 21u,
            FT_SubVersion = 22u,
            FT_DaqDiMaxChan = 50u,
            FT_DaqDoMaxChan = 51u,
            FT_DaqAiRangeMap = 52u,
            FT_DaqAoRangeMap = 53u,
            FT_DaqAiMaxSingleChan = 54u,
            FT_DaqAiMaxDiffChan = 55u,
            FT_DaqAiResolution = 56u,
            FT_DaqAoMaxChan = 57u,
            FT_DaqAoResolution = 58u,
            FT_DaqCntMaxChan = 59u,
            FT_DevEmgFilterBasicTime = 60u,
            FT_DevDIFilterBasicTime = 61u,
            FT_DevPulseInFilterBasicTime = 62u,
            FT_DevHSDIFilterBasicTime = 0x3Fu,
            FT_DevHSDODelayBasicTime = 0x40u,
            FT_DevHSDOPWMBasicTime = 65u,
            FT_DevCmpMaxChan = 70u,
            FT_DevLtcMaxChan = 80u,
            CFG_DevBoardID = 201u,
            CFG_DevRingID = 202u,
            CFG_DevBaseAddress = 203u,
            CFG_DevInterrupt = 204u,
            CFG_DevBusNumber = 205u,
            CFG_DevSlotNumber = 206u,
            CFG_DevDriverVersion = 207u,
            CFG_DevDllVersion = 208u,
            CFG_DevComQualityContiErr = 209u,
            CFG_DevComQualityErrRate = 210u,
            CFG_DevComWdgMode = 211u,
            CFG_DevFwMemory = 212u,
            CFG_DevEmgReact = 213u,
            CFG_DevFwVersion = 214u,
            CFG_DevBelongsTo = 215u,
            CFG_DevMasterDev = 216u,
            CFG_DevSlaveDevs = 217u,
            CFG_DevCPLDVersion = 218u,
            CFG_DevCPLD_1Version = 219u,
            CFG_DevEmgLogic = 220u,
            CFG_DevLatestFwVersion = 221u,
            CFG_DevEmgFilterTime = 222u,
            CFG_DevMultiCmpAxisEnable = 223u,
            CFG_DevMultiCmpOutChannel = 224u,
            CFG_DevMultiCmpPulseLogic = 225u,
            CFG_DevMultiCmpPulseWidth = 226u,
            CFG_DevKillDec = 227u,
            CFG_DevFuncDiFltSmpRate = 228u,
            CFG_DevLogMsg = 229u,
            CFG_DevErrorReact = 230u,
            CFG_DevCompensateTableEnable = 231u,
            CFG_MasBaudRate_R0 = 232u,
            CFG_MasBaudRate_R1 = 233u,
            CFG_MasComErrRate_R0 = 234u,
            CFG_MasComErrRate_R1 = 235u,
            CFG_MasComContiErr_R0 = 236u,
            CFG_MasComContiErr_R1 = 237u,
            CFG_MasIoComContiErr_R0 = 238u,
            CFG_MasIoComContiErr_R1 = 239u,
            CFG_MasDataComContiErr_R0 = 240u,
            CFG_MasDataComContiErr_R1 = 241u,
            CFG_DaqAiChanType = 251u,
            CFG_DaqAiRanges = 252u,
            CFG_DaqMaiRanges = 253u,
            CFG_DaqAoRanges_C0 = 254u,
            CFG_DaqAoRanges_C1 = 0xFFu,
            CFG_DaqAoRanges_C2 = 0x100u,
            CFG_DaqAoRanges_C3 = 257u,
            CFG_DaqAiGain = 258u,
            CFG_MasCycleTime = 261u,
            CFG_IoCycleTime = 262u,
            CFG_DevMotionMasterShiftTime = 263u,
            CFG_DevIoMasterShiftTime = 264u,
            CFG_DevMultiTrigFifoWriteEnable = 265u,
            CFG_DevMultiTrigPulseMode = 266u,
            CFG_DevMultiTrigPWMFreq = 267u,
            CFG_DevMultiTrigPWMDuty = 268u,
            CFG_DevMultiTrigAutoEmptyEn = 269u,
            CFG_DevMultiTrigForcePWMCount = 270u,
            CFG_DevMotionLostFrameThreshold = 271u,
            CFG_DevIOLostFrameThreshold = 272u,
            CFG_DevMotionDisconnectEventTime = 273u,
            CFG_DevIoDisconnectEventTime = 274u,
            CFG_DevConfigurePDOs = 275u,
            CFG_DevMultiCmpAxisEnableEx = 276u,
            CFG_DevMultiCmpOutChannelEx = 277u,
            CFG_DevMotionDisconnectSlave = 278u,
            CFG_DevIoDisconnectSlave = 279u,
            CFG_DevExtEncoderEn = 281u,
            CFG_DevExtEncoderPPUNum = 282u,
            CFG_DevExtEncoderPPUDemo = 283u,
            CFG_DevExtEncoderLogic = 284u,
            CFG_DevExtEncoderChannel = 285u,
            CFG_DevMotionRescanTime = 295u,
            CFG_DevIoRescanTime = 296u,
            CFG_DevAresAutoRun = 297u,
            CFG_DevAresRestart = 298u,
            CFG_DevProcess0MonitorEnable = 299u,
            CFG_DevProcess1MonitorEnable = 300u,
            CFG_DevProcess2MonitorEnable = 301u,
            CFG_DevProcess3MonitorEnable = 302u,
            CFG_DevProcess4MonitorEnable = 303u,
            CFG_DevProcess5MonitorEnable = 304u,
            CFG_DevExtPulseInMode = 305u,
            CFG_DevSetAxisBatchMode = 306u,
            CFG_DevEvenTime = 307u,
            CFG_DevEmgFilterTimeEx = 308u,
            CFG_DevZAxisCompensateTableEnable = 309u,
            CFG_DevAutoRecovery = 310u,
            CFG_DevWaitStableTime = 311u,
            CFG_DevRecoveryTimeout = 312u,
            CFG_DevChangeWithPPU = 313u,
            FT_AxFunctionMap = 301u,
            FT_AxMaxVel = 302u,
            FT_AxMaxAcc = 303u,
            FT_AxMaxDec = 304u,
            FT_AxMaxJerk = 305u,
            FT_AxPulseInMap = 306u,
            FT_AxPulseInModeMap = 307u,
            FT_AxPulseOutMap = 308u,
            FT_AxPulseOutModeMap = 309u,
            FT_AxAlmMap = 310u,
            FT_AxInpMap = 311u,
            FT_AxErcMap = 312u,
            FT_AxErcEnableModeMap = 313u,
            FT_AxErcOnTimeMap = 314u,
            FT_AxErcOffTimeMap = 315u,
            FT_AxSdMap = 316u,
            FT_AxElMap = 317u,
            FT_AxSwMelMap = 318u,
            FT_AxSwPelMap = 319u,
            FT_AxHomeMap = 320u,
            FT_AxBackLashMap = 321u,
            FT_AxVibrationMap = 322u,
            FT_AxAlarmMap = 323u,
            FT_AxCompareMap = 324u,
            FT_AxLatchMap = 325u,
            FT_AxCamDOMap = 326u,
            FT_AxExtDriveMap = 327u,
            FT_AxExtMasterSrcMap = 328u,
            FT_AxGenDOMap = 329u,
            FT_AxGenDIMap = 330u,
            FT_AxSimStartSourceMap = 331u,
            FT_AxHomeModeMap = 332u,
            FT_AxIN1Map = 333u,
            FT_AxIN2Map = 334u,
            FT_AxIN3Map = 335u,
            FT_AxIN4Map = 336u,
            FT_AxIN5Map = 337u,
            FT_AxDIFilterMap = 338u,
            FT_AxJogMap = 339u,
            FT_AxSimStartSourceMapEx = 340u,
            FT_AxSvOnMap = 341u,
            FT_AxRingCounterMap = 342u,
            FT_AxPVTMap = 343u,
            FT_AxCmdFilterMap = 344u,
            FT_AxParameterDecimalScale = 345u,

            /// <summary>
            /// 初速度(Acm_SetF64Property)。
            /// </summary>
            PAR_AxVelLow = 401u,

            /// <summary>
            /// 运行速度(Acm_SetF64Property)
            /// </summary>
            PAR_AxVelHigh = 402u,

            /// <summary>
            /// 加速度(Acm_SetF64Property)。
            /// </summary>
            PAR_AxAcc = 403u,

            /// <summary>
            /// 减速度(Acm_SetF64Property)。
            /// </summary>
            PAR_AxDec = 404u,

            /// <summary>
            /// 速度类型。0表示T型1表示S型(Acm_SetF64Property)。
            /// </summary>
            PAR_AxJerk = 405u,
            PAR_AxHomeExMode = 406u,

            /// <summary>
            /// 设置Acm_AxHomeEx的停止条件
            /// </summary>
            PAR_AxHomeExSwitchMode = 407u,

            /// <summary>
            /// 设置起始交叉距离（单位：PPU）。此属性必须大于0。默认值为10000。
            /// </summary>
            PAR_AxHomeCrossDistance = 408u,
            PAR_AxJerkL = 409u,
            PAR_AxJogVelLow = 410u,
            PAR_AxJogVelHigh = 411u,
            PAR_AxJogAcc = 412u,
            PAR_AxJogDec = 413u,
            PAR_AxJogJerk = 414u,
            PAR_AxHomeVelLow = 415u,
            PAR_AxHomeVelHigh = 416u,
            PAR_AxHomeAcc = 417u,
            PAR_AxHomeDec = 418u,
            PAR_AxHomeJerk = 419u,
            PAR_AxJerkFactor = 443u,
            PAR_AxHomeJerkFactor = 444u,
            PAR_AxTargetPosition = 445u,
            PAR_AxTargetVelocity = 446u,
            PAR_AxTargetTorque = 447u,
            PAR_AxControlWord = 448u,
            PAR_AxStatusWord = 449u,
            PAR_AxOperationMode = 450u,
            PAR_AxMinAcc = 451u,
            PAR_AxJerkValue = 452u,
            PAR_AxDLValue = 453u,
            PAR_AxErrorCode = 454u,
            PAR_AxAbsPosi = 455u,
            PAR_AxHomeMode = 456u,
            PAR_AxHomeDir = 457u,
            PAR_AxOffsetBase = 458u,
            PAR_AxRotateOffsetBase = 459u,
            CFG_AxPPU = 551u,
            CFG_AxPhyID = 552u,
            CFG_AxMaxVel = 553u,
            CFG_AxMaxAcc = 554u,
            CFG_AxMaxDec = 555u,
            CFG_AxMaxJerk = 556u,
            CFG_AxPulseInMode = 557u,
            CFG_AxPulseInLogic = 558u,
            CFG_AxPulseInSource = 559u,
            CFG_AxPulseOutMode = 560u,
            CFG_AxAlmEnable = 561u,
            CFG_AxAlmLogic = 562u,
            CFG_AxAlmReact = 563u,
            CFG_AxInpEnable = 564u,
            CFG_AxInpLogic = 565u,
            CFG_AxErcLogic = 566u,
            CFG_AxErcOnTime = 567u,
            CFG_AxErcOffTime = 568u,
            CFG_AxErcEnableMode = 569u,
            CFG_AxSdEnable = 570u,
            CFG_AxSdLogic = 571u,
            CFG_AxSdReact = 572u,
            CFG_AxSdLatch = 573u,
            CFG_AxElEnable = 574u,
            CFG_AxElLogic = 575u,
            CFG_AxElReact = 576u,
            CFG_AxSwMelEnable = 577u,
            CFG_AxSwPelEnable = 578u,
            CFG_AxSwMelReact = 579u,
            CFG_AxSwPelReact = 580u,
            CFG_AxSwMelValue = 581u,
            CFG_AxSwPelValue = 582u,
            CFG_AxHomeDir = 584u,
            CFG_AxHomePosition = 586u,
            CFG_AxOrgEnable = 588u,
            CFG_AxOrgLogic = 589u,
            CFG_AxEzEnable = 590u,
            CFG_AxEzLogic = 591u,
            CFG_AxEzCount = 592u,
            CFG_AxBacklashEnable = 593u,
            CFG_AxBacklashPulses = 594u,
            CFG_AxVibrationEnable = 595u,
            CFG_AxVibrationReverseTime = 596u,
            CFG_AxVibrationForwardTime = 597u,
            CFG_AxPositionLagEn = 598u,
            CFG_AxMaxPositionLag = 599u,
            CFG_AxEmgReaction = 600u,
            CFG_AxLatchLogic = 601u,
            CFG_AxHomeResetEnable = 602u,
            CFG_AxCmpSrc = 603u,
            CFG_AxCmpMethod = 604u,
            CFG_AxCmpPulseMode = 605u,
            CFG_AxCmpPulseLogic = 606u,
            CFG_AxCmpPulseWidth = 607u,
            CFG_AxCmpEnable = 608u,
            CFG_AxRange = 609u,
            CFG_AxGenDoEnable = 610u,
            CFG_AxExtMasterSrc = 611u,
            CFG_AxExtSelEnable = 612u,
            CFG_AxExtPulseNum = 613u,
            CFG_AxOrgLatch = 614u,
            CFG_AxOutLogic = 615u,
            CFG_AxDirLogic = 616u,
            CFG_AxExtPulseInMode = 617u,
            CFG_AxExtPresetNum = 618u,
            CFG_AxErcOffTmEnable = 619u,
            CFG_AxAuxOutEnable = 620u,
            CFG_AxAuxOutTime = 621u,
            CFG_AxCamDOEnable = 622u,
            CFG_AxCamDOLoLimit = 623u,
            CFG_AxCamDOHiLimit = 624u,
            CFG_AxCamDOMode = 625u,
            CFG_AxCamDODir = 626u,
            CFG_AxCamDOCmpSrc = 627u,
            CFG_AxCamDOLogic = 628u,
            CFG_AxModuleRange = 629u,
            CFG_AxBacklashVel = 630u,
            CFG_AxLatchEnable = 631u,
            CFG_AxPulseInMaxFreq = 632u,
            CFG_AxSimStartSource = 633u,
            CFG_AxOrgReact = 634u,
            CFG_AxIN1StopEnable = 635u,
            CFG_AxIN1StopReact = 636u,
            CFG_AxIN1StopLogic = 637u,
            CFG_AxIN2StopEnable = 638u,
            CFG_AxIN2StopReact = 639u,
            CFG_AxIN2StopLogic = 640u,
            CFG_AxIN4StopEnable = 641u,
            CFG_AxIN4StopReact = 642u,
            CFG_AxIN4StopLogic = 643u,
            CFG_AxIN5StopEnable = 644u,
            CFG_AxIN5StopReact = 645u,
            CFG_AxIN5StopLogic = 646u,
            CFG_AxLatchBufEnable = 647u,
            CFG_AxLatchBufMinDist = 648u,
            CFG_AxLatchBufEventNum = 649u,
            CFG_AxLatchBufSource = 650u,
            CFG_AxLatchBufAxisID = 651u,
            CFG_AxLatchBufEdge = 652u,
            CFG_AxHomeOffsetDistance = 653u,
            CFG_AxHomeOffsetVel = 654u,
            CFG_AxPWMFreq = 655u,
            CFG_AxPWMDuty = 656u,
            CFG_AxPPUDenominator = 657u,
            CFG_AxGantryMaxDiffValue = 658u,
            CFG_AxPelToleranceEnable = 666u,
            CFG_AxPelToleranceValue = 667u,
            CFG_AxSwPelToleranceEnable = 668u,
            CFG_AxSwPelToleranceValue = 669u,
            CFG_AxCmpPulseWidthEx = 670u,
            CFG_AxMelToleranceEnable = 671u,
            CFG_AxMelToleranceValue = 672u,
            CFG_AxSwMelToleranceEnable = 673u,
            CFG_AxSwMelToleranceValue = 674u,
            CFG_AxALMFilterTime = 675u,
            CFG_AxLMTPFilterTime = 676u,
            CFG_AxLMTNFilterTime = 677u,
            CFG_AxIN1FilterTime = 678u,
            CFG_AxIN2FilterTime = 679u,
            CFG_AxORGFilterTime = 680u,
            CFG_AxIN4FilterTime = 681u,
            CFG_AxIN5FilterTime = 682u,
            CFG_AxEncoderRatio = 683u,
            CFG_AxMaxErrCount = 684u,
            CFG_AxResponseTime = 685u,
            CFG_AxMaxCorrectTimes = 686u,
            CFG_AxMultiCmpDeviation = 687u,
            CFG_AxForcePWMOutTime = 688u,
            CFG_AxLatchStopEnable = 689u,
            CFG_AxLatchStopReact = 690u,
            CFG_AxPulseStopSrc = 691u,
            CFG_AxJogVLTime = 692u,
            CFG_AxPulseOutReverse = 693u,
            CFG_AxKillDec = 694u,
            CFG_AxJogVelLow = 695u,
            CFG_AxJogVelHigh = 696u,
            CFG_AxJogAcc = 697u,
            CFG_AxJogDec = 698u,
            CFG_AxJogJerk = 699u,
            CFG_AxMaxErrorCnt = 700u,
            CFG_AxCounterMax = 701u,
            CFG_AxOverflowMode = 702u,
            CFG_AxGantryActDiffValue = 703u,
            CFG_AxPelLogic = 704u,
            CFG_AxMelLogic = 705u,
            CFG_AxSetCmpDO = 706u,
            CFG_AxMPGOffsetEnable = 707u,
            CFG_AxMPGOffsetSum = 708u,
            CFG_AxIN1StopEdge = 709u,
            CFG_AxIN2StopEdge = 710u,
            CFG_AxIN4StopEdge = 711u,
            CFG_AxIN5StopEdge = 712u,
            CFG_AxIN1OffsetValue = 713u,
            CFG_AxIN2OffsetValue = 714u,
            CFG_AxIN4OffsetValue = 715u,
            CFG_AxIN5OffsetValue = 716u,
            CFG_AxMPGMaxVel = 717u,
            CFG_AxMPGAcc = 718u,
            CFG_AxMPGDec = 719u,
            CFG_AxMPGStopReact = 720u,
            CFG_AxJogPAssign = 721u,
            CFG_AxJogNAssign = 722u,
            CFG_AxCamDOAssign = 723u,
            CFG_AxIN1StopAssign = 724u,
            CFG_AxAxTorqueConstData = 725u,
            CFG_AxTorqueEnable = 726u,
            CFG_AxJogJerkFactor = 727u,
            CFG_AxDIStartTime = 728u,
            CFG_AxDIStartEdge = 729u,
            CFG_AxHomeORGSide = 730u,
            CFG_AxCompensateEnable = 731u,
            CFG_AxCmpTrigPathEnable = 732u,
            CFG_AxCounterMin = 733u,
            CFG_AxMaxTorque = 734u,
            CFG_AxMaxMotorSpeed = 735u,
            CFG_AxSvOnLogic = 736u,
            CFG_AxGantryCompFactor = 738u,
            CFG_AxRstLogic = 739u,
            CFG_AxRstOn = 740u,
            CFG_AxErcOn = 741u,
            CFG_AxPVTVelLow = 742u,
            CFG_AxPVTDec = 743u,
            CFG_AxCmdFilterMode = 744u,
            CFG_AxCmdFilterFactor = 745u,
            CFG_AxRotateFlag = 746u,
            CFG_AxRotateBestPath = 747u,
            CFG_AxRotateCircleNumber = 748u,
            CFG_AxRstOnTime = 749u,
            CFG_AxRstOffTime = 750u,
            CFG_AxRstOffTmEnable = 751u,
            CFG_AxRstEnableMode = 752u,
            CFG_AxPelShiftBits = 753u,
            CFG_AxMelShiftBits = 754u,
            CFG_AxOrgShiftBits = 755u,
            CFG_AxHomeAdjustTime = 756u,
            CFG_AxPelEnable = 757u,
            CFG_AxMelEnable = 758u,
            CFG_AxALMFilterTimeEx = 759u,
            CFG_AxLMTPFilterTimeEx = 760u,
            CFG_AxLMTNFilterTimeEx = 761u,
            CFG_AxORGFilterTimeEx = 762u,
            CFG_AxPulseInMaxFreqEx = 763u,
            CFG_AxAlmCommErrorEnable = 764u,
            PAR_GpVelLow = 701u,
            PAR_GpVelHigh = 702u,
            PAR_GpAcc = 703u,
            PAR_GpDec = 704u,
            PAR_GpJerk = 705u,
            PAR_GpGroupID = 706u,
            PAR_GpJerkL = 707u,
            PAR_GpIsPathDec = 708u,
            PAR_GpRefPlane = 709u,
            PAR_GpJerkFactor = 710u,
            CFG_GpMaxVel = 801u,
            CFG_GpMaxAcc = 802u,
            CFG_GpMaxDec = 803u,
            CFG_GpMaxJerk = 804u,
            CFG_GpPPU = 805u,
            CFG_GpAxesInGroup = 806u,
            CFG_GpGroupID = 807u,
            CFG_GpBldTime = 808u,
            CFG_GpSFEnable = 809u,
            CFG_GpVectorEnable = 814u,
            CFG_GpSpdFwdVelEn = 815u,
            CFG_GpCornerAngleFloor = 816u,
            CFG_GpCornerAngleCeiling = 817u,
            CFG_GpCornerSpeedRatio = 818u,
            CFG_GpSFMinCornerTime = 819u,
            CFG_GpAxesInGroupEx = 820u,
            CFG_GpPWMLinkVel = 821u,
            CFG_GpPWMMonitorMode = 822u,
            CFG_GpPWMRefVel = 823u,
            CFG_GpPathMode = 824u,
            PAR_RbVelLow = 1000u,
            PAR_RbVelHigh = 1001u,
            PAR_RbAcc = 1002u,
            PAR_RbDec = 1003u,
            PAR_RbJerk = 1004u,
            PAR_RbRefPlane = 1005u,
            CFG_RbLengthArm1 = 1200u,
            CFG_RbLengthArm2 = 1201u,
            CFG_RbLengthArm3 = 1202u,
            CFG_RbHandMode = 1203u,
            CFG_RbSFEnable = 1204u,
            CFG_RbLengthArm4 = 1205u,
            CFG_RbLengthArm5 = 1206u,
            CFG_RbCSys = 1207u,
            CFG_RbJogAxis = 1208u,
            CFG_RbRZCOUPLING = 1209u,
            CFG_RbRZCFNumerator = 1210u,
            CFG_RbRZCFDenominator = 1211u,
            CFG_RbScaraAxisMode = 1212u,
            CFG_RbJ1J2CouplingEn = 1213u,
            CFG_RbMoveLinkCSAngle = 1214u,
            CFG_RbMoveLinkAutoEn = 1215u,
            CFG_CH_DaqDiInvertEnable = 1500u,
            CFG_CH_DaqDiLowFilter = 1501u,
            CFG_CH_DaqDiHighFilter = 1502u,
            CFG_CH_DaqDoFsvEnable = 1503u,
            CFG_CH_DaqAoRange = 1504u,
            CFG_CH_DaqAiRange = 1505u,
            CFG_CH_DaqAiEnable = 1506u,
            CFG_CH_DaqAiIntegrationTime = 1507u,
            CFG_CH_DaqAoFsv = 1508u,
            CFG_CH_DaqAoStartup = 1509u,
            CFG_CH_DaqDoFuncSelect = 1510u,
            CFG_CH_DaqDoOutputMode = 1511u,
            CFG_CH_DaqDoLogic = 1512u,
            CFG_CH_DaqDoPulseWidth = 1513u,
            CFG_CH_DaqDoDelayTime = 1514u,
            CFG_CH_DaqDoLinkCmpDo = 1515u,
            CFG_CH_DaqAoEnable = 1523u,
            CFG_CH_DaqCmpDoEnable = 1550u,
            CFG_CH_DaqCmpDoOutputMode = 1551u,
            CFG_CH_DaqCmpDoLogic = 1552u,
            CFG_CH_DaqCmpDoPulseWidth = 1553u,
            CFG_CH_DaqCmpDoLinkPulseIn = 1554u,
            CFG_CH_DaqCntPulseInMode = 1600u,
            CFG_CH_DaqCntPulseInLogic = 1601u,
            CFG_CH_DaqCntPulseInMaxFreq = 1602u,
            CFG_CH_DaqCntMultiCmpDeviation = 1610u,
            CFG_CH_DaqCntLatchEnable = 1620u,
            CFG_CH_DaqCntLatchEdge = 1621u,
            CFG_CH_DaqCntLatchLogic = 1622u,
            CFG_CH_DaqCntLatchMinDist = 1623u,
            CFG_CH_DaqCntExtPulseNum = 1630u,
            CFG_CH_DaqCntExtPulseInMode = 1631u,
            CFG_CH_DaqCntEnable = 1700u,
            CFG_CH_DaqCntInitValue = 1701u,
            CFG_CH_DaqCntMaxValue = 1702u,
            CFG_CH_DaqCntOverflowMode = 1703u,
            CFG_CH_DaqCntCmpEnable = 1704u,
            CFG_CH_DaqCntCmpMethod = 1705u
        }

        /// <summary>
        /// 研华板卡API中用到的轴状态枚举
        /// </summary>
        public enum AxisState : uint
        {
            STA_AX_DISABLE,
            STA_AX_READY,
            STA_AX_STOPPING,
            STA_AX_ERROR_STOP,
            STA_AX_HOMING,
            STA_AX_PTP_MOT,
            STA_AX_CONTI_MOT,
            STA_AX_SYNC_MOT,
            STA_AX_EXT_JOG,
            STA_AX_EXT_MPG,
            STA_AX_PAUSE,
            STA_AX_BUSY,
            STA_AX_WAIT_DI,
            STA_AX_WAIT_PTP,
            STA_AX_WAIT_VEL
        }

        /// <summary>
        /// 研华板卡API中用到的轴群组状态枚举
        /// </summary>
        public enum GroupState : ushort
        {
            STA_Gp_Disable,
            STA_Gp_Ready,
            STA_Gp_Stopping,
            STA_Gp_ErrorStop,
            STA_Gp_Motion,
            STA_GP_AX_MOTION,
            STA_GP_Pathing,
            STA_GP_PAUSE,
            STA_GP_BUSY
        }
    }
}

using PropertyChanged;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace WCSPro.Model
{
    /// <summary>
    /// 轴信息实体类
    /// </summary>
    [AddINotifyPropertyChangedInterface]
    public class AxisInfo
    {
        /// <summary>
        /// 轴编号
        /// </summary>
        public string Code { get; set; }

        /// <summary>
        /// 轴名称
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// 连接状态("UnConnected"、"Connected")
        /// </summary>
        public string ConnectState { get; set; } = "UnConnected";

        /// <summary>
        /// 轴状态
        /// </summary>
        public string AxisState { get; set; } = string.Empty;

        /// <summary>
        /// 其它信息(详见本实体类下方说明)
        /// </summary>
        public Dictionary<string, object> OtherInfo { get; set; } = new Dictionary<string, object>();

        //其它信息说明
        //"Handle"：存放控制句柄，类型IntPart。
        //"MotionInfo"：存放运动控制卡信息对象，类型MotionInfo。
        //"Factor"：距离转换脉冲的系数，类型decimal。
        //"VelL"：初速度，类型double。
        //"VelH"：运行速度，类型double。
        //"Acc"：加速度，类型double。
        //"Dec"：减速度，类型double。
        //"Jerk"：速度类型(0：T型、1：S型)，类型double。

        public override string ToString()
        {
            return this.Name;
        }
    }
}