////**********************************************************************************************************
//
//  Copyright(c) 2017, Shenzhen Gaochuan Industrial Automation Co.,Ltd
//
//  Moudle Name :   nmc_lib20.h
//
//  Abstract    :   GaoChuan Motion 2.0 User Header
//
//  Note        :   1.结构体定义中所有的'reservedxxx'的成员都是保留参数,为保持向后兼容性,请设置为0。
//                  2.无特别说明,所有API返回RTN_CMD_SUCCESS（即0值）表示执行成功,其他则表示错误代码,见mtn_lib20_err.h。
//                  3.所有的API参数中,无特别说明,axisHandle表示操作轴的句柄,devHandle表示目标控制器的句柄,
//                    crdHandle表示目标坐标系组句柄。
//                  4.若无特别说明,所有API的参数中,牵涉到序号则从0开始,比如NMC_MtOpen中的itemNo参数,0表示第一个轴。
//
// Modification History :
//
////**********************************************************************************************************
#ifndef _H_NMC_LIB20_H_
#define _H_NMC_LIB20_H_

#ifdef __cplusplus
extern "C" {
#endif

//------------------------------------------------------------------------------------------------------------
//
//              宏定义
//
//------------------------------------------------------------------------------------------------------------
// 编译控制
#ifndef MTN_API
    #ifdef WIN32 
        #ifdef NMC_LIB_EXPORTS
            #define MTN_API __declspec(dllexport)
        #else
            #define MTN_API __declspec(dllimport)
        #endif
    #else
        #define MTN_API 
        #define __stdcall 
    #endif    
#endif

// 句柄类型定义
typedef     unsigned short*     PHAND;
typedef     unsigned short      HAND;

//------------------------------------------------------------------------------------------------------------
//
//           指令分组索引
//
//------------------------------------------------------------------------------------------------------------
//  1.控制器连接、关闭
//  2.单轴配置
//  3.单轴控制
//  4.单轴状态读取
//  5.IO控制及外部资源读写
//  6.坐标系配置
//  7.坐标系控制
//  8.坐标系及运动缓冲区状态读取
//  9.缓冲区插补运动和IO控制
//  10.回零


//------------------------------------------------------------------------------------------------------------
//
//          1.控制器连接、关闭
//
//------------------------------------------------------------------------------------------------------------
// 通讯模式设置
typedef enum { USB=0, Ethernet, RS485 } TSearchMode;

//设备信息结构
typedef struct
{
    unsigned short address;     // 在上位机系统中的设备序号,
    char  idStr[16];            // 识别字符串
    char  description[64];      // 描述符
    unsigned short ID;          // 板上的ID(未用)
}TDevInfo;

// 板卡搜寻
// 参数: mode:通讯模式
// pDevNo : 返回设备的数目
// pInfoList：返回设备信息
MTN_API short __stdcall NMC_DevSearch( TSearchMode mode, unsigned short *pDevNo, TDevInfo *pInfoList );

// 板卡打开（根据序号）
// devNo: 设备序号,取值范围[0,n]； pDevHandle: 返回设备操作句柄
MTN_API short __stdcall NMC_DevOpen       ( short devNo, PHAND pDevHandle );

// 板卡关闭
// pDevHandle : 设备句柄指针
MTN_API short __stdcall NMC_DevClose(PHAND pDevHandle );

// 板卡复位
MTN_API short __stdcall NMC_DevReset(HAND devHandle );

// 打开单轴
// devHandle : 设备句柄
// itemNo：轴号,取值范围[0,n]
// pCrdHandle：坐标系组句柄
MTN_API short  __stdcall NMC_MtOpen(HAND devHandle, short itemNo, PHAND pAxisHandle ); 

// 关闭单轴
// devHandle : 设备句柄指针
MTN_API short  __stdcall NMC_MtClose(PHAND pAxisHandle );

// 打开坐标系组
// pCrdHandle：返回坐标系组句柄
MTN_API short __stdcall NMC_CrdOpen(HAND devHandle, PHAND pCrdHandle );

// 打开坐标系组(支持多坐标系)
// itemNo：坐标系号,取值范围[0,1]
// pCrdHandle：返回坐标系组句柄
MTN_API short __stdcall NMC_CrdOpenEx( HAND devHandle,short itemNo, PHAND pCrdHandle );

// 关闭坐标系组
// pCrdHandle：坐标系组句柄
MTN_API short __stdcall NMC_CrdClose(PHAND pCrdHandle );


//------------------------------------------------------------------------------------------------------------
//
//          2.单轴配置
//
//------------------------------------------------------------------------------------------------------------
// 系统扩展资源的起始ID,包括扩展编码器／模拟量输入输出
#define EXT_RES_START_INDEX  256

// 编码器模式：定义信号源,信号类型,取反,,编码器分频等 
// Bit7:0 分频系数,数值为0~255。对应分频数值 1~256
// Bit9:8 信号号源选择
//   00：外部信号输入
//   01: 轴脉冲输入
//   10：自动产生信号（正脉冲）
//   11：自动产生信号（负脉冲）
// Bit11:10 信号类型（外部）
//  00：AB相,90度差
//  01：脉冲+方向
//  10：正脉冲+负脉冲
//  11：保留
// Bit12 输入A、B交换（外部） 0：不交换,1：交换
// Bit13 输入A取反（外部） 0：不取反,1：取反
// Bit14 输入B取反（外部） 0：不取反,1：取反
// Bti15 编码器饱和,0：最大最小值翻转,1：不翻转
// 设置编码器模式
// encId: 编码器ID,对于轴编码器通道,取值范围[0,n],
//                对于扩展编码器通道,256表示第一个扩展编码器通道,257表示第二个,以此类推
// encMode:编码器模式,参考宏定义
MTN_API short  __stdcall NMC_SetEncMode( HAND devHandle, short encId,  short encMode );

// 设置软件限位是否停止运动
// enable：软件限位触发允许设置,1为允许,0为禁止
MTN_API short  __stdcall NMC_MtSwLmtOnOff  ( HAND axisHandle, short swt );

// 设置软件限位数值
// posLmt：正向软件限位设置值
// negLmt：负向软件限位设置值。单位为脉冲数
MTN_API short  __stdcall NMC_MtSwLmtValue  ( HAND axisHandle, long posLmt,long negLmt );

//轴运动安全参数
typedef struct
{
    double estpDec;     // 急停加速度
    double maxVel;      // 最大速度
    double maxAcc;      // 最大加速度
}TSafePara;
// 设置轴安全参数
// TSafePara：包含急停减速度、最大允许速度、最大允许加速度
MTN_API short  __stdcall NMC_MtSetSafePara( HAND axisHandle, TSafePara *pPara );

// 设置脉冲输出模式
// inv, 1：取反,0：不取反
// mode 0：脉冲方向 1：正负脉冲
MTN_API short  __stdcall NMC_MtSetStepMode ( HAND axisHandle, short inv, short mode );

// 设置轴速度滤波参数
// 注：filterCoef系数在0~5之间,值越大,速度越平滑，默认值为0
MTN_API short __stdcall NMC_MtSetAxisVelFilter(HAND axisHandle,short filterCoef);


// 硬件限位配置
// posLmtEnable: 正向限位触发允许设置,1为允许,0为禁止
// negLmtEnable: 负向限位触发允许设置,1为允许,0为禁止
// posLmtSns: 正向限位触发电平,1为高电平触发,0为低电平触发
// negLmtSns: 正向限位触发电平,1为高电平触发,0为低电平触发
MTN_API short __stdcall NMC_MtSetLmtCfg( HAND axisHandle, short posLmtEnable,short negLmtEnable,short posLmtSns,short negLmtSns );

// 伺服报警配置
// alarmEnable: 伺服报警触发允许设置,1为允许,0为禁止
// alarmSns:     伺服报警触发电平,1为高电平触发,0为低电平触发
MTN_API short __stdcall NMC_MtSetAlarmCfg( HAND axisHandle, short alarmEnable,short alarmSns );

// 设置脉冲输出滤波
// coe系数： 范围0~65535,0不滤波,数值越大滤波效果越明显。
MTN_API short  __stdcall NMC_MtSetStepFilter ( HAND axisHandle, unsigned short  coe );

//------------------------------------------------------------------------------------------------------------
//
//          3.单轴控制指令
//
//------------------------------------------------------------------------------------------------------------
// 各轴的规划模式
#define MT_NONE_PRF_MODE        (-1)            // 无效
#define MT_PTP_PRF_MODE         (0)             // 梯形规划
#define MT_JOG_PRF_MODE         (1)             // 连续速度模式
#define MT_CRD_PRF_MODE         (3)             // 坐标系
#define MT_GANTRY_MODE          (4)             // 龙门跟随模式
#define MT_PT_PRF_MODE			(5)				// PT模式

// 设置单轴规划模式
// mode：单轴运动模式
MTN_API short __stdcall NMC_MtSetPrfMode(HAND axisHandle,short mode);

// 单轴PTP运动参数结构
typedef struct
{
    double acc;         // 加速度
    double dec;         // 减速度
    double startVel;    // 起跳速度
    double endVel;      // 终止速度
    short smoothCoef;   // 平滑系数,取值范围[0,199]
    short reserved[3];      // 保留
}TPtpPara;
// 设置多个参数, 并更新。
// pAxPara：参数,参考结构定义。
MTN_API short __stdcall NMC_MtSetPtpPara( HAND axisHandle, TPtpPara *pAxPara );

// 单轴JOG运动参数结构
typedef struct
{
    double acc;         // 加速度
    double dec;         // 减速度
    double smoothCoef;  // 平滑系数,取值范围[0,199]
}TJogPara;
// 设置Jog运动参数
// pAxPara：参数,参考结构定义。
MTN_API short __stdcall NMC_MtSetJogPara   ( HAND axisHandle, TJogPara *pAxPara );

// 设置目标运动速度,只针对PTP和Jog：PTP模式下只接受正数,Jog模式下正负号标识运动方向
// vel: 目标速度（最大速度）,单位是 脉冲/ms
MTN_API short __stdcall NMC_MtSetVel( HAND axisHandle, double vel );

// 设置目标运动位置,只针对PTP
// pos: 目标位置,单位是 脉冲
MTN_API short __stdcall NMC_MtSetPtpTgtPos( HAND axisHandle, long pos );

// 参数更新, 只针对PTP和Jog
MTN_API short __stdcall NMC_MtUpdate( HAND axisHandle );

// 单轴运动停止
// 注：运动会按设定的减速度停止。
MTN_API short __stdcall NMC_MtStop( HAND axisHandle );

// 单轴急停
// 注：运动会按设定的急停加速度停止。如果没有设置,则会立即停止。
MTN_API short __stdcall NMC_MtEstp    ( HAND axisHandle );

// 单轴急停，不会置起急停标志位
// 注：运动会按设定的急停加速度停止。如果没有设置,则会立即停止。
MTN_API short __stdcall NMC_MtAbruptStop( HAND axisHandle );

// 单轴位置系统清零,规划以及编码器
MTN_API short __stdcall NMC_MtZeroPos( HAND axisHandle);

// 设置伺服报警清除输出的状态
// swt: 设置开关有效状态。1, 有效（输出低电平）,0,无效（输出高电平）
MTN_API short  __stdcall NMC_MtSetSvClr( HAND axisHandle, short swt );

// 设置伺服ON, 轴静止时执行,如果后面是update指令,需要延时一个周期
MTN_API short  __stdcall NMC_MtSetSvOn( HAND axisHandle );

// 设置伺服OFF, 轴静止时执行,如果后面是update指令,需要延时一个周期
MTN_API short  __stdcall NMC_MtSetSvOff( HAND axisHandle );

// 清除轴错误状态
MTN_API short  __stdcall NMC_MtClrError ( HAND axisHandle );

// 清除轴错误状态,按位清除
// stsMask:对应位为1表明需要清除对应位的错误状态
MTN_API short  __stdcall NMC_MtClrStsByBits(HAND axisHandle , short stsMask);

// 单轴点位运动,包含NMC_MtSetPrfMode,NMC_MtSetPtpPara,NMC_MtSetVel,NMC_MtSetPtpTgtPos,NMC_MtUpdate
// acc:加速度,dec：减速度,startVel:起跳速度,endVel:终止速度,smoothCoef:平滑系数
// maxVel：最大速度
// tgtPos:目标位置,单位：脉冲
MTN_API short  __stdcall NMC_MtMovePtpAbs(HAND axisHandle,double acc,double dec,double startVel,double endVel,double maxVel,short smoothCoef,long tgtPos);

// 单轴点位运动,相对运动
// acc:加速度,dec：减速度,startVel:起跳速度,endVel:终止速度,smoothCoef:平滑系数
// maxVel：最大速度
// relPos:相对当前位置的移动量,单位：脉冲
MTN_API short  __stdcall NMC_MtMovePtpRel(HAND axisHandle,double acc,double dec,double startVel,double endVel,double maxVel,short smoothCoef,long relPos);

// 启动手轮
// axis:轴号,取值范围[0,n]
// ratio:跟随倍率,取值范围(0,..],数值越大,则同样的输入,跟随轴运动距离越长
// acc:跟随的加速度
// vel:跟随的速度
// 注：编码器信号源为控制器上手脉端口
MTN_API short __stdcall NMC_SetHandWheel(HAND devHandle,short axis,double ratio,double acc,double vel);

//------------------------------------------------------------------------------------------------------------
//
//         4.单轴状态读取
//
//------------------------------------------------------------------------------------------------------------
// 读取规划坐标系的位置
// pPos : 返回位置,单位是 脉冲
MTN_API short __stdcall NMC_MtGetPrfPos   ( HAND axisHandle, long *pPos );

// 读当前轴规划速度
// pVel: 返回速度,单位是 脉冲/ms
MTN_API short __stdcall NMC_MtGetPrfVel   ( HAND axisHandle, double *pVel );

// 读取打包轴状态（4轴）
#define PACK_AXIS_NUM   4
typedef struct
{
    long prfPos[PACK_AXIS_NUM];     // 规划位置
    long encPos[PACK_AXIS_NUM];     // 实际位置
    float prfVel[PACK_AXIS_NUM];    // 规划速度
    long motionIO[PACK_AXIS_NUM];   // 轴专用IO
    short sts[PACK_AXIS_NUM];       // 轴状态
    long gpo;                       // 通用输出
    long gpi;                       // 通用输入
}TAxisStsPack;
// 打包读取多个轴的状态,从第一个轴开始读取后续四个轴的状态
// axisFirstHandle : 第一个轴句柄
// count:读取状态的轴数量,取值范围：[1,4]
// pPackSts: 打包的状态数据,参考结构体定义
MTN_API short  __stdcall NMC_MtGetStsPack  ( HAND axisFirstHandle, short count,TAxisStsPack *pPackSts );

// 读取打包轴状态（12轴）
typedef struct
{
	long prfPos[12];     // 规划位置
	long encPos[12];     // 实际位置
	float prfVel[12];    // 规划速度
	long motionIO[12];   // 轴专用IO
	short sts[12];       // 轴状态
	long gpo;            // 通用输出
	long gpi;            // 通用输入
}TAxisStsPack12;
// 打包读取12个轴的状态,从第一个轴开始读取
// axisFirstHandle : 第一个轴句柄
// pPackSts: 打包的状态数据,参考结构体定义
MTN_API short  __stdcall NMC_MtGetStsPack12  ( HAND axisFirstHandle, TAxisStsPack12 *pPackSts );

// 读取打包轴状态（8轴）
typedef struct
{
	long prfPos[8];     // 规划位置
	long encPos[8];     // 实际位置
	float prfVel[8];    // 规划速度
	long motionIO[8];   // 轴专用IO
	short sts[8];       // 轴状态
	long gpo;            // 通用输出
	long gpi;            // 通用输入
}TAxisStsPack8;
// 打包读取8个轴的状态,从第一个轴开始读取
// axisFirstHandle : 第一个轴句柄
// pPackSts: 打包的状态数据,参考结构体定义
MTN_API short  __stdcall NMC_MtGetStsPack8  ( HAND axisFirstHandle, TAxisStsPack8 *pPackSts );

// 读当前轴编码器通道
// pPos:返回编码器数值
MTN_API short  __stdcall NMC_MtGetEncPos   ( HAND axisHandle, long *pPos );

// 读轴编码器速度(单位是：脉冲/ms)
MTN_API short  __stdcall NMC_GetEncVel( HAND devHandle, short encId, double *pVel);

// 轴状态字位定义 
#define BIT_AXIS_BUSY           (0x00000001)    // bit 0  , 运动:1 ,静止 0       
#define BIT_AXIS_POSREC         (0x00000002)    // bit 1 , 伺服位置到达,步进模式时位置到达,伺服模式时实际位置到达误差限 
#define BIT_AXIS_MVERR          (0x00000004)    // bit 2 , 上次运动出错,或当前无法启动运动,需要软件复位 
#define BIT_AXIS_SVON           (0x00000008)    // bit 3  , 伺服允许        
#define BIT_AXIS_CRD            (0x00000010)    // bit 4 , 坐标系模式      
#define BIT_AXIS_STEP           (0x00000020)    // bit 5  , 步进/伺服       
#define BIT_AXIS_LMTP           (0x00000040)    // bit 6  , 正向限位        
#define BIT_AXIS_LMTN           (0x00000080)    // bit 7  , 负面限位        
#define BIT_AXIS_SOFTPOSLMT     (0x00000100)    // bit 8  , 正向软限位触发  
#define BIT_AXIS_SOFTNEGLMT     (0x00000200)    // bit 9  , 负向软限位触发  
#define BIT_AXIS_ALM            (0x00000400)    // bit 10  , 伺服报警,需要软件复位 
#define BIT_AXIS_POSERR         (0x00000800)    // bit 11  , 位置超限,需要软件复位 
#define BIT_AXIS_ESTP           (0x00001000)    // bit 12 , 急停,需要软件复位 
#define BIT_AXIS_HWERR          (0x00002000)    // bit 13 , 硬件错误 
#define BIT_AXIS_CAPTSET        (0x00004000)    // bit 14  , 捕获触发       
// 读当前轴状态
// pStsWord: 返回轴状态字。参考位定义
MTN_API short  __stdcall NMC_MtGetSts( HAND axisHandle, short *pStsWord );

// 专用IO定义,arrive,alm : home : limit+ , limit- 
#define BIT_AXMTIO_LMTN     (0x00000001)    // bit 0  ,负向限位  
#define BIT_AXMTIO_LMTP     (0x00000002)    // bit 1  ,正向限位  
#define BIT_AXMTIO_HOME     (0x00000004)    // bit 2  ,原点  
#define BIT_AXMTIO_ALARM    (0x00000008)    // bit 3  ,驱动报警 
#define BIT_AXMTIO_ARRIVE   (0x00000010)    // bit 4  ,电机到位 
// 读运动控制专用IO
// pIoValue : 返回专用IO的状态,原点,限位,报警。参考位定义。对应位为0为低电平,1为高电平。
MTN_API short __stdcall NMC_MtGetMotionIO ( HAND axisHandle, long *pIoValue );

// 读运动控制专用IO,逻辑电平
// pIoValue : 返回专用IO的状态,原点,限位,报警。参考位定义。对应位为0为低电平,1为高电平。
MTN_API short __stdcall NMC_MtGetMotionIOLogical ( HAND axisHandle, long *pIoValue );

//------------------------------------------------------------------------------------------------------------
//
//        5.IO控制及外部资源读写
//
//------------------------------------------------------------------------------------------------------------
// 设置通用输出(按通道,支持超过32位),带默认group
// value: 设置通用数字量输出。1, 输出高电平,0,输出低电平
// groupID:DO组,取值范围[0,n],具体需要看控制器是否存在多组数字量输出
MTN_API short  __stdcall NMC_SetDOGroup( HAND devHandle, long value, short groupID) ;

// 读通用输入(按通道,支持超过32位) ,带默认group
// pInValue: 通用数字量输入值。1, 高电平,0,低电平
// groupID:DI组,取值范围[0,n],0: 本地DI31~DI0, 1: 本地DI63~DI32,其他指扩展IO模块
MTN_API short __stdcall NMC_GetDIGroup( HAND devHandle, long *pInValue, short groupID);

// 读取通用输出(按通道,支持超过32位),带默认group
// pDoValue: 设置通用数字量输出。1, 高电平,0,低电平
// groupID:DO组,取值范围[0,n],,0: 本地DO31~DO0, 1: 本地DO63~DO32,其他指扩展IO模块
MTN_API short  __stdcall NMC_GetDOGroup( HAND devHandle, long *pDoValue, short groupID);

// 按位设置通用输出
// bitIndex:取值范围[0,n],位序号,前64位为本地的通用输出,大于64为扩展DO
// value: 设置通用数字量输出。1, 输出高电平,0,输出低电平
MTN_API short  __stdcall NMC_SetDOBit( HAND devHandle, short bitIndex, short value );

// 按位读通用输入 
// 读通用输入(按通道,支持超过32位) 
// bitIndex:取值范围[0,n],位序号
// pBitValue: 通用数字量输入值。1, 高电平,0,低电平
MTN_API short  __stdcall NMC_GetDIBit( HAND devHandle,short bitIndex, short *pBitValue );

// 读取扩展IO模块的状态
// sts:io模块状态
MTN_API short  __stdcall NMC_GetIOModuleSts(HAND devHandle, unsigned long *sts);

// 设置扩展IO模块有效
// chDevId:设备ID
MTN_API short  __stdcall NMC_SetIOModuleEn( HAND devHandle, unsigned char chDevId);


//------------------------------------------------------------------------------------------------------------
//
//        6.坐标系配置
//
//------------------------------------------------------------------------------------------------------------
// 坐标系配置
typedef struct
{
    short axCnts;       // 参与的轴数量
    short reserved[3];  // 保留
    short pAxArray[4];  // 坐标系轴映射表,轴序号取值范围[0,n]
    short port[4];      // 坐标系端口映射表,统一设为0
}TCrdConfig;
// 建立插补坐标系系统(必须)
// pConfig:坐标系配置,参考结构体定义
MTN_API short __stdcall NMC_CrdConfig( HAND crdHandle, TCrdConfig *pConfig );

//缓冲区运动安全参数
typedef struct
{
    double estpDec;     // 急停加速度
    double maxVel;      // 最大速度
    double maxAcc;      // 最大加速度
}TCrdSafePara;
// 设置轴缓冲区运动安全参数
// pPara：包含急停减速度、最大允许速度、最大允许加速度
MTN_API short  __stdcall NMC_CrdSetSafePara( HAND crdHandle, TCrdSafePara *pPara );

// 设置轴缓冲区运动偏移
// count:设置偏移的轴数
// pOffsetArray：缓冲区运动偏移,long数组
// 注：会同时修改坐标系内相关轴的运动偏移！
MTN_API short  __stdcall NMC_CrdSetOffset( HAND crdHandle,short count, long *pOffsetArray );

// 删除坐标系
MTN_API short __stdcall NMC_CrdDelete(  HAND crdHandle );


//------------------------------------------------------------------------------------------------------------
//
//        7.坐标系运行控制
//
//------------------------------------------------------------------------------------------------------------
// 坐标系缓冲运动启动  
MTN_API short __stdcall NMC_CrdStartMtn( HAND crdHandle );

// 立即平滑停止运动
// 注：立即停止运动。并不清空指令缓冲区。需要再次启动才能继续运行缓冲区指令。
MTN_API short __stdcall NMC_CrdStopMtn( HAND crdHandle );

// 急停
// 并不清空指令缓冲区
MTN_API short __stdcall NMC_CrdEstopMtn( HAND crdHandle );

// 结束缓冲区运动（等待运动完后才结束区运动,并置空闲标志）
// 注：缓冲区运动结束并不立即停止运动。把指令缓冲区全部执行完后,结束缓冲区运动状态。
MTN_API short __stdcall NMC_CrdEndMtn   ( HAND crdHandle );

// 返回缓冲区运动的断点
// vel:返回时使用的速度
// acc:返回时使用的加速度
MTN_API short __stdcall NMC_CrdGotoBreak( HAND crdHandle,double acc,double vel);


//------------------------------------------------------------------------------------------------------------
//
//        8.坐标系及运动缓冲区状态读取
//
//------------------------------------------------------------------------------------------------------------
// 坐标系状态字位定义 
#define BIT_CORD_BUSY           (0x00000001)    // bit 0 , 运动:1 ,静止 0,立即运动下运动停止,完成 
#define BIT_CORD_MVERR          (0x00000002)    // bit 1 , 运动出错,或当前运动指令无法启动,需要软件复位    
#define BIT_CORD_EMPTY          (0x00000004)    // bit 2 , 缓冲区空　       
#define BIT_CORD_FULL           (0x00000008)    // bit 3 , 缓冲区满　               
#define BIT_CORD_NODATASTOP     (0x00000010)    // bit 4 , 缓冲区空异常停止或者急停　    
#define BIT_CORD_SDRAM_HWERR    (0x00000020)    // bit 5, 插补缓冲区硬件或者其他错误  
// 读取坐标系状态
// pStsWord：返回状态字,参考宏定义
MTN_API short __stdcall NMC_CrdGetSts( HAND crdHandle, short  *pStsWord );

// 读取规划位置XYZ
// cnts: 读取个数,1~N
// pPosArray：返回坐标数组
MTN_API short __stdcall NMC_CrdGetPrfPos( HAND crdHandle, short cnts, long *pPosArray );

// 坐标系模式下,读取多个轴的机械坐标位置
// cnts: 读取个数,1~N
// pPos：返回坐标数组
MTN_API short __stdcall NMC_CrdGetAxisPos(HAND crdHandle,short cnts, long *pPosArray);

// 获取坐标系合成速度
// pVel：坐标系合成速度
MTN_API short __stdcall  NMC_CrdGetVel(HAND crdHandle,double *pVel);

// 读取编码器位置
// cnts: 读取个数,1~N
// pPos：返回坐标数组。
MTN_API short __stdcall NMC_CrdGetEncPos  ( HAND crdHandle, short cnts, long *pPosArray );

typedef struct
{
    short crdSts;          // 坐标系状态
    short axSts[3];        // 坐标系里各轴状态
    long  prfPos[3];       // 用户坐标系下的规划位置
    long  axisPos[3];      // 机械坐标系下的规划位置
    long  encPos[3];        // 编码器位置
    long  userSeg;         // 运行的缓冲区段号
    double  prfVel;         // 运动速度
    long  gpDi;             // 通用输入0~31
    long  gpDo;             // 通用输出0~31
    short  motDi[3];        // 限位、原点、报警。请参考专用IO位定义( 搜索 BIT_AXMTIO_LMTN )
    short  reserved;        // 保留
    long crdFreeSpace;      // 缓冲区剩余空间
    long reserved2;
}TPackedCrdSts3;
// 坐标系运动模式下,打包读取控制器状态
MTN_API short __stdcall NMC_CrdGetStsPack3( HAND crdHandle, TPackedCrdSts3 *pPackSts );

// 清坐标系运动错误状态,同时清除所包含轴的错误状态
MTN_API short __stdcall NMC_CrdClrError   ( HAND crdHandle );

// 设置坐标系速度倍率
// overRide：坐标系速度倍率,取值范围(0,10)
MTN_API short __stdcall NMC_CrdSetOverRide( HAND crdHandle, double overRide );

// 读取指令缓冲区空闲长度
// pRes：返回空闲的长度
MTN_API short __stdcall NMC_CrdBufGetFree ( HAND crdHandle, long *pRes );

// 读取指令缓冲区已用长度
// pLen: 长度。缓冲区中还未执行的指令个数。
MTN_API short __stdcall NMC_CrdBufGetUsed  ( HAND crdHandle, long *pLen );

// 指令缓冲区清空
MTN_API short __stdcall NMC_CrdBufClr( HAND crdHandle );

// 读段号
// pSegNo：返回的当前段号
MTN_API short __stdcall NMC_CrdGetUserSegNo  ( HAND crdHandle, long *pSegNo);

//  读取总共压了多少条指令
//  pCnt:返回的指令数
MTN_API short __stdcall NMC_CrdGetBufAllCmdCnt ( HAND crdHandle, long *pCnt);


//------------------------------------------------------------------------------------------------------------
//
//        9.缓冲区插补运动和IO控制
//
//------------------------------------------------------------------------------------------------------------
// 直线插补
// segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
// mask:参与的轴,按位表示
// pTgPosArray：目标位置数组,长度为3
MTN_API short __stdcall NMC_CrdLineXYZ(  HAND crdHandle,  long segNo, short mask,long *pTgPosArray, double endVel, double vel,double synAcc );

// segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
// mask:参与的轴,按位表示
// pTgPosArray：目标位置数组,长度为3
// lookaheadDis:是否使用前瞻,0：使用前瞻,则控制器自动计算终点速度,1：禁用前瞻,使用设定的终点速度（endVel）
MTN_API short __stdcall NMC_CrdLineXYZEx(  HAND crdHandle,  long segNo, short mask,long *pTgPosArray,
	double endVel, double vel,double synAcc,short lookaheadDis );

// 多轴直线插补（最多支持8轴）
// segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
// crdAxmask:坐标系中参与的轴,按位表示
// extAxmask:其他参与轴,按位表示,不能包括坐标系中
// pTgPosArray：目标位置数组,长度为所有参与运动的轴的数量,
//              索引小的是坐标系内的轴的坐标（按crdAxMask位排列）。索引大的是其它联动轴的坐标（按extAxMask位排列）
// lookaheadDis:是否使用前瞻(仅仅适用与坐标系中的轴的运动),0：使用前瞻,则控制器自动计算终点速度,1：禁用前瞻,使用设定的终点速度（endVel）
MTN_API short __stdcall NMC_CrdLineXYZD8(  HAND crdHandle, long segNo, 
	long crdAxmask, long extAxmask, long *pTgPosArray,
	double endVel, double vel,double synAcc,short lookaheadDis );

// 8轴插补打包单元结构体
typedef struct
{
    long segNo;         // 用户自定义段号
	short crdAxMask;
	short extAxMask;
    long  tgPos[8];     // 目标位置
	float vel;         // 最大速度
	float endVel;      // 终点速度
    float acc;			// 插补加速度
	short lookaheadDis;	// 是否使用前瞻
	short reserved;		// 保留
}TCrdLineXYZD8Unit;

// 打包的多轴直线插补
// count:打包指令数,取值范围[1,18]
// pCmdArray:指令列表
MTN_API short __stdcall NMC_CrdLineXYZD8Pack(  HAND crdHandle, short count,  TCrdLineXYZD8Unit *pCmdArray);


// 4轴插补打包单元结构体
typedef struct
{
    long segNo;         // 用户自定义段号
	short crdAxMask;
	short extAxMask;
    long  tgPos[4];     // 目标位置
	float vel;         // 最大速度
	float endVel;      // 终点速度
    float acc;      // 插补加速度
	short lookaheadDis;	// 是否使用前瞻
	short reserved;		// 保留
}TCrdLineXYZD4Unit;

// 打包的4轴直线插补
// count:打包指令数,取值范围[1,25]
// pCmdArray:指令列表
MTN_API short __stdcall NMC_CrdLineXYZD4Pack(  HAND crdHandle, short count,  TCrdLineXYZD4Unit *pCmdArray);

typedef struct
{
    long segNo;         // 用户自定义段号
    long  tgPos[3];     // 目标位置
    double endVel;      // 终点速度
    double vel;         // 最大速度
    double synAcc;      // 插补加速度
    short mask;         // 参与的轴,按位表示
	short lookaheadDis;	// 是否使用前瞻
    short reserved[2];  // 保留
}TCrdLineXYZUnit;
// 打包的直线插补
// count:打包指令数,取值范围[1,20]
// pCmdArray:指令列表
MTN_API short __stdcall NMC_CrdLineXYZPack(  HAND crdHandle, short count,  TCrdLineXYZUnit *pCmdArray);

// XY平面圆弧插补：终点位置、半径、方向
// segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
// radius:圆弧半径,大于0表示劣弧,小于0表示优弧
// pTgPosArray：目标位置数组（二维数组,分别表示XY的位置）
// circleDir:圆弧方向,0表示顺时针方向,1表示逆时针方向
MTN_API short __stdcall NMC_CrdArcRadius(  HAND crdHandle, long segNo,long *pTgPosArray, double radius, short circleDir,double endVel, double vel,double synAcc );

// YZ平面圆弧插补：终点位置、半径、方向
// segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
// radius:圆弧半径,大于0表示劣弧,小于0表示优弧
// pTgPosArray：目标位置数组（二维数组,分别表示YZ的位置）
// circleDir:圆弧方向,0表示顺时针方向,1表示逆时针方向
MTN_API short __stdcall NMC_CrdArcRadiusYZ(  HAND crdHandle, long segNo,
	long *pTgPos, double radius, short circleDir,double velEnd, double vel,double synAcc );

// ZX平面圆弧插补：终点位置、半径、方向
// segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
// radius:圆弧半径,大于0表示劣弧,小于0表示优弧
// pTgPosArray：目标位置数组（二维数组,分别表示ZX的位置）
// circleDir:圆弧方向,0表示顺时针方向,1表示逆时针方向
MTN_API short __stdcall NMC_CrdArcRadiusZX(  HAND crdHandle, long segNo,
	long *pTgPos, double radius, short circleDir,double velEnd, double vel,double synAcc );

// XY平面圆弧插补：终点位置、半径、方向
// segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
// radius:圆弧半径,大于0表示劣弧,小于0表示优弧
// pTgPosArray：目标位置数组（二维数组,分别表示XY的位置）
// circleDir:圆弧方向,0表示顺时针方向,1表示逆时针方向
// lookaheadDis:是否使用前瞻,0：使用前瞻,则控制器自动计算终点速度,1：禁用前瞻,使用设定的终点速度（endVel）
MTN_API short __stdcall NMC_CrdArcRadiusEx(  HAND crdHandle, long segNo,long *pTgPosArray, double radius, 
								short circleDir,double endVel, double vel,double synAcc ,short lookaheadDis);

// YZ平面圆弧插补：终点位置、半径、方向
// segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
// radius:圆弧半径,大于0表示劣弧,小于0表示优弧
// pTgPosArray：目标位置数组（二维数组,分别表示YZ的位置）
// circleDir:圆弧方向,0表示顺时针方向,1表示逆时针方向
// lookaheadDis:是否使用前瞻,0：使用前瞻,则控制器自动计算终点速度,1：禁用前瞻,使用设定的终点速度（endVel）
MTN_API short __stdcall NMC_CrdArcRadiusYZEx(  HAND crdHandle, long segNo,long *pTgPos, double radius, 
	short circleDir,double velEnd, double vel,double synAcc ,short lookaheadDis);

// ZX平面圆弧插补：终点位置、半径、方向
// segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
// radius:圆弧半径,大于0表示劣弧,小于0表示优弧
// pTgPosArray：目标位置数组（二维数组,分别表示ZX的位置）
// circleDir:圆弧方向,0表示顺时针方向,1表示逆时针方向
// lookaheadDis:是否使用前瞻,0：使用前瞻,则控制器自动计算终点速度,1：禁用前瞻,使用设定的终点速度（endVel）
MTN_API short __stdcall NMC_CrdArcRadiusZXEx(  HAND crdHandle, long segNo,long *pTgPos, double radius, 
	short circleDir,double velEnd, double vel,double synAcc ,short lookaheadDis);

// XY平面圆弧插补：终点位置、圆心、方向
// segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
// pCenterPosArray:圆心坐标（二维数组,分别表示XY轴相对于起点的圆心位置）,注意：圆心坐标为相对于起点的相对位置
// pTgPosArray：目标位置（二维数组,分别表示XY轴的目标位置）
// circleDir:圆弧方向,0表示顺时针方向,1表示逆时针方向
MTN_API short __stdcall NMC_CrdArcCenter(  HAND crdHandle, long segNo,long *pTgPosArray, long *pCenterPosArray,short circleDir,double endVel, double vel,double synAcc );

// YZ平面圆弧插补：终点位置、圆心、方向
// segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
// pCenterPosArray:圆心坐标（二维数组,分别表示YZ轴相对于起点的圆心位置）,注意：圆心坐标为相对于起点的相对位置
// pTgPosArray：目标位置（二维数组,分别表示YZ轴的目标位置）
// circleDir:圆弧方向,0表示顺时针方向,1表示逆时针方向
MTN_API short __stdcall NMC_CrdArcCenterYZ(  HAND crdHandle, long segNo,long *pTgPos, 
	long *pCenterPos,short circleDir,double velEnd, double vel,double synAcc );

// ZX平面圆弧插补：终点位置、圆心、方向
// segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
// pCenterPosArray:圆心坐标（二维数组,分别表示ZX轴相对于起点的圆心位置）,注意：圆心坐标为相对于起点的相对位置
// pTgPosArray：目标位置（二维数组,分别表示ZX轴的目标位置）
// circleDir:圆弧方向,0表示顺时针方向,1表示逆时针方向
MTN_API short __stdcall NMC_CrdArcCenterZX(  HAND crdHandle, long segNo,long *pTgPos, 
	long *pCenterPos,short circleDir,double velEnd, double vel,double synAcc );

// XY平面圆弧插补：终点位置、圆心、方向
// segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
// pCenterPosArray:圆心坐标（二维数组,分别表示XY轴相对于起点的圆心位置）,注意：圆心坐标为相对于起点的相对位置
// pTgPosArray：目标位置（二维数组,分别表示XY轴的目标位置）
// circleDir:圆弧方向,0表示顺时针方向,1表示逆时针方向
// lookaheadDis:是否使用前瞻,0：使用前瞻,则控制器自动计算终点速度,1：禁用前瞻,使用设定的终点速度（endVel）
MTN_API short __stdcall NMC_CrdArcCenterEx(  HAND crdHandle, long segNo,long *pTgPosArray, long *pCenterPosArray,
										short circleDir,double endVel, double vel,double synAcc ,short lookaheadDis);

// YZ平面圆弧插补：终点位置、圆心、方向
// segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
// pCenterPosArray:圆心坐标（二维数组,分别表示ZX轴相对于起点的圆心位置）,注意：圆心坐标为相对于起点的相对位置
// pTgPosArray：目标位置（二维数组,分别表示YZ轴的目标位置）
// circleDir:圆弧方向,0表示顺时针方向,1表示逆时针方向
// lookaheadDis:是否使用前瞻,0：使用前瞻,则控制器自动计算终点速度,1：禁用前瞻,使用设定的终点速度（endVel）
MTN_API short __stdcall NMC_CrdArcCenterYZEx(  HAND crdHandle, long segNo,long *pTgPos, long *pCenterPos,
    short circleDir,double velEnd, double vel,double synAcc ,short lookaheadDis);

// ZX平面圆弧插补：终点位置、圆心、方向
// segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
// pCenterPosArray:圆心坐标（二维数组,分别表示ZX轴相对于起点的圆心位置）,注意：圆心坐标为相对于起点的相对位置
// pTgPosArray：目标位置（二维数组,分别表示ZX轴的目标位置）
// circleDir:圆弧方向,0表示顺时针方向,1表示逆时针方向
// lookaheadDis:是否使用前瞻,0：使用前瞻,则控制器自动计算终点速度,1：禁用前瞻,使用设定的终点速度（endVel）
MTN_API short __stdcall NMC_CrdArcCenterZXEx(  HAND crdHandle, long segNo,long *pTgPos, long *pCenterPos,
    short circleDir,double velEnd, double vel,double synAcc ,short lookaheadDis);

// XY平面圆弧插补：起点（当前点）、中点、终点
// segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
// pMidPosArray:中间位置点坐标（二维数组,分别表示中间点的XY轴的位置）
// pTgPosArray：终点位置坐标（二维数组,分别表示终点的XY轴的位置）
MTN_API short __stdcall NMC_CrdArcPPP(  HAND crdHandle,long segNo, long *pMidPosArray, long *pTgPosArray, double endVel, double vel,double synAcc );

// XY平面圆弧插补：起点（当前点）、中点、终点
// segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
// pMidPosArray:中间位置点坐标（二维数组,分别表示中间点的XY轴的位置）
// pTgPosArray：终点位置坐标（二维数组,分别表示终点的XY轴的位置）
// lookaheadDis:是否使用前瞻,0：使用前瞻,则控制器自动计算终点速度,1：禁用前瞻,使用设定的终点速度（endVel）
MTN_API short __stdcall NMC_CrdArcPPPEx(  HAND crdHandle,long segNo, long *pMidPosArray, long *pTgPosArray, 
												double endVel, double vel,double synAcc ,short lookaheadDis);

// 螺旋线插补
// segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
// pTgPosArray：目标位置（三维数组,分别表示终点的XYZ轴的位置）
// pCenterPosArray:圆心位置（二维数组,分别表示XY轴相对于起点的圆心位置）,注意：圆心坐标为相对于起点的相对位置
// rounds: Z方向圈数
MTN_API short __stdcall NMC_CrdHelixCenter(  HAND crdHandle, long segNo, long *pTgPosArray, long *pCenterPosArray,short circleDir,double rounds, double endVel, double vel,double synAcc );

// 螺旋线插补
// segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
// pTgPosArray：目标位置（三维数组,分别表示终点的XYZ轴的位置）
// pCenterPosArray:圆心位置（二维数组,分别表示XY轴相对于起点的圆心位置）,注意：圆心坐标为相对于起点的相对位置
// rounds: Z方向圈数
// lookaheadDis:是否使用前瞻,0：使用前瞻,则控制器自动计算终点速度,1：禁用前瞻,使用设定的终点速度（endVel）
MTN_API short __stdcall NMC_CrdHelixCenterEx(  HAND crdHandle, long segNo, long *pTgPosArray, long *pCenterPosArray,short circleDir,
														double rounds, double endVel, double vel,double synAcc ,short lookaheadDis);

// 3D圆弧插补
// segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
// pMidPos：中点位置（三维数组,分别表示中点的XYZ轴的位置）
// pTgPos:终点位置（三维数组,分别表示终点的XYZ轴的位置）
MTN_API short __stdcall NMC_CrdArc3D(  HAND crdHandle,long segNo, long *pMidPos, long *pTgPos,
									double velEnd, double vel,double synAcc );

// 3D圆弧插补
// segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
// pMidPos：中点位置（三维数组,分别表示中点的XYZ轴的位置）
// pTgPos:终点位置（三维数组,分别表示终点的XYZ轴的位置）
// lookaheadDis:是否使用前瞻,0：使用前瞻,则控制器自动计算终点速度,1：禁用前瞻,使用设定的终点速度（endVel）
MTN_API short __stdcall NMC_CrdArc3DEx(  HAND crdHandle,long segNo, long *pMidPos, long *pTgPos,
									double velEnd, double vel,double synAcc ,short lookaheadDis);


// 缓冲区输出DO组定义
#define CRD_BUFF_DO_MOTOR_ENABLE            1   // 电机使能
#define CRD_BUFF_DO_MOTOR_CLEAR             2   // 电机报警清除
#define CRD_BUFF_DO_GPDO1                   3   // 通用输出1
#define CRD_BUFF_DO_GPDO2                   4   // 通用输出2
// 缓冲区DO
// segNo:段号
// gourp:Do组别,见宏定义
// ch：位序号,取值范围[0,31]
// value：输出值,取值范围[0,1]
MTN_API short __stdcall NMC_CrdBufDo( HAND crdHandle, long segNo, short group,   long  ch,  long  value);

// 缓冲区DO
// segNo:段号
// gourp:Do组别,见宏定义
// doMask：位掩码
// doValue：输出值
MTN_API short  __stdcall NMC_CrdBufDoEx(HAND crdHandle,long segNo,short group,long doMask,long doValue);

// 通用输出宏类型
#define BUF_OUT_GROUP_DA        (0)             // 模拟量输出
#define BUF_OUT_GROUP_PWM       (1)             // PWM输出
// 缓冲区输出
// segNo:段号
// gourp:组别,见宏定义
// ch：通道号,取值范围[0,n]
// value：输出值
MTN_API short __stdcall NMC_CrdBufOut( HAND crdHandle,  long segNo, short group, short ch, long  value);

// 缓冲区DI等待
// index:通道号
// diValue：等待值
// waitLastTime：超时,单位：毫秒
MTN_API short __stdcall NMC_CrdBufWaitDI(HAND crdHandle, long segNo,short index,short diValue,long waitLastTime);

// 功能:缓冲区等待电机运动到位
// segNo:段号
// axisMask:需要等待到位的轴掩码（按位对应轴号,不能超出控制器的最大轴数）
// overTime:等待到位超时的时间
MTN_API short  __stdcall NMC_CrdBufWaitEncInPosition(HAND crdHandle,long segNo,long axisMask,long overTime);

// 缓冲区延时单位
#define CRD_BUFF_DELAY_SCALE_MS             0   // 毫秒
#define CRD_BUFF_DELAY_SCALE_SECAND         1   // 秒
// 缓冲区延时
// segNo:段号
// scale:延时单位,0表示单位为毫秒,1表示单位为秒
// count：延时时长
MTN_API short __stdcall NMC_CrdBufDelay( HAND crdHandle, long segNo, short scale, long  count);

// 缓冲区单轴移动(绝对位移移动)
// segNo:段号
// axMask:参与的轴
// pTgPos：目标位置
// blockEn:是否为阻塞模式
// synEn：是否为同步模式,如果synEn和blockEn同时为1,则同步优先
MTN_API short __stdcall NMC_CrdBufAxMove( HAND crdHandle,  long segNo, short axMask,long *pTgPos,short blockEn ,short synEn);

// 缓冲区单轴移动(带参数)
// segNo:段号
// axMask:参与的轴
// pTgPos：目标位置
// vel:速度
// acc:加速度
// blockEn:是否为阻塞模式
// synEn：是否为同步模式,如果synEn和blockEn同时为1,则同步优先
MTN_API short  __stdcall NMC_CrdBufAxMoveEx(HAND crdHandle,long segNo,short axMask,long *pTgPos,
	double vel,double acc,short blockEn ,short synEn);

// 缓冲区单轴移动(相对位移移动)
// segNo:段号
// axMask:参与的轴
// pRelPos：相对移动位置
// blockEn:是否为阻塞模式
// synEn：是否为同步模式,如果synEn和blockEn同时为1,则同步优先
MTN_API short __stdcall NMC_CrdBufAxMoveRel( HAND crdHandle,  long segNo, short axMask,long *pRelPos,short blockEn ,short synEn);

// 缓冲区单轴移动参数设置
// segNo:段号
// axis：轴号,[0,n]
// vel:运动速度
// acc:运动加速度
// smoothCoef:平滑系数
MTN_API short __stdcall NMC_CrdBufSetPtpMovePara(HAND crdHandle, long segNo,short axis,double vel,double acc,short soomthCoef);

// 缓冲区跟随
// segNo:段号
// onOff:开关
MTN_API short __stdcall NMC_CrdBufValueFollow ( HAND crdHandle ,  long segNo, short onOff );


//------------------------------------------------------------------------------------------------------------
//
//        10.回零
//
//------------------------------------------------------------------------------------------------------------
// 回零类型定义                                                 
// 回零模式    单原点      单限位     单Z相    原点+Z相 原点+ -Z相  限位+ -Z相
typedef enum { HM_MODE1=0, HM_MODE2, HM_MODE3, HM_MODE4, HM_MODE5, HM_MODE6 } THomeMode;

// 回零参数设置
typedef struct
{
    short  mode;                    // 模式,HM_MODE1 ~ HM_MODE6 （必须）
    short  dir;                     // 搜寻零点方向（必须）, 0:负向,1：正向,其它值无意义
    long    offset;                 // 原点偏移（必须）
    double  scan1stVel;             // 基本搜寻速度（必须）
    double  scan2ndVel;             // 低速（两次搜寻时需要）
    // 当usePreSetPtpPara=0时,回零运动的减加速度默认等于acc,起跳速度、终点速度、平滑系数默认为0
    double  acc;                    // 加速度
    
    unsigned char reScanEn;         // 是否两次搜寻零点（可选,不用时设为0）
    unsigned char homeEdge;         // 原点,触发沿（默认下降沿）
    unsigned char lmtEdge;          // 限位,触发沿（默认下降沿）
    unsigned char zEdge;            // 限位,触发沿（默认下降沿）
    unsigned long iniRetPos;        // 起始反向运动距离（可选,不用时设为0）
    unsigned long retSwOffset;      // 反向运动时离开开关距离（可选,不用时设为0）
    unsigned long safeLen;          // 安全距离,回零时最远搜寻距离（可选,不用时设为0,不限制距离）
    unsigned char usePreSetPtpPara; // 为1表示用户需要在启动回零前,自己设置回零运动（点到点）的参数
    unsigned char reserved[3];      // 保留
    long reserved2;                 // 保留
} THomeSetting;
// 设置回零参数
// pHomePara: 回零参数结构,参考结构定义
MTN_API short __stdcall NMC_MtSetHomePara( HAND axisHandle, THomeSetting *pHomePara );

// 回零状态字位定义 
#define BIT_AXHOME_BUSY         (0x00000001)    // bit 0  , 忙    
#define BIT_AXHOME_OK           (0x00000002)    // bit 1  , 成功  
#define BIT_AXHOME_FAIL         (0x00000004)    // bit 2  , 失败  
#define BIT_AXHOME_ERR_MV       (0x00000008)    // bit 3  , 错误：运动参数出错导致不动 
#define BIT_AXHOME_ERR_SWT      (0x00000010)    // bit 4  , 错误：搜寻过程中开关没触发 
// 读回零状态
// pStsWord: 返回状态字。参数宏定义
MTN_API short __stdcall NMC_MtGetHomeSts(HAND axisHandle, short *pStsWord );

// 启动回零
MTN_API short __stdcall NMC_MtHome(HAND axisHandle );

// 尝试性回零（测试回零误差,不清位置）
MTN_API short __stdcall NMC_MtTryHome( HAND axisHandle );

// 终止回零
MTN_API short __stdcall NMC_MtHomeStop(HAND axisHandle );

// 读新回零位置和历史回零位置的差值
// pErrPos: 回零位置偏差
// 注：回零成功时才有意义
MTN_API short __stdcall NMC_MtGetHomeError( HAND axisHandle, long *pErrPos );//------------------------------------------------------------------------------------------------------------
//
//           指令分组索引
//
//------------------------------------------------------------------------------------------------------------
//	1.设备高级配置等
//	2.单轴配置读取
//	3.单轴高级指令
//	4.缓冲区高级指令
//	5.硬件捕获及不常用指令
//	6.平台相关指令
//	7.数据采集模块(高级指令)
//	8.激光
//	9.龙门
//  10.通讯扩展等其他
//  11.手轮
//  12.PT
//  13.线性距离位置比较
//  14.二维位置点比较
//  15.多维位置比较输出
//  16.坐标系输出转换
//  17.结构体初始化函数及常见习惯指令
//  18.闭环
//  19.高级BufIo输出配置及控制
//  20.模拟量控制

///////////////////////////////////////////////////////////////////指令
//------------------------------------------------------------------------------------------------------------
//
//	1.设备高级配置等
//
//------------------------------------------------------------------------------------------------------------

// 设置通讯参数
// devHandle : 设备句柄
// waitTimeInUs：等待时间,微秒
// retryTimes： 通讯重试次数
MTN_API short __stdcall NMC_SetCommPara( HAND devHandle, unsigned long waitTimeInUs, unsigned long retryTimes );

// 板卡打开（根据名称）
// idStr: 板卡ID字符串, 可通过指令写入。pDevHandle: 返回设备操作句柄
// 注：ID号用户可写入,掉电不丢失,可用于区分板卡。出厂板卡号ID号为0
MTN_API short __stdcall NMC_DevOpenByID   ( char *idStr, PHAND pDevHandle );

// 修改板卡ID号
// pIdStr: 要写入的板卡ID字符串,最长16字节,以\0结尾
// 注：修改ID号完成后,板卡要掉电重启,新的ID才有效。
MTN_API short __stdcall NMC_DevWriteID   ( HAND devHandle, char *pIdStr );

// 读取板卡ID号
// pIdStr: 存储字符串的数组,数组长度大于16字节
MTN_API short __stdcall NMC_DevReadID(HAND devHandle, char *pIdStr );

// 读取库的版本
// pVersion：接收版本信息
// example(c):
//          char dllVersion[128];
//          NMC_GetDllVersion(dllVersion);
MTN_API short  __stdcall NMC_GetDllVersion(char *pVersion);

// 当前运动控制器固件的版本等信息
typedef struct
{
	char strVer[16];
	char strOemVer[16];
	char strBuild[32];
}TMtLibVersion;
// 读取当前运动控制器固件的版本等信息
// devHandle : 设备句柄
// pVersion：版本信息
MTN_API short __stdcall NMC_GetMtLibVersion ( HAND devHandle, TMtLibVersion *pVersion );

typedef struct
{
	char strVer[16];           // 控制器版本号
	char strOemVer[16];        // OEM版本号(定制控制器才有),默认为0
	short time[6];          // 时间,年月日,时分秒
	short axisNum;          // 支持的轴数
	short encNum;           // 支持的编码器数
	short diNum;            // 数字输入数量
	short doNum;            // 数字输出数量
	short daNum;            // 模拟量通道
	short adNum;            // 模拟量输入通道
	short shioNum;          // 同步高速IO通道
    short reserved;         // 保留
	char ipv4[4];           // IP地址
	char idStr[16];         // 板卡名称,多卡时可用名称打开参考NMC_DevOpenByID
	unsigned long uid[4];   // 唯一序列号
}TCardInfo;
// 读取当前运动控制器信息
MTN_API short __stdcall NMC_GetCardInfo ( HAND devHandle, TCardInfo *pInfo );

// 启动指令调试
// enable:0关闭调试信息,默认关闭
// debugOutputFile:调试输出文件
MTN_API short  __stdcall NMC_SetCmdDebug( short enable,char *debugOutputFile);

// 获取错误代码信息
// errCode:错误代码
// errDesc:返回的错误代码描述
MTN_API short  __stdcall NMC_GetErrDesc( short errCode,char *errDesc);

// 加载配置文件
MTN_API short __stdcall NMC_LoadConfigFromFile(HAND devHandle, char *pFilePath);

// 保存为配置文件
MTN_API short __stdcall NMC_SaveConfigToFile(HAND devHandle, char *pFilePath);

// 保存基本的配置信息,将这些信息保存到系统参数区,控制器重启或者NMC_DevReset后,系统将使用这些参数
// 保存的参数包括报警、限位、脉冲方式、编码器方式、安全参数、滤波参数
// enable:1表示保存当前配置,并使能自动加载参数功能,0：表示关闭自动加载参数功能
MTN_API short __stdcall NMC_SaveMotionConfig(HAND devHandle,short enable);


//------------------------------------------------------------------------------------------------------------
//
//	2.单轴配置读写
//
//------------------------------------------------------------------------------------------------------------
// 设置限位开关输入是否停止运动
// posEn：正向限位触发允许设置,1为允许,0为禁止
// negEn: 负向限位触发允许设置
MTN_API short  __stdcall NMC_MtLmtOnOff    ( HAND axisHandle, short posSwt, short negSwt );

// 设置限位开关触发电平
// posSwt：正向限位触发电平设置,1为高电平触发,0为低电平触发
// negSwt: 负向限位触发电平设置
MTN_API short  __stdcall NMC_MtLmtSns      ( HAND axisHandle, short posSwt, short negSwt );

// 设置原点开关触发电平，注意：这里的电平设置不会影响捕获的电平
// sns：原点电平设置,1为高电平触发,0为低电平触发
MTN_API short  __stdcall NMC_MtHomeSns( HAND axisHandle, short sns);

// 读取原点开关触发电平
// pSns：当前的原点电平设置,1为高电平触发,0为低电平触发
MTN_API short  __stdcall NMC_MtGetHomeSns( HAND axisHandle, short *pSns);

// 设置伺服报警开关是否停止运动
// swt：伺服报警开关输入允许设置,1为允许,0为禁止。（默认为高电平触发）
MTN_API short  __stdcall NMC_MtAlarmOnOff  ( HAND axisHandle, short swt );

// 设置伺服报警开关电平
// swt：伺服报警触发电平设置,1为高电平触发,0为低电平触发
MTN_API short  __stdcall NMC_MtAlarmSns    ( HAND axisHandle, short swt );

// 获取轴规划模式
// pMode：返回轴运动模式
MTN_API short __stdcall NMC_MtGetPrfMode(HAND axisHandle,short *pMode);

// 获取Ptp参数
// pAxPara：参数
MTN_API short __stdcall NMC_MtGetPtpPara( HAND axisHandle, TPtpPara *pAxPara );

// 获取Jog参数
// pAxPara：参数
MTN_API short __stdcall NMC_MtGetJogPara   ( HAND axisHandle, TJogPara *pAxPara );

// 获取目标运动速度
// pVel: 目标速度（最大速度）,单位是 脉冲/ms
MTN_API short __stdcall NMC_MtGetVel( HAND axisHandle, double *pVel );

// 获取目标运动位置,只针对PTP
// pPos: 目标位置,单位是 脉冲
MTN_API short __stdcall NMC_MtGetPtpTgtPos( HAND axisHandle, long *pPos );

// 读编码器通道位置
// devHandle : 控制器句柄
// encId: 编码器ID,取值范围[0,n]
// pPos:返回编码器数值
MTN_API short  __stdcall NMC_GetEncPos( HAND devHandle, short encId, long *pPos );

// 写编码器通道位置
// devHandle : 控制器句柄
// encId: 编码器ID,对于轴编码器通道,取值范围[0,n]
//				  对于扩展编码器通道,256表示第一个扩展编码器通道,257表示第二个,以此类推
// encPos:编码器数值
MTN_API short  __stdcall NMC_SetEncPos( HAND devHandle, short encId, long encPos );

// 设置允许的位置误差,当位置误差超过设定值时,电机停止运动,提示位置误差超限
// posErr为0表示不检查
MTN_API short  __stdcall NMC_MtSetPosErrLmt( HAND axisHandle, long posErr );

// 读取允许的位置误差设定值
MTN_API short  __stdcall NMC_MtGetPosErrLmt( HAND axisHandle, long *pPosErr );

// 读取编码器模式
// encId: 编码器ID,对于轴编码器通道,取值范围[0,n]
//				  对于扩展编码器通道,256表示第一个扩展编码器通道,257表示第二个,以此类推
// encMode:返回编码器模式,参考宏定义
MTN_API short  __stdcall NMC_GetEncMode (HAND devHandle, short encId,  short *encMode );

// 读取限位开关输入是否停止运动
// posEn：正向限位触发允许设置,1为允许,0为禁止
// negEn: 负向限位触发允许设置
MTN_API short  __stdcall NMC_MtGetLmtOnOff    ( HAND axisHandle, short *pPosSwt, short *pNegSwt );

// 读取限位开关触发电平
// posSwt：正向限位触发电平设置,1为高电平触发,0为低电平触发
// negSwt: 负向限位触发电平设置
MTN_API short  __stdcall NMC_MtGetLmtSns      ( HAND axisHandle, short *pPosSwt, short *pNegSwt );

// 读取伺服报警开关是否停止运动
// swt：伺服报警开关输入允许设置,1为允许,0为禁止。（默认为高电平触发）
MTN_API short  __stdcall NMC_MtGetAlarmOnOff  ( HAND axisHandle, short *pSwt );

// 读取伺服报警开关电平
// swt：伺服报警触发电平设置,1为高电平触发,0为低电平触发
MTN_API short  __stdcall NMC_MtGetAlarmSns    ( HAND axisHandle, short *pSwt );

// 读取软件限位是否停止运动
// enable：软件限位触发允许设置,1为允许,0为禁止
MTN_API short  __stdcall NMC_MtGetSwLmtOnOff  ( HAND axisHandle, short *pSwt );

// 读取软件限位数值
// posLmt：正向软件限位设置值
// negLmt：负向软件限位设置值。单位为脉冲数
MTN_API short  __stdcall NMC_MtGetSwLmtValue  ( HAND axisHandle, long *pPosLmt,long *pNegLmt );

//  读取轴安全参数
MTN_API short  __stdcall NMC_MtGetSafePara( HAND axisHandle, TSafePara *pPara );

// 读取脉冲输出模式
// pInv, 1：取反,0：不取反
// pMode 0：脉冲方向 1：正负脉冲
MTN_API short  __stdcall NMC_MtGetStepMode ( HAND axisHandle, short *pInv, short *pMode );

// 读取轴速度滤波参数
MTN_API short __stdcall NMC_MtGetAxisVelFilter(HAND axisHandle,short *pFilterCoef);

// 读取回零参数
// pHomePara: 回零参数结构,参考结构定义
MTN_API short __stdcall NMC_MtGetHomePara( HAND axisHandle, THomeSetting *pHomePara );

//------------------------------------------------------------------------------------------------------------
//
//	3.单轴高级指令
//
//------------------------------------------------------------------------------------------------------------

// 读取机械坐标的位置
// pPos : 返回位置,单位是 脉冲
MTN_API short __stdcall NMC_MtGetAxisPos   ( HAND axisHandle, long *pPos );

// 读发送到执行器的位置
// pPos : 返回位置,单位是 脉冲
MTN_API short __stdcall NMC_MtGetCmdPos   ( HAND axisHandle, long *pPos );

// 设定机械位置, 轴静止时执行,如果后面是update指令,需要延时一个周期
// axisPos: 设定机械位置值
// 注：只能在轴静止时使用
MTN_API short  __stdcall NMC_MtSetAxisPos( HAND axisHandle, long axisPos);

// 设定编码器位置, 轴静止时执行,如果后面是update指令,需要延时一个周期
// encPos: 设定编码器位置值
// 注：只能在轴静止时使用
MTN_API short  __stdcall NMC_MtSetEncPos( HAND axisHandle, long encPos);

// 设置单轴规划高级参数
// axisHandle : 轴句柄
// mapAxisNo：轴号,取值范围[0,n]
// port：端口号,取值范围[0,1],默认为0
// startPos：偏置,默认为0
// pCrdHandle：坐标系组句柄
MTN_API short __stdcall NMC_MtPrfConfig(HAND axisHandle,short mapAxisNo,short port,long startPos);

// 读取单轴规划高级参数
MTN_API short __stdcall NMC_MtGetPrfConfig(HAND axisHandle,short *mapAxisNo,short *port,long *startPos);

// 设置单轴比例系数
// axisHandle : 轴句柄
// inCoe：单轴比例系数,取值范围(0,1]
MTN_API short __stdcall NMC_MtSetPrfCoe(HAND axisHandle,double inCoe);

// 读取单轴比例系数
// axisHandle : 轴句柄
// pInCoe：单轴比例系数,取值范围(0,1]
MTN_API short __stdcall NMC_MtGetPrfCoe(HAND axisHandle,double *pInCoe);

// 设置轴通道编码器的系数,默认为1
// axisHandle : 轴句柄
// encCoe：单轴通道编码器比例系数,取值范围(0,1]
MTN_API short __stdcall NMC_MtSetEncCoe(HAND axisHandle,double encCoe);

// 读取轴通道编码器的系数
// axisHandle : 轴句柄
// pEncCoe：比例系数,取值范围(0,1]
MTN_API short __stdcall NMC_MtGetEncCoe(HAND axisHandle,double *pEncCoe);

// 设置轴的到位误差参数
// axisHandle : 轴句柄
// arrivalBand: 到位误差,单位Pulse 取值大于0
// stableTime: 到位保持时间,单位 ms 取值大于0
MTN_API short __stdcall NMC_MtSetAxisArrivalPara(HAND axisHandle,long arrivalBand,long stableTime);


// 获取轴的到位误差参数
// axisHandle : 轴句柄
// pArrivalBand:到位误差,单位Pulse 
// pStableTime：到位保持时间,单位 ms
MTN_API short __stdcall NMC_MtGetAxisArrivalPara(HAND axisHandle,long *pArrivalBand,long *pStableTime);


// 设置螺距误差的补偿参数
// number:补偿段数量
// startPos:开始补偿位置
// lenPos:补偿间隔
MTN_API short __stdcall NMC_MtSetLeadScrewPara( HAND axisHandle, short number,long startPos,long lenPos );

// 按序号设置螺距位置补偿的值
// index：补偿段序号
// positivePos:正向补偿值
// negativePos:负向补偿值
MTN_API short __stdcall NMC_MtSetLeadScrewCompPos( HAND axisHandle, short index,long positivePos,long negativePos );


// 使能或禁止螺距位置补偿
// enable:1：使能,0：禁用
MTN_API short __stdcall NMC_MtEnableLeadScrew(HAND axisHandle, short enable);

// 设置单轴急停DI
// gpiIndex：通用输入序号,[0,]
// sense :触发电平,0：低电平,1：高电平
MTN_API short __stdcall NMC_MtSetEstopDI( HAND axisHandle, short gpiIndex,short sense);

// 读取单轴急停DI
// gpiIndex：通用输入序号,[0,]
// sense :触发电平,0：低电平,1：高电平
MTN_API short __stdcall NMC_MtGetEstopDI( HAND axisHandle, short *gpiIndex,short *sense);


// 捕获源
#define CAPT_EX_SRC_GPI				0   // 通用输入
#define CAPT_EX_SRC_NEGLMT          1   // 负向限位
#define CAPT_EX_SRC_POSLMT          2   // 正向限位
#define CAPT_EX_SRC_HOME			3   // 原点
#define CAPT_EX_SRC_Z				4   // Z向信号
#define CAPT_EX_SRC_PRFPOS          5   // 规划位置（当规划位置达到设定值时触发）
#define CAPT_EX_SRC_ENCPOS          6   // 编码器位置

typedef struct
{
	short capPosIndex;	// 捕获的位置源序号,0~N：轴1~N+1。（默认0）注：捕获的编码器位置根据用户设置的编码器模式决定 
	
	short trigSrc;		// 触发源,见上面的定义。（默认：CAPT_EX_SRC_GPI）
	short trigIndex;	// 触发源序号。（默认0）
	short filter;		// 滤波时间常数,单位0.1毫秒,取值范围[0,255]
	long  trigValue;	// 触发值,对于触发源为IO,表示信号触发的有效电平；对于触发源为位置,则表示触发捕获的位置。（默认0）
}TAdvCaptureParam;

// 设置高级捕获参数,并启动捕获
// pParam:参数
// ch：高级捕获通道号,[0~3]
MTN_API short __stdcall NMC_MtSetAdvCaptParam( HAND devHandle, TAdvCaptureParam *pParam,short ch);

// 清除高级捕获状态,并取消该通道的捕获
// ch：高级捕获通道号,[0~3]
MTN_API short __stdcall NMC_MtClrAdvCaptSts( HAND devHandle,short ch);

// 读取高级捕获状态
// captSts:捕获状态,bit0表示设置的信号前沿触发到,bit1表示信号的后沿触发到。
// pPosArray : 返回位置,在触发到时,位置为捕获到的位置值。
//				pPosArray[0]:信号前沿触发位置,pPosArray[1]:信号后沿触发位置,单位:脉冲
MTN_API short  __stdcall NMC_MtGetAdvCaptPos( HAND devHandle, short *captSts,long *pPosArray ,short ch);

//------------------------------------------------------------------------------------------------------------
//
//	4.缓冲区高级指令
//
//------------------------------------------------------------------------------------------------------------

// 坐标系运动：扩展参数
typedef struct
{
	double startVel;					//起跳速度（默认0）
	double T;							//前瞻时间常数,越大则速度变化越小 (默认1)
	double smoothDec;					//停止减速度（默认accMax）
	double abruptDec;					//急停减速度（默认无穷大）
	short  lookAheadSwitch;				//前瞻启动开关( 默认为1，表示前瞻开)
	short eventTime;					// 最小的匀速段时间,单位ms,(默认为10)
	short reserved[2];
}TExtCrdPara;
// 设置坐标系扩展参数 
// extCrdPara:坐标系扩展参数,参考‘坐标系运动：扩展参数’TExtCrdPara结构体定义
MTN_API short __stdcall NMC_CrdSetExtPara( HAND crdHandle, TExtCrdPara *extCrdPara);

// 设置坐标系运动缓冲区是否启用,NMC_CrdConfig后默认为启用状态
// enFlag:启用,1：启动,0：不启用
// 注意：如果不想使用坐标系运动缓冲区,请在NMC_CrdConfig之后调用该指令
MTN_API short __stdcall NMC_EnableCrdSdram( HAND crdHandle, short enFlag);

// 读取坐标系扩展参数
// extCrdPara:坐标系扩展参数
MTN_API short __stdcall NMC_CrdGetExtPara( HAND crdHandle, TExtCrdPara *extCrdPara);
 
// 坐标系运动：圆弧插补配置
#define MAX_ERR_TABLE_SECTION	2
typedef struct
{
	double minSectionLen;				// 分解的最小段长,默认1脉冲,范围[1,10000]
	double maxArcDiff;					// 最大的圆弧有效性误差,单位：脉冲
		
	// 圆弧插补误差配置表
	// 注意：MTN通过限制圆弧插补速度,从而保证插补误差。r全部为0,则表示关闭这个功能
	double r[MAX_ERR_TABLE_SECTION];	// 半径
	double err[MAX_ERR_TABLE_SECTION+1];	// 半径对应的插补误差,半径 [0,r0],对应err0;半径[r0,r1],对应err1;半径[r1,+max],对应err2

}TArcSecSetting;
// 设置圆弧插补参数（高级指令）
// pSetting : 设置
MTN_API short __stdcall NMC_CrdSetArcSecPara( HAND crdHandle,  TArcSecSetting *pSetting);
                                          
// 读圆弧插补参数（高级指令）
MTN_API short __stdcall NMC_CrdGetArcSecPara( HAND crdHandle,  TArcSecSetting *pSetting);

// 坐标系运动参数
typedef struct
{
	short orgFlag;		// 是否自定义坐标系原点
	short reserved[3];		// 保留
	long offset[4];		// 自定义坐标系原点偏置（基于机械原点）
	double synAccMax;	// 最大合成加速度
	double synVelMax;	// 最大合成速度
}TCrdPara;
// 设置坐标系参数(必须)
// pCrdPara:坐标系参数
MTN_API short __stdcall NMC_CrdSetPara( HAND crdHandle, TCrdPara *pCrdPara );

// 读取插补坐标系系统配置信息
// pConfig:返回坐标系配置,参考结构体定义
MTN_API short __stdcall NMC_CrdGetConfig( HAND crdHandle, TCrdConfig *pConfig );

// 获取坐标系参数
// pCrdPara:坐标系参数
MTN_API short __stdcall NMC_CrdGetPara( HAND crdHandle, TCrdPara *pCrdPara );

// 获取坐标系速度倍率
// overRide：坐标系速度倍率
MTN_API short __stdcall NMC_CrdGetOverRide( HAND crdHandle, double *pOverRide );

// 坐标系状态字位定义:内部扩展 
#define BIT_CORD_POSREC         (0x00000040)    // bit 6 , 伺服位置到达,步进模式时位置到达,伺服模式时实际位置到达误差限    
#define BIT_CORD_AUXAXIS_BUSY   (0x00000080)    // bit 7 , 坐标系运动中的关联轴启动前处于运动状态错误
#define BIT_CORD_AUXAXIS_ERR    (0x00000100)    // bit 8 , 插补辅助轴错误             
#define BIT_CORD_AXIS_ERR       (0x00000200)    // bit 9 , 插补轴存在报警错误（如限位、驱动报警）   
#define BIT_CORD_SDRAM_CALC_ERR (0x00000400)    // bit 10 , SDRAM缓冲区计算错误  
// 读取内部坐标系状态
// pStsWord：返回状态字,定义64bits(二维的long数组),便于后续扩展状态位
MTN_API short __stdcall NMC_CrdGetInnerSts     ( HAND crdHandle, long *pStsWord );

// 直接修改坐标系偏移
// pOffsetArray:坐标系偏移
// cnt:数组长度
MTN_API short __stdcall NMC_CrdModifyOffset( HAND crdHandle, long *pOffsetArray, short cnt);

// 缓冲区设置急停DI
// axis:轴号,取值范围[0,n)
// gpiIndex:通用输入序号
// sense:触发电平
MTN_API short  __stdcall NMC_CrdBufSetEstopDI ( HAND crdHandle,long segNo,short axis,short gpiIndex,short sense);

// 缓冲区数据打包
#define BUF_LINE	0 //缓冲区直线插补
#define BUF_DO		1 //缓冲区DO输出
#define BUF_OUT		2 //缓冲区OUT输出
#define BUF_DELAY   3 //缓冲区延时
#define BUF_AXMOVE	4 //缓冲区单轴运动
#define BUF_DOEX    5 //缓冲区DO输出（根据掩码输出）
#define BUF_ARC_R   6 //平面圆弧插补：终点位置、半径、方向
#define BUF_ARC_C   7 //平面圆弧插补：终点位置、圆心、方向
#define BUF_ARC_C   7 //平面圆弧插补：终点位置、圆心、方向
#define BUF_LASER_SETPOWER		8	// 激光：设置能量
#define BUF_LASER_ONOFF			9	// 激光：缓冲区开关光
#define BUF_LASER_SETFOLLOW		10	// 激光：设置跟随
#define BUF_LASER_SETPARAM		11	// 激光：设置参数

typedef struct
{  
	long segNo;        // 用户自定义段号
	long tgPos[3];     // 目标位置
	double endVel;     // 终点速度
	double vel;        // 最大速度
	double synAcc;     // 插补加速度
	short mask;        // 参与的轴,按位表示
	short lookaheadDis;//是否使用前瞻
}TCrdBufLine;

typedef struct
{
	long segNo;     // 用户自定义段号
	short group;    // Out输出类型 
	short ch;       // 通道号,取值范围[0,n]
	long outValue;	// 输出
}TCrdBufOut;

typedef struct
{
	long segNo;     // 用户自定义段号
	short group;    // 缓冲区输出DO组 
	short ch;       // 位序号,取值范围[0,31]
	long value;     // 输出值,取值范围[0,1]
}TCrdBufDO;

typedef struct
{
	long segNo;     // 用户自定义段号
	long scale;     // 延时单位,0表示单位为毫秒,1表示单位为秒
	long count;     // 延时时长
}TCrdBufDelay;

typedef struct
{
	long segNo;     // 用户自定义段号
	long group;    // 缓冲区输出DO组
	long doMask;    // 输出操作位,bit位为1表示要输出
	long value;     // 输出值,bit位指示输出值
}TCrdBufDOEx;

typedef struct
{
	long segNo;         // 用户自定义段号
	short axis;		    // 单轴移动的轴号 [0,n],非坐标系内轴	
	short soomthCoef;   // smoothCoef:平滑系数
	short blockEn;      // 是否为阻塞模式 0 不阻塞 ,1 阻塞
	short synEn;        // 是否为同步模式 0 异步 ,1 同步
	double vel;         // 运动速度
	double acc;         // 运动加速度
	long  tgPos;	    // 目标位置
}TCrdBufAxMove;

typedef struct
{
	long segNo;         // 用户自定义段号
	long tgPos[2];		// 目标位置
	short circleDir;    // 是否为同步模式 0 异步 ,1 同步
	char lookaheadDis;	// 是否使用前瞻
	char panelIndex;	// 圆弧插补平面：0：XY平面，1：YZ平面，其他：ZX平面
	double radius;		// 半径
	double endVel;      // 终点速度
	double vel;         // 运动速度
	double acc;         // 运动加速度
}TCrdBufArcR;

typedef struct
{
	long segNo;         // 用户自定义段号
	long tgPos[2];		// 目标位置
	long centerPos[2];	// 目标位置
	short circleDir;    // 是否为同步模式 0 异步 ,1 同步
	char lookaheadDis;	// 是否使用前瞻
	char panelIndex;	// 圆弧插补平面：0：XY平面，1：YZ平面，其他：ZX平面
	double endVel;      // 终点速度
	double vel;         // 运动速度
	double acc;         // 运动加速度
}TCrdBufArcC;
 
typedef struct
{  
	long segNo;        // 用户自定义段号
	long onDelay;     // 开光延时
	long offDelay;     // 关光延时
	long minValue;     // 最小输出值
	long maxValue;     // 最大输出值
	long standbyPower;	// 待机能量
	short ch;			// 激光控制通道
	short reserved;		// 保留
}TCrdBufLaserSetParam;

typedef struct
{  
	long segNo;        // 用户自定义段号
	short followType;    // 跟随类型
	short ch;			// 激光通道号
	double overRide;     // 跟随倍率
}TCrdBufLaserSetFollow;

typedef struct
{  
	long segNo;        // 用户自定义段号
	short onOff;		// 开关,0：关光,1：开光
	short ch;			// 激光通道号
}TCrdBufLaserOnOff;

typedef struct
{  
	long segNo;        // 用户自定义段号
	short ch;			// 激光通道号
	short reserved;		// 保留
	double power;		// 能量
}TCrdBufLaserSetPower;

// 打包插补数据
// pBufData 插补数据结构存储数组
// dataLen 数据长度
// 压入数据时，先压入指令字，然后再压入指令字对应的工作数据，总的数据长度不超过1000个字节
MTN_API short __stdcall NMC_CrdBufDataPack(HAND crdHandle,  unsigned char *pBufData, short dataLen);

//功能：缓冲区探位置停止并后续加位置偏置
// useCaptPos：是否使用捕获位置  1使用,0不使用
// axis:轴序号
// sense:触发电平,0：低电平,1：高电平
// gpiIndex:通用输入序号
MTN_API short  __stdcall NMC_CrdBufSetStopOffset ( HAND crdHandle, long segNo,
	short axis,short gpiIndex,short sense,short useCaptPos);

//功能：解除缓冲区探位置停止并后续加位置偏置
MTN_API short  __stdcall NMC_CrdBufClrStopOffset ( HAND crdHandle, long segNo,short axis);

// 设置是否计算所有线段长度
MTN_API short __stdcall NMC_CrdSetBufLengthFlag(HAND crdHandle, short flag);

// 读取插补线段长度
MTN_API short __stdcall NMC_CrdGetBufLength(HAND crdHandle, double *pLen);

MTN_API short  __stdcall NMC_CrdSetIsShortLine(HAND crdHandle,short isShortLine);

MTN_API short  __stdcall NMC_CrdSetLookAheadCentriAcc(HAND crdHandle,short isUsingSetAcc,double centriAcc);

//------------------------------------------------------------------------------------------------------------
//
//	5.硬件捕获及不常用指令
//
//------------------------------------------------------------------------------------------------------------

// 编码器硬件捕获模式选择 
#define CAPT_MODE_Z          0   // 编码器Z相捕获 
#define CAPT_MODE_IO         1   // IO 捕获 
#define CAPT_MODE_Z_AND_IO   2   // IO+Z相 捕获 
#define CAPT_MODE_Z_AFT_IO   3   // 先IO触发再Z相触发 捕获 

// 编码器硬件捕获IO源选择 
#define CAPT_IO_SRC_HOME    0   // 原点输入作为捕获IO 
#define CAPT_IO_SRC_LMTN    1   // 负向限位输入作为捕获IO 
#define CAPT_IO_SRC_LMTP    2   // 正向限位输入作为捕获IO 
#define CAPT_IO_SRC_DI0     3   // 通用数字输入0作为捕获IO 
#define CAPT_IO_SRC_DI1     4   // 通用数字输入1作为捕获IO 
#define CAPT_IO_SRC_DI2     5   // 通用数字输入2作为捕获IO 
#define CAPT_IO_SRC_DI3     6   // 通用数字输入3作为捕获IO 
#define CAPT_IO_SRC_DI4     7   // 通用数字输入4作为捕获IO 
#define CAPT_IO_SRC_DI5     8   // 通用数字输入5作为捕获IO 
#define CAPT_IO_SRC_DI6     9   // 通用数字输入6作为捕获IO 
#define CAPT_IO_SRC_DI7     10  // 通用数字输入7作为捕获IO 
#define CAPT_IO_SRC_DI8     11  // 通用数字输入8作为捕获IO 
#define CAPT_IO_SRC_DI9     12  // 通用数字输入9作为捕获IO 
#define CAPT_IO_SRC_DI10    13  // 通用数字输入10作为捕获IO 
#define CAPT_IO_SRC_DI11    14  // 通用数字输入11作为捕获IO 
#define CAPT_IO_SRC_DI12    15  // 通用数字输入12作为捕获IO 
// 设置捕获有效电平
// mode : 模式选择,参考宏定义
// ioSrc：IO输入源选择,参考宏定义
// level: 触发沿。bit0:index电平（0为下降沿,1为上升沿）,bit1:IO电平
MTN_API short  __stdcall NMC_MtSetCaptSns( HAND axisHandle, short mode, short ioSrc, short level );

// 读取捕获有效电平
// mode : 模式选择,参考宏定义
// ioSrc：IO输入源选择,参考宏定义
// level: 触发沿。0为下降沿,1为上升沿
MTN_API short  __stdcall NMC_MtGetCaptSns( HAND axisHandle, short *pMode, short *pIoSrc, short *pLevel );

// 设置启动捕获
// 注：捕获触发标志在轴状态字里。
MTN_API short  __stdcall NMC_MtSetCapt( HAND axisHandle );

// 清除轴的捕获状态
MTN_API short __stdcall NMC_MtClrCaptSts   ( HAND axisHandle);

// 读捕获位置
// pPos : 返回位置,单位:脉冲
MTN_API short  __stdcall NMC_MtGetCaptPos( HAND axisHandle, long *pPos );

// 读取通用输出(按通道,支持超过32位)
// groupID:DO组,取值范围[0,n],,0: 本地DO31~DO0, 1: 本地DO63~DO32,其他指扩展IO模块
// pDoValue: 设置通用数字量输出。1, 高电平,0,低电平
MTN_API short  __stdcall NMC_GetDO( HAND devHandle, short groupID, long *pDoValue);

// 设置通用输出(按通道,支持超过32位)
// groupID:DO组,取值范围[0,n],具体需要看控制器是否存在多组数字量输出
// value: 设置通用数字量输出。1, 输出高电平,0,输出低电平
MTN_API short  __stdcall NMC_SetDO( HAND devHandle, short groupID, long value ) ;

// 读通用输入(按通道,支持超过32位) 
// groupID:DI组,取值范围[0,n],0: 本地DI31~DI0, 1: 本地DI63~DI32,其他指扩展IO模块
// pInValue: 通用数字量输入值。1, 高电平,0,低电平
MTN_API short __stdcall NMC_GetDI( HAND devHandle, short groupID, long *pInValue );

// 读取脉冲输出滤波
// pCoe系数： 范围0~65535,0不滤波,数值越大滤波效果越明显。默认值为0
MTN_API short  __stdcall NMC_MtGetStepFilter ( HAND axisHandle, unsigned short  *pCoe );

// 多轴同时启动
// axisHandle:任意轴
// mask：按bit对应相应轴号,bit为1表示启动,bit为0表示不启动
MTN_API short __stdcall NMC_MtUpdateMulti( HAND axisHandle,long mask );

// 多轴同时停止
// axisHandle:任意轴
// mask：按bit对应相应轴号,bit为1表示启动,bit为0表示不启动
MTN_API short __stdcall NMC_MtStopMulti( HAND axisHandle,long mask  );

// 按位设置通用输入信号取反
// bitIndex:取值范围[0,n],位序号,前64位为本地的通用输入,大于64为扩展Di
// revs:是否取反,1：取反,0：不取反
MTN_API short  __stdcall NMC_SetDIBitRevs ( HAND devHandle,short bitIndex,short revs);

// 按位读取通用输入信号取反
// bitIndex:取值范围[0,n],位序号,前64位为本地的通用输入,大于64为扩展Di
// pRevs:是否取反,1：取反,0：不取反
MTN_API short  __stdcall NMC_GetDIBitRevs ( HAND devHandle,short bitIndex,short *pRevs);

// 按位设置通用输出信号取反
// bitIndex:取值范围[0,n],位序号,前64位为本地的通用输出,大于64为扩展Do
// revs:是否取反,1：取反,0：不取反
MTN_API short  __stdcall NMC_SetDOBitRevs ( HAND devHandle,short bitIndex,short revs);

// 按位读取通用输出信号取反
// bitIndex:取值范围[0,n],位序号,前64位为本地的通用输出,大于64为扩展Do
// pRevs:是否取反,1：取反,0：不取反
MTN_API short  __stdcall NMC_GetDOBitRevs ( HAND devHandle,short bitIndex,short *pRevs);

// DO输出定时脉冲
// bitIndex:取值范围[0,n],位序号,前64位为本地的通用输出,大于64为扩展Do
// value:设置通用数字量输出。1, 输出高电平,0,输出低电平
// reverseTime:持续的电平,单位:毫秒
MTN_API short  __stdcall NMC_SetDOBitAutoReverse(HAND devHandle,short bitIndex,short value,short reverseTime);

// DIO映射
#define DIO_MAP_MAX_NUM		8	// 最多允许的映射关系

// 信号类型定义
#define DIO_TYPE_GPI		1	// 通用输入
#define DIO_TYPE_HOME		2	// 轴Home信号
#define DIO_TYPE_ALM		3	// 驱动器报警信号
#define DIO_TYPE_LMTN		4	// 轴负向限位信号
#define DIO_TYPE_LMTP		5	// 轴正向限位信号
#define DIO_TYPE_GPO		6	// 通用输出信号
#define DIO_TYPE_SVON		7	// 伺服使能信号
#define DIO_TYPE_SVCLR		8	// 报警清除信号


// DIo映射参数配置
typedef struct 
{
	unsigned char  enable;		// 1：启用，0：禁用
	unsigned char  pinGrp;      // 映射的信号类型
	unsigned char  pinIndex;    // 映射的信号序号
	unsigned char  outEnable;	// 输出允许       
	unsigned char  newGrp;      // 映射到的信号类型
	unsigned char  newIndex;	// 映射到的信号序号
}TDioMappingCfg;

// 增加一组映射，映射关系目前最多存在DIO_MAP_MAX_NUM组
MTN_API short  __stdcall NMC_SetDioMapping(HAND devHandle,TDioMappingCfg *pDioCfg);

// 获取所有的DIO映射数据
// pDioCfg：映射数据数组,目前为DIO_MAP_MAX_NUM组
MTN_API short  __stdcall NMC_GetAllDioMapping(HAND devHandle,TDioMappingCfg *pDioCfg);

// 清除所有的DIO映射关系
MTN_API short  __stdcall NMC_ClrAllDioMapping(HAND devHandle);


//------------------------------------------------------------------------------------------------------------
//
//	6.平台相关指令
//
//------------------------------------------------------------------------------------------------------------
// 
#define     VAR_PWM0_CTL    256		// pwm通道0打开关闭,1表示打开,0表示关闭
#define     VAR_PWM0_VALUE  257		// pwm通道0输出值
#define     VAR_PWM1_CTL    258		// pwm通道1打开关闭,1表示打开,0表示关闭
#define     VAR_PWM1_VALUE  259		// pwm通道1输出值
#define     VAR_EXT_DAC0    260		// 扩展的DAC通道0
#define     VAR_EXT_DAC1    261		// 扩展的DAC通道1
#define     VAR_OUT_OPTION	262		// PWM输出通道选项
#define     VAR_DAC0		263		// DAC通道0~7
#define     VAR_DAC1		264
#define     VAR_DAC2		265
#define     VAR_DAC3		266
#define     VAR_DAC4		267
#define     VAR_DAC5		268
#define     VAR_DAC6		269
#define     VAR_DAC7		270
#define     VAR_ADC0		271		// ADC通道0~7
#define     VAR_ADC1		272
#define     VAR_ADC2		273
#define     VAR_ADC3		274
#define     VAR_ADC4		275
#define     VAR_ADC5		276
#define     VAR_ADC6		277
#define     VAR_ADC7		278
// 设置通用可寻址变量 8字节数据类型（可涵盖常用的类似,如：char/short/long/double 等）
MTN_API short __stdcall NMC_SetVar8B( HAND devHandle, long varID, __int64 value );

// 读取通用可寻址变量 8字节数据类型（可涵盖常用的类似,如：char/short/long/double 等）
MTN_API short __stdcall NMC_GetVar8B( HAND devHandle, long varID, __int64 *pValue );

// 系统变量宏定义
#define SYS_VAR_SET_STAT_ENABLE		100
#define SYS_VAR_GET_CLOCK			101
#define SYS_VAR_GET_USERAPP_COUNT	107
#define SYS_VAR_GET_USERAPP_MIN		108
#define SYS_VAR_GET_USERAPP_MAX		109
#define SYS_VAR_GET_USERAPP_AVG		110
#define SYS_VAR_GET_USERAPP_CURT	111
#define SYS_VAR_GET_PRFINT_COUNT	112
#define SYS_VAR_GET_PRFINT_MIN		113
#define SYS_VAR_GET_PRFINT_MAX		114
#define SYS_VAR_GET_PRFINT_AVG		115
#define SYS_VAR_GET_PRFINT_CURT		116
#define SYS_VAR_GET_MAINLP_COUNT	117
#define SYS_VAR_GET_MAINLP_MIN		118
#define SYS_VAR_GET_MAINLP_MAX		119
#define SYS_VAR_GET_MAINLP_AVG		120
#define SYS_VAR_GET_MAINLP_CURT		121

// 设置通用可寻址系统变量 8字节数据类型（可涵盖常用的类似,如：char/short/long/double 等）
MTN_API short __stdcall NMC_SysSetVar8B( HAND devHandle, long varID, __int64 value );

// 读取通用可寻址系统变量 8字节数据类型（可涵盖常用的类似,如：char/short/long/double 等）
MTN_API short __stdcall NMC_SysGetVar8B( HAND devHandle, long varID, __int64 *pValue );

//向备份内存写数据(总长度约510byte)
//src: 要写入的数据
//len: 要写入的长度,单位：byte
//off: 要写入的地址(偏移量)
// 注：1)写入的数据掉电不丢失。
//     2)一次最多写1440字节。总长度约1500byte
MTN_API short __stdcall NMC_BackSramWrite(HAND devHandle,const void *src, long len, long off);

//从备份内存读数据
//dst: 读出的数据暂存区
//len: 要读出的长度,单位：byte,一次最多读1440字节。总长度约1500byte
//off: 读数据的地址(偏移量)
MTN_API short __stdcall NMC_BackSramRead(HAND devHandle,void *dst, long len, long off);

// 平台：控制器时间结构
typedef    struct
{
    short   year;           // 年,真实年份。取值范围[2000,2099]
    short   mon;            // 月,取值范围[1,12]
    short   day;            // 日,取值范围[1,31]
    short   hour;           // 时,取值范围[0,23]
    short   min;            // 分,取值范围[0,59]
    short   second;         // 秒,取值范围[0,59]
} TNMCTime;
// 读时间
// pTime ：返回时间结构,参考 TNMCTime 结构定义
// 注：时间在出厂时根据实际时间设定,用户不可通过指令修改
MTN_API short  __stdcall NMC_GetTime( HAND devHandle, TNMCTime *pTime );


// 写时间
// pTime ：时间结构,参考 TNMCTime 结构定义
// pPassword : 控制器系统密码,长度最多为16个字节
MTN_API short  __stdcall NMC_SetTime( HAND devHandle, TNMCTime *pTime,char *pPassword);

// 修改控制器系统密码,密码用于修改系统时钟等
// pPasswordOld : 控制器系统当前密码,长度最多为15个字符
// pPasswordNew : 新的控制器系统密码,长度最多为15个字符
// 注意：1.初始出厂无密码
//            2.修改密码后,请务必记住新的密码。忘记密码只能返厂复位。
//            3.密码大小写敏感
MTN_API short  __stdcall NMC_ChangePassword( HAND devHandle, char *pPasswordOld,char *pPasswordNew);

// 验证系统密码
// pPassword : 控制器系统当前密码,长度最多为15个字符
// 返回0表示验证通过,其他表示错误
MTN_API short  __stdcall NMC_VerifyPassword( HAND devHandle, char *pPassword);

// 清除系统密码及用户密码
// pData:解密数据，长度为8
MTN_API short  __stdcall NMC_ClrPassword( HAND devHandle, short *pData);

// 读设备唯一序列号
// pUID ：返回设备唯一序列号,为四个Int32的数据
// example:unsigned long devID[4];
//         NMC_GetUID(g_hDev,devID);
MTN_API short  __stdcall NMC_GetUID( HAND devHandle, unsigned long *pUID );

// 写用户参数
// add ：参数区的偏移地址(字节地址)
// len : 写入长度,单位：byte
// pWrData ：要写入的数据；
// 注：1)写入的数据掉电不丢失。
//     2)一次最多写256字节。参数区总长度为2048字节。
//     3)此指令比其它指令操作时间会长,如果出现通讯错误（返回-1）,则需要将通过NMC_SetCommPara延长指令通讯时间
MTN_API short  __stdcall NMC_UserParaWr( HAND devHandle, unsigned long add, unsigned long len, unsigned char *pWrData );

// 读用户参数
// add ：参数区的偏移地址(字节地址)
// len : 写入长度,单位：byte
// pRdData ：要读取的数据存储
// 注：一次最多读256字节。参数区总长度为2048字节。（参考函数 ： NMC_UserParaWr）
MTN_API short  __stdcall NMC_UserParaRd( HAND devHandle, unsigned long add, unsigned long len, unsigned char *pRdData );


// 掉电保存：备份数据定义
typedef struct
{
	long crdSegNo;		// 坐标系运动的段号
	long crdPrfPos[3];	// 坐标系运动的规划位置
	long axPrfPos[8];	// 规划位置
	long axisPos[8];	// 机械位置
	long encPos[8];		// 编码器位置
}TBackGroup1;
// 读取当前备份的变量数值（断电自动保存）
// pBackVar : 备份的变量值,参考结构体定义
MTN_API short __stdcall NMC_GetBackedVarGroup1( HAND devHandle, TBackGroup1 *pBackVar);

// 掉电保存：备份数据定义（12轴）
typedef struct
{
	long crdSegNo[2];		// 坐标系运动的段号
	long crdPrfPos[2][3];	// 坐标系运动的规划位置
	long axPrfPos[12];		// 规划位置
	long axisPos[12];		// 机械位置
	long encPos[12];		// 编码器位置
}TBackGroup2;
// 读取当前备份的变量数值（断电自动保存）
// pBackVar : 备份的变量值,参考结构体定义
MTN_API short __stdcall NMC_GetBackedVarGroup2( HAND devHandle, TBackGroup2 *pBackVar);

// 开始或者关闭变量的自动备份（断电自动保存,默认为关闭状态）
// en:是否开启,1：开启变量的自动备份,0：停止变量的自动备份
MTN_API short __stdcall NMC_SetBackedVarOnOff( HAND devHandle, short en);

// 读取当前自动备份的开启状态
// pEn:当前的开启状态
MTN_API short __stdcall NMC_GetBackedVarOnOff( HAND devHandle, short *pEn);

// paraID
#define     PARA_IP_ADDR   	100		// IP地址,四个字节分别表示四段
#define     PARA_IP_MSK    	101		// IP mask
#define     PARA_IP_GW   	102		// Gateway
#define     PARA_IP_DHCP   	103		// DHCP
#define     PARA_WRITE_EN	999		// 参数保存
// 读取系统参数（long 型）
// paraID :　系统参数ID,参见后面定义。pValue : 返回值
// 注：此函数可用于设置板卡上的扩展资源
MTN_API short  __stdcall NMC_DevGetPara( HAND devHandle, unsigned long paraID, long *pValue );

// 设置系统参数（long 型）
// paraID :　系统参数ID,参见后面定义。value : 设置值
// 注：此函数可用于读取板卡上的扩展资源
// 注：IP地址等参数写成功后,需要调用NMC_DevSetPara(devHandle,PARA_WRITE_EN,1)才能使得写下去的参数保存
// 注：IP地址等参数写成功后,将在控制器重新启动后生效
MTN_API short  __stdcall NMC_DevSetPara( HAND devHandle, unsigned long paraID, long value );

// 设置用户密码
// pUserName    : 指定的用户名,目前只支持"USER1"
// pPasswordOld : 该用户的当前密码,长度最多为15个字符
// pPasswordNew : 新的该用户的密码,长度最多为15个字符
// 注意：1.初始出厂无密码,一旦设置密码,则必须要登陆后,控制器某些指令才能正常工作（包括启动运动指令,设置DO输出指令）
//      2.修改密码后,请务必记住新的密码。忘记密码只能返厂复位。
//      3.密码大小写敏感
MTN_API short  __stdcall NMC_UserSetPassword( HAND devHandle, char *pUserName,char *pPasswordOld,char *pPasswordNew);

// 用户登陆
// pUserName    : 指定的用户名,目前只支持"USER1"
// pPassword    : 该用户的密码
MTN_API short  __stdcall NMC_UserLogin( HAND devHandle, char *pUserName,char *pPassword);

// 用户退出登陆
// pUserName    : 指定的用户名,目前只支持"USER1"
MTN_API short  __stdcall NMC_UserLogout( HAND devHandle, char *pUserName);

//------------------------------------------------------------------------------------------------------------
//
//	7.数据采集模块(高级指令)
//
//------------------------------------------------------------------------------------------------------------

// Collect模块：变量类型
#define COLLECT_ADDRESS_PRF_POS				(0)	// 规划位置
#define COLLECT_ADDRESS_AXIS_POS			(1)	// 机械位置
#define COLLECT_ADDRESS_ENC_POS				(2)	// 编码器位置
#define COLLECT_ADDRESS_CMD_POS				(3)	// 命令位置
#define COLLECT_ADDRESS_AXIS_VEL			(4)	// 电机速度
#define COLLECT_ADDRESS_CRD_POS				(5)	// 坐标系0位置
#define COLLECT_ADDRESS_CRD_VEL				(6)	// 坐标系0速度
#define COLLECT_ADDRESS_CRD_POS0			(5)	// 坐标系0位置
#define COLLECT_ADDRESS_CRD_VEL0			(6)// 坐标系0速度
#define COLLECT_ADDRESS_CRD_POS1			(9)// 坐标系1位置		
#define COLLECT_ADDRESS_CRD_VEL1			(10)// 坐标系1速度
#define COLLECT_ADDRESS_ENC_VEL				(7)	// 编码器速度
#define COLLECT_ADDRESS_CMD_VEL				(8)	// 命令速度
#define	COLLECT_ADDRESS_LASER_OUTPUT		(11)// 激光输出
#define COLLECT_ADDRESS_LASER_GATE			(12)// 激光gate信号状态
// 获取需要采集数据变量的地址
//  index:变量的序号(从0开始)
//  type: 变量的类型,参数‘Collect模块：变量类型’宏定义
//  pAddr: 返回的数据地址
// pDataLen: 返回的该数据长度
MTN_API short  __stdcall NMC_GetCollectDataAddr( HAND devHandle, short index,short dataType,unsigned long *pAddr, short *pDataLen);

// 采集模块：采集配置
#define COLLECT_LIST_MAX		(8) 			//每组最多采集8个数据
typedef struct
{
	short  count;								// 需要采集的变量个数
	short  interval;							// 采集的间隔时间,0表示每隔1毫米采集一次数据,1表示每隔2ms...
	unsigned long  address[COLLECT_LIST_MAX];	// 变量的地址
	short  length[COLLECT_LIST_MAX];			// 每个变量的长度（单位：char）
}TCollectCfg;

// 采集模块：触发模式
#define COLLECT_MODE_NONE	0	// 无条件
#define COLLECT_MODE_G_SRC1	1	// 采集源1数值大于比较值
#define COLLECT_MODE_L_SRC1	2	// 采集源1数值小于比较值
#define COLLECT_MODE_DIFF	3	// 采集源1与采集源2两项差值大于比较值
typedef struct
{
	short  mode;								// 触发模式,
	short  source1;								// 触发源1
	short  source2;								// 触发源2
	short  startDelay;							// 触发启动的延时
	double  value;								// 触发比较值
}TCollectTrig;
// 配置采集数据通道,需要配置对应结构体参数
// pCollect:采集模块配置
// pTrig:采集模块触发方式配置
MTN_API short  __stdcall NMC_ConfigCollect( HAND devHandle, TCollectCfg *pCollect,TCollectTrig *pTrig );

// 启动或停止数据采集
// en：1启动 0停止
MTN_API short  __stdcall NMC_CollectOnOff ( HAND devHandle, short en);

// Collect模块：采集状态
#define COLLECT_BUSY						(0x0001)
#define COLLECT_OVERRIDE_DATA				(0x0002)	
#define COLLECT_PUSH_DATA_ERR				(0x0004)
// 获取采集状态:
// pSts：采集状态,按位表示各自状态,参考‘Collect模块：采集状态’宏定义
// pDataLen: 采集的数据量
MTN_API short  __stdcall NMC_GetCollectSts ( HAND devHandle, short *pSts, long *pDataLen );

// 获取采数据:
// len：采集数据长度（单位：char,一次最多读1440字节）
// pData: 采集的数据（均以char为单元存储）
MTN_API short  __stdcall NMC_GetCollectData ( HAND devHandle, short len, unsigned char *pData );

// 清除采集状态
MTN_API short  __stdcall NMC_ClearCollectSts ( HAND devHandle);

//------------------------------------------------------------------------------------------------------------
//
//	8.激光
//
//------------------------------------------------------------------------------------------------------------
#define MAX_LASER_NUMS			    (2)	    // 最大激光通道

// 激光控制模式
#define LASER_DISABLE_MODE			    (0)	    // 禁用激光功能
#define BASIC_OUTPUT_MODE			    (1)		// 基本控制模式
#define TIME_ARRAY_OUTPUT_MODE			(2)    	// 波形控制模式
#define SHIO_OUTPUT_MODE				(3)     // 位置比较控制模式

//设置激光控制的模式。该模式的设定,约束相应指令的功能和操作
//mode: 激光控制模式,参考上述宏定义
MTN_API short  __stdcall NMC_LaserSetMode  (HAND devHandle, short mode, short ch );

 // 激光物理信号类型
#define LASER_NONE 			(0)			// 关闭激光输出模式
#define LASER_DA  			(1)			// DA输出
#define LASER_PWM_DUTY		(2)			// 占空比输出
#define LASER_PWM_FRQ		(3)			// 频率输出
#define LASER_PWM_FRQ_EXT	(4)			// 频率输出,脉宽固定

// 激光物理信号输出类型配置
// outputType：输出的类型
// index :输出通道序号,取值范围[0,n]
// optionVal: 当作为占空比输出时,该值为PWM的频率,单位HZ；
//            当为LASER_PWM_FRQ时,该值作为占空比值,（0~100）；
//            当为LASER_PWM_FRQ_EXT时,该值为脉宽,单位为0.5微秒,取值范围(0,~)
// ch :激光通道,取值范围[0,n]
MTN_API short  __stdcall NMC_LaserSetOutputType ( HAND devHandle,short outputType,short index,long optionVal,short ch);

// 激光物理信号输出类型配置(高精度)
// outputType：输出的类型
// index :输出通道序号,取值范围[0,n]
// optionVal: 当作为占空比输出时,该值为PWM的频率,单位HZ；
//            当为LASER_PWM_FRQ时,该值作为占空比值,单位为百分比；
//            当为LASER_PWM_FRQ_EXT时,该值为脉宽,单位为微秒,取值范围(0,~)
// ch :激光通道,取值范围[0,n]
MTN_API short  __stdcall NMC_LaserSetOutputTypeEx ( HAND devHandle,short outputType,short index,double optionVal,short ch);

// 功能：设置立即输出激光的能量,
// outVal: 激光能量（设定值意义与NMC_LaserSetOutputType设置的输出类型对应）
// ch：输出通道 (需要根据不同物理信号端口数量进行设定)
MTN_API short  __stdcall NMC_LaserSetPower ( HAND devHandle,long outVal,short ch);

// 功能：读取当前激光的能量 
// pVal: 激光能量值
// ch：通道号
MTN_API short  __stdcall NMC_LaserGetPower ( HAND devHandle,double *pVal,short ch);

// 功能：读取当前激光开关状态 
// pOnOffState: 激光开关状态，1：激光处于打开状态，0:激光处于关闭状态
// ch：通道号
MTN_API short  __stdcall NMC_LaserGetOnOff ( HAND devHandle,short *pOnOffState,short ch);

// 功能：设置立即输出激光的能量(高精度)
// chn：输出通道 (需要根据不同物理信号端口数量进行设定)
// outVal: 激光能量（设定值意义与NMC_LaserSetOutputTypeEx设置的输出类型对应）
MTN_API short  __stdcall NMC_LaserSetPowerEx ( HAND devHandle,double outVal,short ch);

// 功能：激光立即输出开关 
// onOffl: 0或者1表示打开或关闭激光输出
// ch：输出通道 (需要根据不同物理信号端口数量进行设定)
MTN_API short  __stdcall NMC_LaserOnOff ( HAND devHandle,short onOff,short ch);

// 设置激光参数
// onDelay:开光延时,单位us,取值范围[0,65535]
// offDelay:关光延时,单位us,取值范围[0,65535]
// minValue:最小输出值,取值范围[0,32767]
// maxValue:最大输出值,取值范围[0,32767]
// standbyPower:待机能量,为0表示取消待机能量输出功能
// ch:激光控制通道
MTN_API short  __stdcall NMC_LaserSetParam ( HAND devHandle, long onDelay ,
				long offDelay, long minValue ,long maxValue,long standbyPower,short ch);

// 缓冲区设置激光参数
// onDelay:开光延时,单位us,取值范围[0,65535]
// offDelay:关光延时,单位us,取值范围[0,65535]
// minValue:最小输出值，DA输出时，范围[0,32767],占空比输出时，范围[0,100],频率输出时，范围[0,2000000]
// maxValue:最大输出值，DA输出时，范围[0,32767],占空比输出时，范围[0,100],频率输出时，范围[0,2000000]
// standbyPower:待机能量,为0表示取消待机能量输出功能
// ch:激光控制通道
MTN_API short  __stdcall NMC_CrdBufLaserSetParam ( HAND crdHandle, long segment,long onDelay ,
				long offDelay, long minValue ,long maxValue,long standbyPower,short ch);

// 读取激光参数
MTN_API short  __stdcall NMC_LaserGetParam ( HAND devHandle, long *pOnDelay,
			long *pOffDelay, long *pMinValue ,long *pMaxValue,long *pStandbyPower,short ch);

// 设置缓冲区激光能量跟随
// segNo:段号
// overRide:跟随倍率,为0表示取消激光能量跟随
// followType:跟随类型,0：跟随规划速度,1：跟随实际速度
// ch:激光通道号,取值范围[0,n]
MTN_API short __stdcall NMC_CrdBufLaserSetFollow(HAND crdHandle,long segNo,double overRide,short followType,short ch);

// 缓冲区激光开关
// segNo:段号
// onOff:开关,0：关光,1：开光
// ch:激光控制通道
MTN_API short  __stdcall NMC_CrdBufLaserOnOff ( HAND crdHandle,long segNo,short onOff,short ch);

// 缓冲区设置激光能量,激光能量跟随模式下,调用这条指令无效
// segNo:段号
// power:能量
// ch:激光控制通道
MTN_API short  __stdcall NMC_CrdBufLaserPower ( HAND crdHandle,long segNo,long power,short ch);

// 
#define LASER_GROUP		(12)			// 最大激光能量组数
#define LASET_POINT		(40)			// 每组最大点数

typedef struct
{
	short pwmEnable;		// 是否需要输出PWM
	short outputType;		// 开关信号输出类型：0：gate,1：GPO
	short outputCh;			// 开关信号输出通道
	short reserved;			// 保留
	long pwmPeriod;			// PWM周期,单位us,不能小于时间数组的总周期
	long pwmWidth;			// PWM脉宽,单位us,此参数保留,脉宽等于时间数组的总周期
}TTimeArrayPara;

// 设置时间数组输出参数
// ch : 激光通道
// pPara ： 参数
// 注：1.仅时间数组输出方式下有效
MTN_API short  __stdcall NMC_LaserSetTimeArrayPara  ( HAND devHandle,TTimeArrayPara *pPara,short ch);

typedef struct
{
	short time[LASET_POINT];		// 每个点之间的间隔时间
	short power[LASET_POINT];		// 各点的能量大小
	short count;					// 实际压入点数
}TLaserPower;

// 设置激光的能量,对于立即输出模式,group无效,pLaserPower为指定的单个能量信息
// group : 设置哪一组激光能量
// pLaserPower ： 设置的数据
// 注：1.即波形设置 
//     2.该接口对于SHIO模式无效
MTN_API short  __stdcall NMC_LaserSetTimeArrayPower  ( HAND devHandle,short group,TLaserPower *pLaserPower );
	
// 执行时间序列激光,只在时间序列输出模式下有效
// group : 设置哪一组激光能量
// ch:激光通道
// 注：1.启用时间数组输出后,直到最后一个点,如果最后一个点能量不为0,则维持最后一个能量输出
//    2.如果最后一个点能量为0,且没有PWM输出配合,则自动关闭激光。有PWM配合则需要调用NMC_LaserOnOff或者NMC_CrdBufLaserOnOff关闭激光
MTN_API short  __stdcall NMC_LaserTimeArrayExe  (HAND devHandle, short group,short ch );

// 缓冲区执行时间序列激光,只在时间序列输出模式下有效
// segNo:段号
// group:设置哪一组激光能量
// ch:激光控制通道
// 注：1.启用时间数组输出后,直到最后一个点,如果最后一个点能量不为0,则维持最后一个能量输出
//    2.如果最后一个点能量为0,且没有PWM输出配合,则自动关闭激光。有PWM配合则需要调用NMC_LaserOnOff或者NMC_CrdBufLaserOnOff关闭激光
MTN_API short  __stdcall NMC_CrdBufLaserTimeArrayExe ( HAND crdHandle,long segNo,short group,short ch);

typedef struct
{
	short isArray; 		// 是否固定间距还是数组。0：固定间距（仅支持）,默认0
	short outMode; 		// 输出模式。默认1
						// 1：只输出gate 立即开或关,
						// 2: 根据位移输出gate。( 优先 )
						// 3: 根据位移输出gate,gate 和同部trigger 信号同步
						// 4: 根据位移输出gate,gate 和信号输入同步
	short posSrc; 		// 比较模式,外部编码器还是内部规划值。
						// 0：外部编码器（优先）,1：内部规划值。
						// 默认0。
	short axisMask; 	// 轴号,按bit 位对应。（一般两个轴）。
						// 默认 0。
	double delay; 		// 延时开关光时间( 暂不用 ),单位：s。默认 0。
	double gateTime; 	// 设置gate 打开时间,单位：s（内部最小值：1/36us ）,取值范围(0,0.0009)
						// 默认0。
	long gateDistance; 	// 固定模式下的位置间隔 单位：pulse。
						// 默认0,模式2~4 下会进行有效性检查。
	long reserved1;		// 保留参数,应设为0。
	long reserved2; 	// 保留参数,应设为0。
	long reserved3; 	// 保留参数,应设为0。
	long reserved4; 	// 保留参数,应设为0。
	long reserved5; 	// 保留参数,应设为0。
}TSHIOPara;

// 配置SHIO功能的参数
MTN_API short  __stdcall NMC_SHIOConfigPara  (HAND devHandle, TSHIOPara *pSHIOPara,short ch);

// SHIO输出的最小频率功能开
// minFrq:最低频率，单位HZ
MTN_API short  __stdcall NMC_SHIOEnableMinFrq  (HAND devHandle,long minFrq,short ch);

// SHIO输出的最小频率功能关闭
MTN_API short  __stdcall NMC_SHIODisableMinFrq  (HAND devHandle,short ch);

// 缓冲区配置SHIO功能的参数
// delay:延时开关光时间( 暂不用 ),单位：s。默认 0。
// gateTime:设置gate 打开时间,单位：s（内部最小值：1/36us ）,取值范围(0,0.0009),默认0。
// gateDistance:固定模式下的位置间隔 单位：pulse。
MTN_API short  __stdcall NMC_CrdBufSHIOSetParam  (HAND crdHandle, long segment,double delay,
	double gateTime,double gateDistance,short ch);

// 切换轴（允许和坐标系不完全一致）
MTN_API short  __stdcall NMC_SHIOChangeAxisMask( HAND devHandle, short axisMask,short ch );

// 允许GATE输出
// 注：设置后根据模式输出
MTN_API short  __stdcall NMC_SHIOGateOn ( HAND devHandle ,short ch);

// 禁止GATE输出
// 注：设置后立即禁止输出
MTN_API short  __stdcall NMC_SHIOGateOff ( HAND devHandle ,short ch);

// 设置Trigger 输出,
// triggerFreq : 设置triger 脉冲频率单位：HZ。
// triggerWidth : 设置triger 脉冲宽度,单位：s（内部最小值：1/36us ）。默认0。
// 注：设置后立即输出
MTN_API short __stdcall NMC_SHIOTriggerOn ( HAND devHandle,double freq,double width ,short ch);

// 禁止GATE输出
// 注：设置后马上输出
MTN_API short  __stdcall NMC_SHIOTriggerOff ( HAND devHandle ,short ch);

// 允许GATE输出
// 注：设置后根据模式输出
MTN_API short  __stdcall NMC_BufSHIOGateOn ( HAND crdHandle, long segNo,short ch);

//禁止GATE输出
//注：缓冲区执行到该指令后立即禁止输出
MTN_API short  __stdcall NMC_BufSHIOGateOff ( HAND crdHandle, long segNo,short ch);

// PWM映射到GATE引脚输出
// pwmCh:pwm 通道号
// gateCh:gate信号通道号
// onOff: 0 -- 不映射，1 -- 映射 （默认为0）
MTN_API short  __stdcall NMC_SetPwmToGate (HAND devHandle, short pwmCh,short gateCh,short onOff);

// 缓冲区SHIO点动出光，输出一段gate脉冲,注意：必须在激光SHIO控制模式下使用
// gateTime:gate输出的脉宽，单位：微秒
// gateFrq:gate输出的频率，单位：HZ
// outCount:输出个数
// ch:通道
MTN_API short  __stdcall NMC_CrdBufSHIOGatePulse ( HAND crdHandle,long segNo,double gateTime, 
	double gateFrq,long outCount,short ch);

// SHIO点动出光，输出一段gate脉冲,注意：必须在激光SHIO控制模式下使用
// gateTime:gate输出的脉宽，单位：微秒
// gateFrq:gate输出的频率，单位：HZ
// outCount:输出个数
// ch:通道
MTN_API short  __stdcall NMC_SHIOGatePulse ( HAND devHandle,double gateTime, double gateFrq,long outCount,short ch);

// 输出一段PWM脉冲,注意：必须在激光SHIO控制模式下使用
// onTime:PWM输出的脉宽，单位：微秒
// pwmFrq:PWM输出的频率，单位：HZ
// outCount:输出个数
// ch:通道
MTN_API short  __stdcall NMC_PwmPulseOut ( HAND devHandle,double onTime, double pwmFrq,long outCount,short ch);

//------------------------------------------------------------------------------------------------------------
//
//	9.龙门
//
//------------------------------------------------------------------------------------------------------------
// 设置龙门主动轴
// axisHandle: 龙门主动轴句柄
// group     : 龙门组号,取值范围[0,n]
MTN_API short __stdcall NMC_SetGantryMaster( HAND axisHandle, short group );

// 设置龙门从动轴
// axisHandle  : 龙门从动轴句柄;
// group       : 龙门组号,取值范围[0,n]
// gantryErrLmt: 龙门保护误差,取值范围(0,...)
MTN_API short __stdcall NMC_SetGantrySlave( HAND axisHandle , short group, long gantryErrLmt );

// 龙门功能关闭
// group :       龙门组号,取值范围[0,n]
MTN_API short __stdcall NMC_DelGantryGroup( HAND axisHandle, short group );

//------------------------------------------------------------------------------------------------------------
//
//	10.通讯扩展等其他
//
//------------------------------------------------------------------------------------------------------------
// 通讯扩展
// 用户指令传输,只写
MTN_API short  __stdcall NMC_UserCmdWrite( HAND devHandle, unsigned char *sendBuffer, unsigned long sendLen );

// 用户指令传输,只读
MTN_API short  __stdcall NMC_UserCmdRead( HAND devHandle, unsigned char *sendBuffer, 
	unsigned long sendLen, unsigned char *recBuffer, unsigned long waitLen );

// 批量数据传输,只写
MTN_API short  __stdcall NMC_DataTransfer( HAND devHandle, unsigned char *sendBuffer, unsigned long sendLen );		

// 禁止用户程序运行
MTN_API short __stdcall NMC_SysSetUserApp   ( HAND devHandle, unsigned char mode );

// 升级
MTN_API short __stdcall NMC_SysUpgrade   ( HAND devHandle );

// 升级固件
MTN_API short __stdcall NMC_SysUpgradeEx( HAND devHandle, unsigned char cmd, 
	unsigned char *sendBuffer, unsigned long sendLen, unsigned char *recBuffer, unsigned long recvedLen );

// 设置调试信息
MTN_API short __stdcall NMC_SetDebugErrorEn(  HAND devHandle, short debugErrEn );

// 读取最后一次的错误代码
// 返回值：错误代码
MTN_API short __stdcall NMC_GetLastErr(void);

// 设置指令错误返回值模式
// mode:0-标准模式,将返回详细的错误代码(默认)；1--简洁模式,只返回错误代码类别
MTN_API short __stdcall NMC_SetErrCodeMode(short mode);

// 设置指令通讯看门狗
// timeout:看门狗超时时间,单位毫秒,小于等于0代表关闭看门狗功能
// stopMode:超时停止模式,1:马上停止,0:缓冲区执行完毕后停止
// groupID:超时输出do的组号
// doValue:超时输出do状态
MTN_API short __stdcall NMC_SetWatchDog(HAND devHandle,long timeout,short stopMode,short groupID,long doValue);

//------------------------------------------------------------------------------------------------------------
//
//	11.手轮
//
//------------------------------------------------------------------------------------------------------------
// 退出手轮
MTN_API short __stdcall NMC_ClrHandWheel(HAND devHandle);

// 配置手轮
// axis:轴号
// ratio:跟随倍率,取值范围(0,..]
// acc:加速度
// vel:速度
MTN_API short __stdcall NMC_SetHandWheel(HAND devHandle,short axis,double ratio,double acc,double vel);

// 选择手轮跟随的编码器通道
// index:编码器通道编号,如果是轴通道,取值范围[0,n]
//                    如果是扩展编码器通道,则256表示第一个扩展编码器通道,257表示第二个,以此类推
MTN_API short __stdcall NMC_SetHandWheelInput(HAND devHandle,short index);

// 设置手轮跟随的倍率
// ratio:跟随倍率,取值范围(0,..]
MTN_API short __stdcall NMC_SetHandWheelRatio(HAND devHandle,double ratio);


//------------------------------------------------------------------------------------------------------------
//
//	12.PT
//
//------------------------------------------------------------------------------------------------------------
// onOff:		1：数据驻存模式   0：数据刷新模式(默认模式)
// loopCount:	循环次数 ：仅数据驻存模式下有效
MTN_API short  __stdcall NMC_MtPtSetStatic(HAND axisHandle,short onOff,long loopCount);

// onOff:		1：数据驻存模式   0：数据刷新模式(默认模式)
// loopCount:	循环次数 ：仅数据驻存模式下有效
MTN_API short  __stdcall NMC_MtPtGetStatic(HAND axisHandle,short *pOnOff,long *pLoopCount);

// 查询PT数据剩余空间大小
// pSpace:返回的剩余空间大小
// pUsed: 已使用的空间段数
MTN_API short  __stdcall NMC_MtPtGetSpace(HAND axisHandle,short *pSpace,short *pUsed);


// PT数据段类型
#define MT_PT_NORMAL	(0)
#define MT_PT_STOP		(1)

// 向Pt运动缓存区中压运动数据段
// count:压入的数据段数
// pPosArray:段运行距离
// pTimeArray:段运行时间
// pTypeArray:段类型,见宏定义
MTN_API short  __stdcall NMC_MtPtPush(HAND axisHandle,short count,double *pPosArray,long *pTimeArray,short *pTypeArray);

// 清空PT数据
MTN_API short  __stdcall NMC_MtPtBufClr(HAND axisHandle);

// 启动Pt运动
// otherSynAxCnts： 不包括axisHandle 的其他同步启动轴数量
// pOtherSynAxArray: 其他同步启动轴的序号：0~N	
// 注：同步的轴必须属于同一个控制器
MTN_API short  __stdcall NMC_MtPtStartMtn(HAND devHandle,short otherSynAxCnts,short *pOtherSynAxArray);


//-------------------------------------------------------------------------------
// 13.线性距离位置比较
//-------------------------------------------------------------------------------

// 精确输出结构体
typedef struct
{
	short dimens;
	short compMode;
	short axMask;
	short src;
	double gateTime;
}TLinearCmpPara;


// 功能：设置精确位置比较的参数，并清除线性位置比较位置数据
// dimens:比较的维数 1或者2
// axisMask：选比较的轴号,按bit选择:不能超过2个bit同时为1
// src：比较源：0:编码器位置  1：规划位置
// cmpMode：比较的模式：0 按输出数组位置比较,1 线性比较,按interval间距比较
// gateTime:输出的脉冲宽度
// chn：输出通道 目前只支持0
MTN_API short __stdcall NMC_LinearCompSetParam(HAND devHandle,short dimens, short axisMask,short src,short cmpMode,double gateTime,short chn);


// 获取配置参数
MTN_API short __stdcall NMC_LinearCompGetParam(HAND devHandle,TLinearCmpPara *pLinearCmpPara,short chn);


// 功能：设置精确比较位置数据
// pStartPos：起始比较位置，注意：暂时没用
// pPos :比较的位置数组地址。
//		 注意：这里为相对距离，第一点为相对于NMC_LinearCompOnOff调用时的位置的距离，第二点为相对第一点的距离
// count：比较的位置个数，最大不能超过250，如果比较数据过多，可以通过多次调用的方式下压数据，缓冲区长度
// chn：输出通道 目前只支持0
MTN_API short __stdcall NMC_LinearCompSetData(HAND devHandle,long *pStartPos,long *pPos,long count, short chn);


// 功能：线性比较输出
// pStartPos：起始比较位置
// interval:线性比较间距（小于32767）
// count: 线性比较次数
MTN_API short __stdcall NMC_LinearCompInterval(HAND devHandle,long *pStartPos,long interval,long count, short chn);


// 功能：精确位置比较使能
// onOff： 0 停止,1输出
// chn：输出通道 目前只支持0
MTN_API short __stdcall NMC_LinearCompOnOff(HAND devHandle,short onOff, short chn);


// 功能：比较的输出状态
// pStatus: 0 未启动比较 1 比较输出中
// pOutCount：输出的个数,对于数组输出模式，输出计数计算请咨询我们
// chn：输出通道 目前只支持0
MTN_API short __stdcall NMC_LinearCompStatus(HAND devHandle,short *pStatus, short *pOutCount,short chn);

//-------------------------------------------------------------------------------
//14.二维位置点比较
//-------------------------------------------------------------------------------
#define CMP_OUTPUT_CHN_MAX	(3)

// 二维位置点比较结构体
typedef struct
{
	short outputchn[CMP_OUTPUT_CHN_MAX];		// 比较输出的通道:-1表示不输出处理
	short outputType[CMP_OUTPUT_CHN_MAX]; 		// 输出方式0：脉冲1：电平
	short chnType[CMP_OUTPUT_CHN_MAX];      	// 通道类型：0 GPO, 1  GATE通道
	short dir1No; 								// 方向1 的位置源轴号（0~11）
	short dir2No; 								// 方向2 的位置源轴号（0~11）
	short posSrc; 								// 轴位置类型 ：0规划1：编码器
	short stLevel[CMP_OUTPUT_CHN_MAX];			// 电平模式下的起始电平（0或1）
	short gateTime[CMP_OUTPUT_CHN_MAX]; 		// 脉冲方式脉冲时间:单位ms
	short errZone; 								// 进入比较点容差半径范围（pulse）
} TComp2DimensParam;


// 功能：设置2维位置比较的参数
// param: 二维比较参数
// group:组号,0 或者1
// chn:保留,设为0
MTN_API short __stdcall NMC_Comp2DimensSetParam(HAND devHandle,short group,TComp2DimensParam *param,short chn);


// 功能：获取2维位置比较的参数
// param: 二维比较参数
// group:组号,0 或者1
// chn:保留,设为0
MTN_API short __stdcall NMC_Comp2DimensGetParam(HAND devHandle,short group,TComp2DimensParam *param,short chn);


// 功能：设置二维比较数据
// pArrayPos:比较数组地址
// count:位置点数
// group:组号,0 或者1
// chn:保留,设为0
MTN_API short __stdcall NMC_Comp2DimensSetData(HAND devHandle,short group,long *pArrayPos,short count,short chn);


// 功能：2维位置比较使能
// onOff： 0 停止,1输出
// group:组号,0 或者1
// chn:保留,设为0
MTN_API short __stdcall NMC_Comp2DimensOnoff(HAND devHandle,short group,short onOff,short chn);


// 功能：2维位置比较的输出状态
// pStatus: 0 未启动比较 1 比较输出中
// pOutCount：输出的个数
// group:组号,0 或者1
// chn:保留,设为0
MTN_API short __stdcall NMC_Comp2DimensStatus(HAND devHandle,short group,short *pStatus, short *pOutCount,short chn);
//-------------------------------------------------------------------------------
//15.多维位置比较输出通用接口
//-------------------------------------------------------------------------------
// X维位置点比较结构体
typedef struct
{
	short dimens; 		                    // 维度
	short axMask;                           // 使用的轴,按位
	short src; 		                        // 轴位置类型 ：0规划1：编码器

	short outCnts; 							// 输出数量
	short outType[CMP_OUTPUT_CHN_MAX]; 		// 输出方式0：脉冲1：电平
	short outChnType[CMP_OUTPUT_CHN_MAX];	// 通道类型：0 GPO, 1  GATE通道
	short outIndex[CMP_OUTPUT_CHN_MAX];     // GPO：0~63  GATE：0
	short outStLevel[CMP_OUTPUT_CHN_MAX];   // 电平模式下的起始电平（0或1）
	short outGateTime[CMP_OUTPUT_CHN_MAX]; 	// 脉冲模式下的脉冲时间:单位ms
	short errZone; 							// 进入比较点容差半径范围（pulse）
} TCompXDimensParam;

// 功能：设置X维位置比较的参数
// param: X维比较参数
// ch:组号,0~2
MTN_API short __stdcall NMC_CompXDimensSetParam(HAND devHandle,TCompXDimensParam *param,short chn);

// 功能：获取X维位置比较的参数
// param: 二维比较参数
// chn:组号
MTN_API short __stdcall NMC_CompXDimensGetParam(HAND devHandle,TCompXDimensParam *param,short chn);

// 功能：设置X维位置比较的输出模式
// outMode: 输出模式 0：同时输出模式 1： 轮循输出模式
// ch:组号,0~N
MTN_API short __stdcall NMC_CompXDimensSetCmpOutMode(HAND devHandle,short outMode ,short chn);

// 功能：设置X维比较数据
// pArrayPos:比较数组地址,注：若是1维比较,则pPosArray传入一维数组地址,若是2维比较,则pPosArray应传入2维数组地址
// outValue
// count:位置点数,注：若为2维数组比较时,每两个数据为一个点数
// ch:组号,0~N
// 注：按结构体定义的IO,同时输出
MTN_API short __stdcall NMC_CompXDimensSetData(HAND devHandle, long *pPosArray, short count, short chn);

// 功能：X维位置比较使能
// onOff： 0 停止,1输出
// chn： 组号
MTN_API short __stdcall NMC_CompXDimensOnoff(HAND devHandle,short onOff, short chn);

// 功能：X维位置比较的输出状态
// pStatus: 0 未启动比较 1 比较输出中
// pOutCount：输出的个数
// chn：组号
MTN_API short __stdcall NMC_CompXDimensStatus(HAND devHandle,short *pStatus, short *pOutCount,short chn);

//-------------------------------------------------------------------------------
//16.坐标系输出转换（根据机械结构进行转换）
//-------------------------------------------------------------------------------
// 功能：使能旋转转换处理
//       用户数据是按照直角坐标描述,实际加工在一个旋转面上加工,可以用此功能
// rotAxisNo：旋转轴轴号
// angleRadEqual：旋转轴脉冲转弧度系数
// firstAxisInitPos：旋转中心,X轴的位置
// secAxisInitPos：旋转中心,Y轴的位置
MTN_API short  __stdcall NMC_CrdSetTransRotate(HAND crdHandle,short rotAxisNo,
								double angleRadEqual,long firstAxisInitPos,long secAxisInitPos);

// 功能：关闭旋转转换处理
MTN_API short  __stdcall NMC_CrdDelTransRotate(HAND crdHandle);

// 功能：使能极坐标转换处理
//       用户数据是按照直角坐标描述,实际机械机构是一个旋转轴和一个进给轴
//参数：	rotAxNo：旋转轴轴号
//		transAxNo：平移轴轴号
//		rotEquiv：旋转轴当量,2PI/电机一圈脉冲数
MTN_API short  __stdcall NMC_CrdSetTransPolar(HAND crdHandle, short rotAxNo,short transAxNo, double rotEquiv);

// 功能：运行至设定的极坐标位置并且进行圈数清零处理（利用单轴PTP运行到指定位置）
//参数：	xPos:极坐标系下X方向位置
//		yPos:极坐标系下Y方向位置,比如运动到（5000,5000）的位置,则相当于旋转轴转到45度角,进给轴运动到根号2*5000的位置
//		rotVel:旋转速度
//		transVel:进给速度
MTN_API short  __stdcall NMC_CrdRunToPolarPos(HAND crdHandle,double xPos,double yPos,double rotVel,double transVel);

// 功能：运行至设定的极坐标角度位置（利用单轴PTP运行到指定位置）
//参数：	theta:旋转轴目标角度
//				vel:旋转速度
//				clrRoundFlag:是否清除圈数
MTN_API short  __stdcall NMC_CrdRunToPolarTheta(HAND crdHandle,double theta,double vel,short clrRoundFlag);

// 功能：销毁极坐标机型（只恢复直角坐标系）
MTN_API short  __stdcall  NMC_CrdDelTransPolar(HAND crdHandle);

//-------------------------------------------------------------------------------
//17.结构体初始化函数
//-------------------------------------------------------------------------------
MTN_API short  __stdcall NMC_TSafeParaStructInit(HAND devHandle,TSafePara *pPara);
MTN_API short  __stdcall NMC_TCrdConfigStructInit(HAND devHandle,TCrdConfig *pPara);
MTN_API short  __stdcall NMC_TCrdSafeParaStructInit(HAND devHandle,TCrdSafePara *pPara);
MTN_API short  __stdcall NMC_THomeSettingStructInit(HAND devHandle,THomeSetting *pPara);
MTN_API short  __stdcall NMC_TArcSecSettingStructInit(HAND devHandle,TArcSecSetting *pPara);
MTN_API short  __stdcall NMC_TCrdParaStructInit(HAND devHandle,TCrdPara *pPara);
MTN_API short  __stdcall NMC_TCollectCfgStructInit(HAND devHandle,TCollectCfg *pPara);
MTN_API short  __stdcall NMC_TCollectTrigStructInit(HAND devHandle,TCollectTrig *pPara);
MTN_API short  __stdcall NMC_TTimeArrayParaStructInit(HAND devHandle,TTimeArrayPara *pPara);
MTN_API short  __stdcall NMC_TLaserPowerStructInit(HAND devHandle,TLaserPower *pPara);
MTN_API short  __stdcall NMC_TSHIOParaStructInit(HAND devHandle,TSHIOPara *pPara);
MTN_API short  __stdcall NMC_TLinearCmpParaStructInit(HAND devHandle,TLinearCmpPara *pPara);
MTN_API short  __stdcall NMC_TComp2DimensParamStructInit(HAND devHandle,TComp2DimensParam *pPara);
MTN_API short  __stdcall NMC_TPtpParaStructInit(HAND devHandle,TPtpPara *pPara);
MTN_API short  __stdcall NMC_TJogParaStructInit(HAND devHandle,TJogPara *pPara);
MTN_API short  __stdcall NMC_TNMCTimeStructInit(HAND devHandle,TNMCTime *pPara);

// 清除轴错误状态,同时多个
MTN_API short  __stdcall NMC_MtClrErrorEx(HAND axisHandle,short count);

// 输出DO,16位
// bitsFlag,0:低16位,1：高16位
MTN_API short  __stdcall NMC_SetDOGroupEx( HAND devHandle, long value, short groupID,short bitsFlag) ;

//-------------------------------------------------------------------------------
//18.闭环
//-------------------------------------------------------------------------------

// PID参数
typedef struct
{
    float kp;											// 增益系数
    float ki;											// 积分系数
    float kd;											// 微分系数
    float kvff;											// 速度前馈系数
    long integralLimit;                                 // 积分饱和极限
    long derivativeLimit;                               // 微分饱和极限
    short outLimit;                                     // 输出饱和极限
} TPidPara;

// Dac参数
typedef struct
{
	short inverse;			// 电压是否取反
	short bias;				// Dac零漂
	short dacLmt;			// Dac输出极限值
}TDacMotor;

// 设置单轴闭环控制的DA参数,轴与DA通道的对应
MTN_API short  __stdcall NMC_MtSetCloseLoopDac (HAND axisHandle,TDacMotor *pDacPara);

// 获取单轴闭环控制的DA参数
MTN_API short  __stdcall NMC_MtGetCloseLoopDac (HAND axisHandle,TDacMotor *pDacPara);

// 设置单轴的控制模式：默认使用对应轴的编码器作为输入反馈,对应序号的DAC作为输出
// 闭环模式下,先调用NMC_SetCloseLoopDac指令
//mode: 0 脉冲控制  1 DA闭环控制，默认为脉冲控制
MTN_API short  __stdcall NMC_MtSetCtrlMode(HAND axisHandle,short mode);

// 读取单轴的控制模式
MTN_API short  __stdcall NMC_MtGetCtrlMode(HAND axisHandle,short *pMode);


//设置对应组号的PID参数
MTN_API short  __stdcall NMC_MtSetPIDPara(HAND axisHandle,short index, TPidPara *pidPara);

// 获取对应组号的PID参数
MTN_API short  __stdcall NMC_MtGetPIDPara(HAND axisHandle,short index, TPidPara *pPidPara);

// 设置使用哪组PID
MTN_API short  __stdcall NMC_MtSetPIDIndex(HAND axisHandle,short index);

// 获取正使用的PID组号
MTN_API short  __stdcall NMC_MtGetPIDIndex(HAND axisHandle,short *pIndex);

//-------------------------------------------------------------------------------
//19.高级BufIo输出配置及控制
//-------------------------------------------------------------------------------
// BufIo输出最大组数
#define MAX_ADV_BUFIO_GROUP	2

// 高级BufIo输出参数
typedef struct
{
	// 输出点
	short outType;				// 输出类型，0：通用输出；1：Gate信号；其他保留
	short outGroup;				// 输出组，取值范围[0,n]
	short outIndex;				// 输出序号，取值范围[0,n]
	short outSns;				// 有效电平,0:低电平有效，1：高电平
	
	// 信号
	short pulseMode;		// 0：电平输出，1：脉冲输出W
	long  pulseOnTime;		// 有效电平时间（脉冲输出方式下有效），单位：微秒
	long  pulseOffTime;		// 无效电平时间（脉冲输出方式下有效），单位：微秒
	
	unsigned char reserved[32];	// 保留
}TAdvBufIoParam;

// 设置BufIo输出参数
MTN_API short  __stdcall NMC_AdvBufIoSetParam(HAND devHandle,TAdvBufIoParam *pPrm,short ch);

// 读取BufIo输出参数
MTN_API short  __stdcall NMC_AdvBufIoGetParam(HAND devHandle,TAdvBufIoParam *pPrm,short ch);

// 缓冲区设置高级BufIo输出有效（运动一段距离后输出特定状态）
// outLength:距离，单位：脉冲
// value: 脉冲模式下输出脉冲个数，电平方式下无意义。
// ch:输出组，取值范围：[0,MAX_ADV_BUFIO_GROUP)
MTN_API short  __stdcall NMC_CrdAdvBufIoOnAfterLen(HAND crdHandle,long segNo,
	long outLength,long value,short ch);

// 缓冲区设置高级BufIo关闭输出（缓冲区全部运动结束前提前一段距离输出特定状态）
// outLength:距离，单位：脉冲
// ch:输出组，取值范围：[0,MAX_ADV_BUFIO_GROUP)
MTN_API short  __stdcall NMC_CrdAdvBufIoOffBeforeLen(HAND crdHandle,long segNo,long outLength,short ch );
	
// 立即设置高级BufIo输出
// value: 脉冲模式下输出脉冲个数，电平方式下0:关闭，1:打开。
// ch:输出组，取值范围：[0,MAX_ADV_BUFIO_GROUP)
MTN_API short  __stdcall NMC_AdvBufIoOut(HAND devHandle,long value,short ch);

// 读取BufIo的输出数量
// pOutCout:输出脉冲个数
// ch:输出组，取值范围：[0,MAX_ADV_BUFIO_GROUP)
MTN_API short  __stdcall NMC_AdvBufIoGetPulseCnt(HAND devHandle,long *pOutCout,short ch);

//-------------------------------------------------------------------------------
//20.模拟量控制
//-------------------------------------------------------------------------------

// 设置DAC（模拟量输出）通道的模式
// ch:模拟量通道号,取值范围[0,n]
// mode:模拟量输出范围,0:0~5V, 1:0~10V, 2: 0~10.8V, 3:+/-5V, 4:+/-10V, 5:+/-10.8V,其他无效，默认为4
MTN_API short __stdcall NMC_SetDacMode(HAND devHandle,short ch, short mode);

// 读取DAC（模拟量输出）通道的模式
// ch:模拟量通道号,取值范围[0,n]
// pMode:返回的模拟量输出范围设定值
MTN_API short __stdcall NMC_GetDacMode(HAND devHandle,short ch,short *pMode);

// 设置Adc参数
// ch:模拟量通道号,0~7表示轴通道上的AD，256：表示扩展AD
// mode:模拟量范围,0:0~5V, 1:0~10V, 2: 0~10.8V, 3:+/-5V, 4:+/-10V, 5:+/-10.8V,默认为0
// 注意：目前只支持+/-10V
// filterCoe:滤波系数，取值范围[0,16],0表示取消Adc滤波，单位:ms，默认值为0
MTN_API short __stdcall NMC_SetAdcMode(HAND devHandle,short ch,short range,short filterCoe);

// 读取Adc参数
// ch:模拟量通道号,0~7表示轴通道上的AD，256：表示扩展AD
// pMode:模拟量范围
// pFilterCoe:滤波系数
MTN_API short __stdcall NMC_GetAdcMode(HAND devHandle,short ch,short *pRange,short *pFilterCoe);

// 设置DAC（模拟量输出）输出值
// ch:模拟量通道号,取值范围[0,n]
// dacValue:模拟量输出值,取值范围[-32768,32767],对应DAC输出范围
MTN_API short __stdcall NMC_SetDac(HAND devHandle,short ch,short dacValue);

// 读取DAC（模拟量输出）输出值
// ch:模拟量通道号,取值范围[0,n]
// pDacValue:返回模拟量输出值,取值范围[-32768,32767],对应DAC输出范围
MTN_API short __stdcall NMC_GetDac(HAND devHandle,short ch,short *pDacValue);

// 读取ADC（模拟量输入）值
// ch:模拟量通道号,取值范围[0,n]
// pAdcValue:返回模拟量输入值，取值范围[-32768,32767],对应Adc输入电压范围
MTN_API short __stdcall NMC_GetAdc(HAND devHandle,short ch,short *pAdcValue);




#define     RTN_LIB_UNSUPPORT           -1              // 库指令不支持 
#define     RTN_LIB_PARA_ERROR           -2              //库指令参数错不支持 
#define     RTN_DRV_ERROR                   -3              // 桢数据出错，指令桢长度超 
#define     RTN_FRAME_ERROR               -4              // 桢数据出错，指令桢长度超 
#define     RTN_FRAME_UNSUPPORT     -5              // 桢类型不支持错误         
#define     RTN_FRAME_TIMEOUT           -6              // 桢数据超时               
#define     RTN_FRAME_SUM_ERROR      -7              // 检验和错误               
#define     RTN_VEC_FHASE_ERROR        -8              // 矢量数据桢时序不支持     
#define     RTN_VEC_FIFO_FULL              -9              // 缓冲区满                                                           
#define     RTN_CMD_UNSUPPORT        -10              // 指令不支持               
#define     RTN_CMD_PARA_ERROR        -11              //参数1错，范围超出         
#define     RTN_CMD_EXE_ERROR           -12              // 执行失败                 
#define     RTN_CMD_PARA2_ERROR        -13             //参数2错，范围超出   
#define     RTN_CMD_PARA3_ERROR        -14             //参数3错，范围超出   
#define     RTN_CMD_PARA4_ERROR        -15             //参数4错，范围超出   
#define     RTN_CMD_PARA5_ERROR        -16             //参数5错，范围超出   
#define     RTN_CMD_PARA6_ERROR        -17             //参数6错，范围超出   
#define     RTN_CMD_PARA7_ERROR        -18             //参数7错，范围超出   
#define     RTN_CMD_PARA8_ERROR        -19             //参数8错，范围超出   
#define     RTN_CMD_PARA9_ERROR        -20             //参数9错，范围超出   
#define     RTN_CMD_PARA_OTHER         -21			   //其他错误     


// 错误代码
#define RTN_CMD_SUCCESS			0		        // 指令成功执行
#define RTN_CMD_TBD				999				// TBD

// return error code form Library,[1,99]
#define RTN_LIB_SEARCH_MODE						1	// NMC_DevSearch:不支持的搜索模式
#define RTN_LIB_OPEN_INDEX						2	// NMC_DevOpen:序号不能小于0
#define RTN_LIB_OPEN_COMM						3	// NMC_DevOpen:端口打开错误
#define RTN_LIB_OPEN_COMM2						4	// NMC_DevOpenByID:端口打开错误
#define RTN_LIB_ID_WRITE						5	// NMC_DevWriteID:写ID错误
#define RTN_LIB_ID_READ							6	// NMC_DevReadID:读ID错误
#define RTN_LIB_NOT_CONNECT						7	// NMC_CrdOpen:设备未打开
#define RTN_LIB_MT_INDEX						8	// NMC_MtOpen:序号小于0或者大于16
#define RTN_LIB_LINE_AXCNT						9	// NMC_CrdLineXYZ:轴数量范围不正确
#define RTN_LIB_LOCK							10	// 通讯锁错误
#define RTN_LIB_DEBUG_MODE						11	// NMC_SetCmdDebug:库Debug模式错误
#define RTN_LIB_DEBUG_FILE_CRT					12	// NMC_SetCmdDebug:debug文件创建
#define RTN_LIB_DEBUG_FILE_OPEN					13	// NMC_SetCmdDebug:debug文件打开
#define RTN_LIB_DEBUG_H_OPEN					14	// NMC_SetCmdDebug:通讯打开
#define RTN_LIB_CRDGetAxisPos_Cnt				15	// NMC_CrdGetAxisPos:cnts参数范围不正确[1,N]
#define RTN_LIB_CRDGetPos_Cnt					16	// NMC_CrdGetPrfPos的cnts参数范围不正确[1,N]
#define RTN_LIB_CRDGetEncPos_Cnt				17	// NMC_CrdGetEncPos的cnts参数范围不正确[1,N]
#define RTN_LIB_BackSramWrite_LEN				18	// NMC_BackSramWrite数据长度超出范围[1,240]
#define RTN_LIB_BackSramRead_LEN				19	// NMC_BackSramRead数据长度超出范围[1,240]
#define RTN_LIB_UserParaWr_LEN					20	// NMC_UserParaWr数据长度超出范围[1,240]
#define RTN_LIB_UserParaRd_LEN					21	// NMC_UserParaRd数据长度超出范围[1,240]
#define RTN_LIB_CRDLINEXYZPACK_Cnt				22	// NMC_CrdLineXYZPack:范围不正确，[1,5]
#define RTN_LIB_COLLECT_DATA_LEN				23	// NMC_GetCollectData:len
#define RTN_LIB_CONFIG_FILE						24	// NMC_SaveConfigToFile:配置文件错误


// return error code form HostComm,[100,199]
#define RTN_COMM_PARA_LEN						100	// 参数长度不符合
#define RTN_COMM_CMD_UNSUPPORT					101	// 指令字不支持
#define RTN_COMM_TOP_UNSUPPORT					102	// 顶端指令字不支持
#define RTN_COMM_TOP_PARA						103	// 顶端参数错误
#define RTN_COMM_BACKSRAMREAD					104	// NMC_BackSramRead:参数错误//检查地址长度是否合理
#define RTN_COMM_BACKSRAMWRITE					105	// NMC_BackSramWrite:参数错误//检查地址长度是否合理
#define RTN_COMM_SYSUPGRADEEX					106	// NMC_SYSUPGRADEEX执行失败
#define RTN_COMM_DEVSETPARA						107	// NMC_DevSetPara执行失败
#define RTN_COMM_DEVGETPARA						108	// NMC_DevGetPara执行失败
#define RTN_COMM_GETTIME						109 // NMC_GetTime执行错误
#define RTN_COMM_USERPARAWR_PRM					110 // NMC_UserParaWr参数错误
#define RTN_COMM_USERPARAWR_EXE					111 // NMC_UserParaWr执行错误
#define RTN_COMM_USERPARARD_PRM					112 // NMC_UserParaRd参数错误

// return error code form Command
#define RTN_MC_MT_OPEN_INDEX						1000	// NMC_MtOpen:itemNo参数返回错误
#define RTN_MC_MT_LMT_POSSWT						1001	// NMC_MtLmtOnOff:posSwt参数范围不正确[0,1]
#define RTN_MC_MT_LMT_NEGSWT						1002	// NMC_MtLmtOnOff:negSwt参数范围不正确[0,1]
#define RTN_MC_MT_LMT_HANDLE						1003	// NMC_MtLmtOnOff:axisHandle错误
#define RTN_MC_MT_GETLMT_HANDLE						1004	// NMC_MtGetLmtOnOff:axisHandle错误
#define RTN_MC_MT_LMTSNS_POSSWT						1005	// NMC_MtLmtSns:posSwt参数范围不正确[0,1]
#define RTN_MC_MT_LMTSNS_NEGSWT						1006	// NMC_MtLmtSns:negSwt参数范围不正确[0,1]
#define RTN_MC_MT_LMTSNS_HANDLE						1007	// NMC_MtLmtSns:axisHandle错误
#define RTN_MC_MT_GETLMTSNS_HANDLE					1008	// NMC_MtGetLmtSns:axisHandle错误

#define RTN_MC_MT_ALMON_SWT							1010	// NMC_MtAlarmOnOff:swt参数范围不正确[0,1]
#define RTN_MC_MT_ALMON_HANDLE						1011	// NMC_MtAlarmOnOff:axisHandle错误
#define RTN_MC_MT_GETALMON_HANDLE					1012	// NMC_MtGetAlarmOnOff:axisHandle错误
#define RTN_MC_MT_ALMSns_SWT						1013	// NMC_MtAlarmSns:swt参数范围不正确[0,1]
#define RTN_MC_MT_ALMSns_HANDLE						1014	// NMC_MtAlarmSns:axisHandle错误
#define RTN_MC_MT_GETALSns_HANDLE					1015	// NMC_MtGetAlarmSns:axisHandle错误
#define RTN_MC_MT_SwLmtOn_SWT						1016	// NMC_MtSwLmtOnOff:swt参数范围不正确[0,1]
#define RTN_MC_MT_SwLmtOn_HANDLE					1017	// NMC_MtSwLmtOnOff:axisHandle错误
#define RTN_MC_MT_GetSwLmtOn_HANDLE					1018	// NMC_MtGetSwLmtOnOff:axisHandle错误
#define RTN_MC_MT_SwLmtV_POS						1019	// NMC_MtSwLmtValue:正向软限位值不应该小于等于负向
#define RTN_MC_MT_SwLmtV_HANDLE						1020	// NMC_MtSwLmtValue:axisHandle错误
#define RTN_MC_MT_GetSwLmtV_HANDLE					1021	// NMC_MtGetSwLmtValue:axisHandle错误
#define RTN_MC_MT_PosErr_VALUE						1022	// NMC_MtSetPosErrLmt:posErr位置误差不能小于0
#define RTN_MC_MT_PosErr_HANDLE						1023	// NMC_MtSetPosErrLmt:axisHandle错误
#define RTN_MC_MT_GetPosErr_HANDLE					1024	// NMC_MtGetPosErrLmt:axisHandle错误
#define RTN_MC_MT_SafePara_HANDLE					1025	// NMC_MtSetSafePara:axisHandle错误
#define RTN_MC_MT_SafeParaEdec						1026	// NMC_MtSetSafePara:estpDec必须大于0
#define RTN_MC_MT_SafeParaMaxV						1027	// NMC_MtSetSafePara:maxVel必须大于0
#define RTN_MC_MT_SafeParaMaxA						1028	// NMC_MtSetSafePara:maxAcc必须大于0
#define RTN_MC_MT_GetSafePara_HANDLE				1029	// NMC_MtGetSafePara:axisHandle错误
#define RTN_MC_SvrOn_HANDLE							1030	// NMC_MtSetSvOn:axisHandle错误
#define RTN_MC_SvrOff_HANDLE						1031	// NMC_MtSetSvOn:axisHandle错误
#define RTN_MC_SetPos_HANDLE						1032	// NMC_MtSetAxisPos:axisHandle错误
#define RTN_MC_SetEncPos_HANDLE						1033	// NMC_MtSetEncPos:axisHandle错误
#define RTN_MC_GetAPos_HANDLE						1034	// NMC_MtGetAxisPos:axisHandle错误
#define RTN_MC_GetPPos_HANDLE						1035	// NMC_MtGetPrfPos:axisHandle错误
#define RTN_MC_GetEPos_HANDLE						1036	// NMC_MtGetEncPos:axisHandle错误
#define RTN_MC_GetCPos_HANDLE						1037	// NMC_MtGetCmdPos:axisHandle错误
#define RTN_MC_SetCapSns_HANDLE						1038	// NMC_MtSetCaptSns:axisHandle错误
#define RTN_MC_GetCapSns_HANDLE						1039	// NMC_MtGetCaptSns:axisHandle错误
#define RTN_MC_SetCap_HANDLE						1040	// NMC_MtSetCapt:axisHandle错误
#define RTN_MC_GetCapPos_HANDLE						1041	// NMC_MtGetCaptPos:axisHandle错误
#define RTN_MC_GetSts_HANDLE						1042	// NMC_MtGetSts:axisHandle错误
#define RTN_MC_SetStepMode_HANDLE					1043	// NMC_MtSetStepMode:axisHandle错误
#define RTN_MC_SetStepMode_Mode						1044	// NMC_MtSetStepMode:mode参数范围错误[0,1]
#define RTN_MC_SetStepMode_Invert					1045	// NMC_MtSetStepMode:invert参数范围错误[0,1]
#define RTN_MC_GetStepMode_HANDLE					1046	// NMC_MtGetStepMode:axisHandle错误
#define RTN_MC_GetMIo_HANDLE						1047	// NMC_MtGetMotionIO:axisHandle错误
#define RTN_MC_GetStsP_Count						1048	// NMC_MtGetStsPack:axisHandle错误
#define RTN_MC_GetStsP_AxNum						1049	// NMC_MtGetStsPack:axisHandle错误
#define RTN_MC_SvClr_HANDLE							1050	// NMC_MtSetSvClr:axisHandle错误
#define RTN_IO_SetDo_GROUP							1051	// NMC_SetDO:groupID范围错误[0,n]
#define RTN_IO_GetDo_GROUP							1052	// NMC_GetDO:gourpID范围错误[0,n]
#define RTN_IO_SetDoBit_INDEX						1053	// NMC_SetDOBit:bitIndex错误
#define RTN_IO_SetDoBit_GROUP						1054	// NMC_SetDOBit:gourpID错误
#define RTN_IO_GetDi_GROUP							1055	// NMC_GetDI:gourpID错误
#define RTN_IO_GetDiBit_INDEX						1056	// NMC_GetDIBit:bitIndex错误
#define RTN_IO_GetDiBit_GROUP						1057	// NMC_GetDIBit:gourpID错误
#define RTN_IO_GetEncV_INDEX						1058	// NMC_GetEncVel:encId错误
#define RTN_IO_GetEncPos_INDEX						1059	// NMC_GetEncPos:axisHandle错误
#define RTN_MC_SetVar_ID							1060	// NMC_SetVar8B:varID错误
#define RTN_MC_GetVar_ID							1061	// NMC_GetVar8B:varID错误
#define RTN_MC_SysGetVar_ID							1062	// NMC_SysSetVar8B:varID错误
#define RTN_MC_SysSetVar_ID							1063	// NMC_SysGetVar8B:varID错误
#define RTN_MC_GetEncMode_ID						1064	// NMC_GetEncMode:encID错误
#define RTN_MC_SetEncMode_ID						1065	// NMC_SetEncMode:encID错误
#define RTN_MC_SetEncMode_MOVE						1066	// NMC_SetEncMode:正在运动，不能设置
#define RTN_MC_SetStepFilt_HANDLE					1067	// NMC_MtSetStepFilter:axisHandle错误
#define RTN_MC_PrfCfg_HANDLE						1068	// NMC_MtPrfConfig:axisHandle错误
#define RTN_MC_PrfCfg_PORT							1069	// NMC_MtPrfConfig:port范围错误[0,1]
#define RTN_MC_GetPrfCfg_HANDLE						1070	// NMC_MtGetPrfConfig:axisHandle错误
#define RTN_MC_SetPrfMode_HANDLE					1071	// NMC_MtSetPrfMode:axisHandle错误
#define RTN_MC_SetPrfMode_UNSUPPORT					1072	// NMC_MtSetPrfMode:模式不支持错误
#define RTN_MC_GetPrfMode_HANDLE					1073	// NMC_MtGetPrfMode:axisHandle错误
#define RTN_MC_SetPtpPrm_HANDLE						1074	// NMC_MtSetPtpPara:axisHandle错误
#define RTN_MC_SetPtpPrm_SVEL						1075	// NMC_MtSetPtpPara:startVel不能小于0
#define RTN_MC_SetPtpPrm_EVEL						1076	// NMC_MtSetPtpPara:endVel不能小于0
#define RTN_MC_SetPtpPrm_ACC						1077	// NMC_MtSetPtpPara:acc不能小于等于0
#define RTN_MC_SetPtpPrm_DEC						1078	// NMC_MtSetPtpPara:dec不能小于等于0
#define RTN_MC_SetPtpPrm_SMTH						1079	// NMC_MtSetPtpPara:smoothCoef不能小于0
#define RTN_MC_GetPtpPrm_HANDLE						1080	// NMC_MtGetPtpPara:axisHandle错误
#define RTN_MC_SetJogPrm_HANDLE						1081	// NMC_MtSetJogPara:axisHandle错误
#define RTN_MC_SetJogPrm_ACC						1082	// NMC_MtSetJogPara:acc不能小于等于0
#define RTN_MC_SetJogPrm_DEC						1083	// NMC_MtSetJogPara:dec不能小于等于0
#define RTN_MC_SetJogPrm_SMTH						1084	// NMC_MtSetJogPara:smoothCoef不能小于0
#define RTN_MC_GetJogPrm_HANDLE						1085	// NMC_MtGetJogPara:axisHandle错误
#define RTN_MC_SetVel_HANDLE						1086	// NMC_MtSetVel:axisHandle错误
#define RTN_MC_SetVel_VEL							1087	// NMC_MtSetVel:vel范围不正确,对于PTP（0,4500),对于JOG(-4500,4500)
#define RTN_MC_SetVel_VEL2							1088	// NMC_MtSetVel:vel范围不正确,对于PTP（0,4500),对于JOG(-4500,4500)
#define RTN_MC_GetVel_HANDLE						1089	// NMC_MtGetVel:axisHandle错误
#define RTN_MC_SetPtpTgtPos_HANDLE					1090	// NMC_MtSetPtpTgtPos:axisHandle错误
#define RTN_MC_SetPtpTgtPos_POS						1091	// NMC_MtSetPtpTgtPos:pos范围错误
#define RTN_MC_GetPtpTgtPos_HANDLE					1092	// NMC_MtGetPtpTgtPos:axisHandle错误
#define RTN_MC_UPDATE_HANDLE						1093	// NMC_MtUpdate:axisHandle错误
#define RTN_MC_STOP_HANDLE							1094	// NMC_MtStop:axisHandle错误
#define RTN_MC_ESTOP_HANDLE							1095	// NMC_MtEstp:axisHandle错误
#define RTN_MC_GetPrfVel_HANDLE						1096	// NMC_MtGetPrfVel:axisHandle错误
#define RTN_MC_ZeroPos_HANDLE						1097	// NMC_MtZeroPos:axisHandle错误
#define RTN_MC_ZeroPos_MOVE							1098	// NMC_MtZeroPos:正在运动，不能执行该操作

#define RTN_MC_CrdCfg_HANDLE						1099	// NMC_CrdConfig:crdHandle错误
#define RTN_MC_CrdCfg_DISABLE						1100	// NMC_CrdConfig:crd无法使用
#define RTN_MC_CrdCfg_AXIS							1101	// NMC_CrdConfig:参与轴数目错误
#define RTN_MC_CrdCfg_AXIS_INDEX					1102	// NMC_CrdConfig:参与轴序号错误
#define RTN_MC_CrdCfg_BUSY							1103	// NMC_CrdConfig:坐标系正在运动
#define RTN_MC_GetCrdCfg_HANDLE						1104	// NMC_CrdGetConfig:crdHandle错误
#define RTN_MC_CrdDel_HANDLE						1105	// NMC_CrdDelete:crdHandle错误
#define RTN_MC_CrdDel_BUSY							1106	// NMC_CrdDelete:坐标系正在运动,不能执行该操作
#define RTN_MC_CrdSetPrm_HANDLE						1107	// NMC_CrdSetPara:crdHandle错误
#define RTN_MC_CrdSetPrm_EN							1108	// NMC_CrdSetPara:坐标系未启用
#define RTN_MC_CrdSetPrm_ACC						1109	// NMC_CrdSetPara:synAccMax范围不正确，(0,max]
#define RTN_MC_CrdSetPrm_VEL						1110	// NMC_CrdSetPara:synVelMax范围不正确，(0,max]
#define RTN_MC_CrdGetPrm_HANDLE						1111	// NMC_CrdGetPara:crdHandle错误
#define RTN_MC_CrdGetPrm_EN							1112	// NMC_CrdGetPara:坐标系未启用
#define RTN_MC_CrdSetExtPrm_HANDLE					1113	// NMC_CrdSetExtPara:crdHandle错误
#define RTN_MC_CrdSetExtPrm_EN						1114	// NMC_CrdSetExtPara:坐标系未启用
#define RTN_MC_CrdSetExtPrm_T						1115	// NMC_CrdSetExtPara:T范围不正确，(0,max]
#define RTN_MC_CrdSetExtPrm_VEL						1116	// NMC_CrdSetExtPara:startVel范围不正确，[0,max]
#define RTN_MC_CrdSetExtPrm_EDEC					1117	// NMC_CrdSetExtPara:abruptDec范围不正确，(0,max]
#define RTN_MC_CrdSetExtPrm_SDEC					1118	// NMC_CrdSetExtPara:smoothDec范围不正确，(0,max]
#define RTN_MC_CrdGetExtPrm_HANDLE					1119	// NMC_CrdGetExtPara:crdHandle错误
#define RTN_MC_CrdGetExtPrm_EN						1120	// NMC_CrdGetExtPara:坐标系未启用
#define RTN_MC_StartMtn_HANDLE						1121	// NMC_CrdStartMtn:crdHandle错误
#define RTN_MC_StartMtn_EN							1122	// NMC_CrdStartMtn:坐标系未启用或者正在运动
#define RTN_MC_StopMtn_HANDLE						1123	// NMC_CrdStopMtn:crdHandle错误
#define RTN_MC_StopMtn_EN							1124	// NMC_CrdStopMtn:坐标系未启用
#define RTN_MC_EStopMtn_HANDLE						1125	// NMC_CrdEstopMtn:crdHandle错误
#define RTN_MC_EStopMtn_EN							1126	// NMC_CrdEstopMtn:坐标系未启用
#define RTN_MC_GetCrdSts_HANDLE						1127	// NMC_CrdGetSts:crdHandle错误
#define RTN_MC_GetCrdSts_EN							1128	// NMC_CrdGetSts:坐标系未启用
#define RTN_MC_GetCrdPos_HANDLE						1129	// NMC_CrdGetPrfPos:crdHandle错误
#define RTN_MC_GetCrdPos_EN							1130	// NMC_CrdGetPrfPos:坐标系未启用
#define RTN_MC_GetCrdPos_COUNT						1131	// NMC_CrdGetPrfPos:cnts范围不正确
#define RTN_MC_GetCrdVel_HANDLE						1132	// NMC_CrdGetVel:crdHandle错误
#define RTN_MC_GetCrdVel_EN							1133	// NMC_CrdGetVel:坐标系未启用
#define RTN_MC_SetOvrd_HANDLE						1134	// NMC_CrdSetOverRide:crdHandle错误
#define RTN_MC_SetOvrd_EN							1135	// NMC_CrdSetOverRide:坐标系未启用
#define RTN_MC_SetOvrd_OVERIDE						1136	// NMC_CrdSetOverRide:overRide范围错误
#define RTN_MC_GetOvrd_HANDLE						1137	// NMC_CrdGetOverRide:crdHandle错误
#define RTN_MC_GetOvrd_EN							1138	// NMC_CrdGetOverRide:坐标系未启用
#define RTN_MC_GetBufFree_HANDLE					1139	// NMC_CrdBufGetFree:crdHandle错误
#define RTN_MC_GetBufFree_EN						1140	// NMC_CrdBufGetFree:坐标系未启用
#define RTN_MC_GetBufUsed_HANDLE					1141	// NMC_CrdBufGetUsed:crdHandle错误
#define RTN_MC_GetBufUsed_EN						1142	// NMC_CrdBufGetUsed:坐标系未启用
#define RTN_MC_CrdBufClr_HANDLE						1143	// NMC_CrdBufClr:crdHandle错误
#define RTN_MC_CrdBufClr_EN							1144	// NMC_CrdBufClr:坐标系未启用
#define RTN_MC_GetSegNo_HANDLE						1145	// NMC_CrdGetUserSegNo:crdHandle错误
#define RTN_MC_GetSegNo_EN							1146	// NMC_CrdGetUserSegNo:坐标系未启用
#define RTN_MC_GetBufAllCnt_HANDLE					1147	// NMC_CrdGetBufAllCmdCnt:crdHandle错误
#define RTN_MC_GetBufAllCnt_EN						1148	// NMC_CrdGetBufAllCmdCnt:坐标系未启用
#define RTN_MC_EndMtn_HANDLE						1149	// NMC_CrdEndMtn:crdHandle错误
#define RTN_MC_EndMtn_EN							1150	// NMC_CrdEndMtn:坐标系未启用
#define RTN_MC_GetCrdEncPos_HANDLE					1151	// NMC_CrdGetEncPos:crdHandle错误
#define RTN_MC_GetCrdEncPos_EN						1152	// NMC_CrdGetEncPos:坐标系未启用
#define RTN_MC_GetCrdEncPos_COUNT					1153	// NMC_CrdGetEncPos:count范围错误
#define RTN_MC_CrdClrErr_HANDLE						1154	// NMC_CrdClrError:crdHandle错误
#define RTN_MC_CrdClrErr_EN							1155	// NMC_CrdClrError:坐标系未启用
#define RTN_MC_CrdSetVFolw_HANDLE					1156	// NMC_CrdSetValueFollow:crdHandle错误
#define RTN_MC_CrdSetVFolw_EN						1157	// NMC_CrdSetValueFollow:坐标系未启用
#define RTN_MC_CrdLineXYZ_HANDLE					1158	// NMC_CrdLineXYZ:crdHandle错误
#define RTN_MC_CrdLineXYZ_EN						1159	// NMC_CrdLineXYZ:坐标系未启用
#define RTN_MC_CrdLineXYZ_VEL						1160	// NMC_CrdLineXYZ:Vel范围不正确
#define RTN_MC_CrdLineXYZ_ACC						1161	// NMC_CrdLineXYZ:synAcc范围不正确
#define RTN_MC_CrdArcR_HANDLE						1162	// NMC_CrdArcRadius:crdHandle错误
#define RTN_MC_CrdArcR_EN							1163	// NMC_CrdArcRadius:坐标系未启用
#define RTN_MC_CrdArcR_VEL							1164	// NMC_CrdArcRadius:Vel范围不正确
#define RTN_MC_CrdArcR_ACC							1165	// NMC_CrdArcRadius:synAcc范围不正确
#define RTN_MC_CrdArcC_HANDLE						1166	// NMC_CrdArcCenter:crdHandle错误
#define RTN_MC_CrdArcC_EN							1167	// NMC_CrdArcCenter:坐标系未启用
#define RTN_MC_CrdArcC_VEL							1168	// NMC_CrdArcCenter:Vel范围不正确
#define RTN_MC_CrdArcC_ACC							1169	// NMC_CrdArcCenter:synAcc范围不正确
#define RTN_MC_CrdArcP_HANDLE						1170	// NMC_CrdArcPPP:crdHandle错误
#define RTN_MC_CrdArcP_EN							1171	// NMC_CrdArcPPP:坐标系未启用
#define RTN_MC_CrdArcP_VEL							1172	// NMC_CrdArcPPP:Vel范围不正确
#define RTN_MC_CrdArcP_ACC							1173	// NMC_CrdArcPPP:synAcc范围不正确
#define RTN_MC_CrdHelixC_HANDLE						1174	// NMC_CrdHelixCenter:crdHandle错误
#define RTN_MC_CrdHelixC_EN							1175	// NMC_CrdHelixCenter:坐标系未启用
#define RTN_MC_CrdHelixC_VEL						1176	// NMC_CrdHelixCenter:Vel范围不正确
#define RTN_MC_CrdHelixC_ACC						1177	// NMC_CrdHelixCenter:synAcc范围不正确
#define RTN_MC_CrdHelixC_ROUND						1178	// NMC_CrdHelixCenter:rounds范围不正确
#define RTN_MC_CrdBufDo_HANDLE						1179	// NMC_CrdBufDo:crdHandle错误
#define RTN_MC_CrdBufDo_EN							1180	// NMC_CrdBufDo:坐标系未启用
#define RTN_MC_CrdBufDo_GOURP						1181	// NMC_CrdBufDo:group范围不正确
#define RTN_MC_CrdBufDo_OPBITS						1182	// NMC_CrdBufDo:opbits范围不正确
#define RTN_MC_CrdBufOut_HANDLE						1183	// NMC_CrdBufOut:crdHandle错误
#define RTN_MC_CrdBufOut_EN							1184	// NMC_CrdBufOut:坐标系未启用
#define RTN_MC_CrdBufOut_CH							1185	// NMC_CrdBufOut:ch范围不正确
#define RTN_MC_CrdBufOut_GROUP						1186	// NMC_CrdBufOut:group范围不正确
#define RTN_MC_CrdBufDelay_HANDLE					1187	// NMC_CrdBufDelay:crdHandle错误
#define RTN_MC_CrdBufDelay_EN						1188	// NMC_CrdBufDelay:坐标系未启用
#define RTN_MC_CrdBufDelay_SCALE					1189	// NMC_CrdBufDelay:ch范围不正确
#define RTN_MC_CrdBufDelay_COUNT					1190	// NMC_CrdBufDelay:group范围不正确
#define RTN_MC_CrdBufDi_HANDLE						1191	// NMC_CrdBufWaitDI:crdHandle错误
#define RTN_MC_CrdBufDi_EN							1192	// NMC_CrdBufWaitDI:坐标系未启用
#define RTN_MC_CrdBufDi_INDEX						1193	// NMC_CrdBufWaitDI:index范围不正确
#define RTN_MC_CrdBufDi_COUNT						1194	// NMC_CrdBufWaitDI:waitTimeInMs范围不正确
#define RTN_MC_CrdBufAx_HANDLE						1195	// NMC_CrdBufAxMove:crdHandle错误
#define RTN_MC_CrdBufAx_EN							1196	// NMC_CrdBufAxMove:坐标系未启用
#define RTN_MC_CrdBufAx_AXIS						1197	// NMC_CrdBufAxMove:axisNum范围不正确
#define RTN_MC_BufSetPtpMovePara_HANDLE				1198	// NMC_CrdBufSetPtpMovePara:crdHandle错误
#define RTN_MC_BufSetPtpMovePara_EN					1199	// NMC_CrdBufSetPtpMovePara:坐标系未启用
#define RTN_MC_BufSetPtpMovePara_AXIS				1200	// NMC_CrdBufSetPtpMovePara:axis范围不正确
#define RTN_MC_BufSetPtpMovePara_VEL				1201	// NMC_CrdBufSetPtpMovePara:vel范围不正确
#define RTN_MC_BufSetPtpMovePara_ACC				1202	// NMC_CrdBufSetPtpMovePara:acc范围不正确
#define RTN_MC_BufSetPtpMovePara_SMTH				1203	// NMC_CrdBufSetPtpMovePara:smooth范围不正确
#define RTN_MC_CrdBufFollow_HANDLE					1204	// NMC_CrdBufWaitDI:crdHandle错误
#define RTN_MC_BufPushData_EN						1205	// NMC_CrdPushData:crdHandle错误
#define RTN_MC_BufPushData_HANDLE					1206	// NMC_CrdPushData:坐标系未启用

#define RTN_MC_INN_GetCenter_OVER					1207	// 插补指令圆弧参数错误//请检查圆弧参数是否符合
#define RTN_MC_INN_GetRad_OVER						1208	// 插补指令圆弧参数错误//请检查圆弧参数是否符合
#define RTN_MC_INN_GetCircDist_NULL					1209	// 插补指令圆弧参数错误//请检查圆弧参数是否符合
#define RTN_MC_INN_ARC_ONLYXY						1210	// 目前只支持XY平面的圆弧插补
#define RTN_MC_INN_ARC_ONLYXY2						1211	// 目前只支持XY平面的圆弧插补
#define RTN_MC_INN_ARC_ENDP							1212	// 圆弧终点不合理，过大或者过小
#define RTN_MC_INN_ARC_R_CIRCLE						1213	// 半径描述法，不支持描述整圆
#define RTN_MC_INN_ARC_R_CENTER						1214	// 圆心位置不合理
#define RTN_MC_INN_ARC_PPP_SAME						1215	// 3点重合
#define RTN_MC_INN_ARC_PPP_LINE						1216	// 3点共线
#define RTN_MC_INN_HELIX_NULL						1217	// 螺旋线数据为空
#define RTN_MC_INN_HELIX_ENDP						1218	// 螺旋线数据终点不合理，过大或者过小
#define RTN_MC_INN_HELIX_CIRCLE						1219	// 螺旋线不能描述整圆
#define RTN_MC_INN_HELIX_CENTER						1220	// 螺旋线圆心位置不合理
#define RTN_MC_INN_HELIX_POS						1221	// 螺旋线起点和终点不合理
#define RTN_MC_INN_HELIX_LEN						1222	// 螺旋线长度不合理
#define RTN_MC_INN_DOWNDATA_NULL					1223	// 下载数据为空
#define RTN_MC_INN_DA_CH							1224	// DAC通道范围不正确
#define RTN_MC_INN_DOWNLINE_NULL					1225	// 下载数据为空
#define RTN_MC_INN_DOWNLINE_POS						1226	// 下载数据位置不合理，过大或者过小
#define RTN_MC_INN_ENDVEL_ZERO						1227	// 计算的终点速度小于0
#define RTN_MC_INN_VEL_ZERO							1228	// 计算的目标速度小于0
#define RTN_MC_INN_ACC_ZERO							1229	// 计算的目标速度小于0
#define RTN_MC_INN_DOWNARC_NULL						1230	// 下载数据为空
#define RTN_MC_INN_ARC_Z							1231	// Z方向存在位移，目前支持XY平面
#define RTN_MC_INN_C_ENDPOS							1232	// 终点位置不合理，过大或者过小
#define RTN_MC_INN_CD_CIRCLE						1233	// 圆弧下载：半径描述法不能描述整圆
#define RTN_MC_INN_CD_CENTER						1234	// 圆弧下载：圆心坐标不合理
#define RTN_MC_INN_CD_PPP_S							1235	// 圆弧下载：三点重合
#define RTN_MC_INN_CD_PPP_L							1236	// 圆弧下载：三点共线
#define RTN_MC_INN_HELIX_D_NULL						1237	// 螺旋线数据为空
#define RTN_MC_INN_HELIX_D_ENDP						1238	// 螺旋线数据终点不合理，过大或者过小
#define RTN_MC_INN_HELIX_D_CIRCLE					1239	// 螺旋线不能描述整圆
#define RTN_MC_INN_HELIX_D_CENTER					1240	// 螺旋线圆心位置不合理
#define RTN_MC_INN_HELIX_D_POS						1241	// 螺旋线起点和终点不合理
#define RTN_MC_INN_HELIX_D_LEN						1242	// 螺旋线长度范围不正确
#define RTN_MC_INN_HELIX_D_VELEND					1243	// 螺旋线终点速度范围不正确
#define RTN_MC_INN_HELIX_D_VEL						1244	// 螺旋线速度范围不正确
#define RTN_MC_INN_HELIX_D_ACC						1245	// 螺旋线加速度范围不正确
#define RTN_MC_INN_CRV_TYPE							1246	// 指令类型异常
#define RTN_MC_INN_DS_NULL							1247	// 下层下发数据为空
#define RTN_MC_INN_DC_VEL							1248	// 圆弧计算速度超出范围
#define RTN_MC_INN_DC_ENDVEL						1249	// 圆弧计算速度超出范围
#define RTN_MC_INN_DC_ACC							1250	// 圆弧计算速度超出范围
#define RTN_MC_INN_DC_ENDPOS						1251	// 圆弧计算终点不合理，过大或者过小
#define RTN_MC_CRD_NO_SPACE							1252	// 插补缓冲区无数据
#define RTN_MC_MT_SetAxisFilter_Err					1253	// 设置轴速度滤波参数错误
#define RTN_MC_AX_ON_ALARM				1254	// axis on 条件不满足:伺服报警
#define RTN_MC_AX_ON_POSERR				1255	// axis on 条件不满足:位置越限
#define RTN_MC_EnableCrdSdram			1256	// 使能crd的sdram启用参数错误
#define RTN_MC_Sdram_no_Space			1257	// SDRAM无足够空间
#define RTN_MC_Push_Sdram_err			1258	// push数据到SDRAM错误
#define RTN_MC_AX_HOME_PARA				1259	// 回零临时，参数不正确
#define RTN_MC_CrdGetConfig_EN			1260	// NMC_CrdGetConfig获取参数时，未使能插补模块
#define RTN_MC_ClrCrdSts_HANDLE			1261	// NMC_ClrCrdSts句柄错误

#define RTN_MC_SetHomePara_HANDLE		1262	// NMC_MtSetHomePara句柄错误
#define RTN_MC_GetHomeSts_HANDLE		1263	// NMC_MtGetHomeSts句柄错误
#define RTN_MC_HomeStart_HANDLE			1264	// NMC_MtHome句柄错误
#define RTN_MC_HomeStop_HANDLE			1265	// NMC_MtHomeStop句柄错误
#define RTN_MC_GetHomeError_HANDLE		1266	// NMC_MtGetHomeError句柄错误
#define RTN_MC_GetHomePara_HANDLE		1267	// NMC_MtGetHomePara句柄错误
#define RTN_MC_TryHome_HANDLE			1268	// NMC_MtTryHome句柄错误
#define RTN_MC_HomeStartInNegLmt_HANDLE	1269	// NMC_MtHome或者NMC_MtTryHome调用时，电机负向限位触发，并且负向限位开关未输入句柄错误
#define RTN_MC_HomeStartInPosLmt_HANDLE	1270	// NMC_MtHome或者NMC_MtTryHome调用时，电机正向限位触发，并且正向限位开关未输入句柄错误
#define RTN_MC_HomeStartInAlarm_HANDLE	1271	// NMC_MtHome或者NMC_MtTryHome调用时，电机报警
#define RTN_MC_HomeStartInMoving_HANDLE	1272	// NMC_MtHome或者NMC_MtTryHome调用时，电机正在运动
#define RTN_MC_GetCrdAxisPos_HANDLE		1273	// NMC_CrdGetAxisPos句柄错误
#define RTN_MC_GetCrdAxisPos_EN			1274	// NMC_CrdGetAxisPos坐标系未初始化
#define RTN_MC_GetCrdAxisPos_COUNT		1275	// NMC_CrdGetAxisPos cnts参数错误
#define RTN_MC_CrdBufClr_CrdBusy		1276	// NMC_CrdBufClr Crd busy
#define RTN_MC_GetCrdStsPack3_HANDLE	1277	// NMC_CrdGetStsPack3句柄错误
#define RTN_MC_GetCrdStsPack3_EN		1278	// NMC_CrdGetStsPack3坐标系未初始化
#define RTN_MC_CrdSetExtPara_CrdBusy	1279	// NMC_CrdSetExtPara:当前坐标系正在运动
#define RTN_MC_CrdSetPara_CrdBusy		1280	// NMC_CrdSetPara:当前坐标系正在运动
#define RTN_MC_CrdConfig_CrdBusy		1281	// NMC_CrdConfig:当前坐标系正在运动
#define RTN_MC_CrdStartMtn_Mode			1282	// NMC_CrdStartMtn:启动时相关轴模式不对
#define RTN_MC_SetPrfMode_Busy			1283	// NMC_SetPrfMode:需要切换模式的轴处于busy状态
#define RTN_MC_MtUpdate_error			1284	// NMC_MtUpdate启动模式错误，当前轴模式不在该启动范围
#define RTN_MC_SetPrfCoe_HANDLE			1285	// NMC_MtSetPrfCoe:句柄错误
#define RTN_MC_GetPrfCoe_HANDLE			1286	// NMC_MtGetPrfCoe:句柄错误
#define RTN_MC_SetPrfCoe_Range			1287	// NMC_MtSetPrfCoe:系数范围不正确// inCoe有效范围：(0,1]
#define RTN_MC_SetPrfCoe_Busy			1288	// NMC_MtSetPrfCoe:轴忙，不能设置
#define RTN_MC_SetPrfCoe_PosNotZero		1289	// NMC_MtSetPrfCoe:当前位置不为0，不能设置// 先回原点，清除位置，然后再设置
#define RTN_MC_GetIOModuleSts_Unsupport	1290	// NMC_GetIOModuleSts:IO扩展模块不支持
#define RTN_MC_SetIOModuleEn_Param		1291	// NMC_SetIOModuleEn:参数错误，chDevId范围不正确
#define RTN_MC_SetIOModuleEn_Unsupport	1292	// NMC_SetIOModuleEn:IO扩展模块不支持
#define RTN_MC_GetDI_En					1293	// NMC_GetDI:对应IO模块未配置
#define RTN_MC_BackSramWrite_out_rang	1294	// NMC_BackSramWrite操作地址越界
#define RTN_MC_BackSramRead_out_rang	1295	// NMC_BackSramRead操作地址越界
#define RTN_MC_BackSramWrite_Len		1296	// NMC_BackSramWrite:写sram错误，写入长度不正确
#define RTN_MC_BackSramRead_Len			1297	// NMC_BackSramRead:读sram错误，读取长度不正确
#define RTN_MC_CrdLineXYZPack_Count		1298	// NMC_CrdLineXYZPack:count范围不正确[1,5]
#define RTN_MC_CrdLineXYZPack_Handle	1299	// NMC_CrdLineXYZPack:句柄错误
#define RTN_MC_CrdLineXYZPack_En		1300	// NMC_CrdLineXYZPack:坐标系未初始化
#define RTN_MC_CrdLineXYZPack_NoSpace	1301	// NMC_CrdLineXYZPack:没有足够的空间 // 检查空间是否足够
#define RTN_MC_CrdSetArcSecPara_Handle	1302	// NMC_CrdSetArcSecPara:句柄错误
#define RTN_MC_CrdSetArcSecPara_En		1303	// NMC_CrdSetArcSecPara:坐标系未初始化
#define RTN_MC_CrdSetArcSecPara_R_Rise	1304	// NMC_CrdSetArcSecPara:误差半径表的r值不符合，必须递增
#define RTN_MC_CrdSetArcSecPara_Err		1305	// NMC_CrdSetArcSecPara:误差半径表的err值不能小于等于0
#define RTN_MC_CrdSetArcSecPara_Diff	1306	// NMC_CrdSetArcSecPara:maxArcDiff范围不正确，不能小于1
#define RTN_MC_CrdSetArcSecPara_Sec		1307	// NMC_CrdSetArcSecPara:minSectionLen不能小于0
#define RTN_MC_CrdGetArcSecPara_Handle	1308	// NMC_CrdGetArcSecPara:句柄错误
#define RTN_MC_CrdGetArcSecPara_En		1309	// NMC_CrdGetArcSecPara:坐标系未初始化
#define RTN_IO_GetDIBit_En				1310	// NMC_GetDIBit:扩展模块未使能 //请先调用NMC_SetIOModuleEn使能响应模块
#define	RTN_IO_SetDoBit_En				1311	// NMC_SetDOBit:扩展模块未使能 //请先调用NMC_SetIOModuleEn使能响应模块
#define	RTN_IO_SetDo_En					1312	// NMC_SetDO:扩展模块未使能 //请先调用NMC_SetIOModuleEn使能响应模块
#define	RTN_IO_GetDo_En					1313	// NMC_GetDO:扩展模块未使能 //请先调用NMC_SetIOModuleEn使能响应模块
#define RTN_MC_GetCollectDataAddr_BUSY 	1314 	// NMC_GetCollectDataAddr:正在数据采集
#define RTN_MC_GetCollectDataAddr_index 1315 	// NMC_GetCollectDataAddr:index 超出范围
#define RTN_MC_ConfigCollect_BUSY 		1316 	// NMC_ConfigCollect:正在采集数据，不允许配置
#define RTN_MC_StartCollect_ErrFlag 	1317 	// NMC_StartCollect:正在采集数据
#define RTN_MC_GetCollectData_Err 		1318 	// NMC_GetCollectData:取数据失败
#define	RTN_MC_ConfigCollect_count		1319 	// MC_ConfigCollect:count 超出范围
#define	RTN_MC_SetJogPara_Busy			1320 	// NMC_MtSetJogPara:忙
#define	RTN_MC_SetJogPara_Mode			1321 	// NMC_MtSetJogPara:非jog模式下不允许配置
#define	RTN_MC_SetPtpPara_Busy			1322 	// NMC_MtSetPtpPara:忙
#define	RTN_MC_SetPtpPara_Mode			1323 	// NMC_MtSetPtpPara:非PTP模式下不允许配置
#define	RTN_MC_SetAxisPos_Busy			1324 	// NMC_MtSetAxisPos:非静止状态下禁止设置
#define RTN_IO_SetEncPos_INDEX			1325	// NMC_MtSetEncPos:encId范围不正确
#define RTN_MC_SetEncCoe_HANDLE			1326	// NMC_MtSetEncCoe:句柄错误
#define RTN_MC_GetEncCoe_HANDLE			1327	// NMC_MtGetEncCoe:句柄错误
#define RTN_MC_SetEncCoe_Range			1328	// NMC_MtSetEncCoe:系数范围不正确// inCoe有效范围：(0,1]
#define RTN_MC_SetEncCoe_Busy			1329	// NMC_MtSetEncCoe:轴忙，不能设置
#define RTN_MC_SetEncCoe_PosNotZero		1330	// NMC_MtSetEncCoe:当前位置不为0，不能设置// 先回原点，清除位置，然后再设置
#define	RTN_MC_ConfigCollect_Interval	1331    // MC_ConfigCollect:interval 超出范围

#define RTN_MC_SetLaserPower_group 		1332	// NMC_SetLaserPower设置激光能量的组号超范围
#define RTN_MC_SetLaserPower_points		1334	// NMC_SetLaserPower设置激光能量的组内点数超单位
#define RTN_MC_LaserOn_group					1335	//  NMC_LaserOn打开激光的组号超范围
#define RTN_MC_LaserOn_type						1336	// 	NMC_LaserOn打开激光的类型不对
#define RTN_MC_LaserOff_group					1337	//  NMC_LaserOff关闭激光的组号超范围
#define RTN_MC_LaserOff_type					1338 	//  NMC_LaserOff关闭激光的类型不对
#define RTN_MC_LaserConfig_laserType	1339	// NMC_LaserConfig配置激光的类型不对
#define RTN_MC_LaserConfig_val_err		1340	// NMC_LaserConfig配置激光的option值错误
#define RTN_MC_DelGantryGroup_exe_err	1341	// NMC_DelGantryGroup:执行错误
#define RTN_MC_DelGantryGroup_axisHandle_err	1342	//NMC_DelGantryGroup:句柄错误
#define RTN_MC_SetGantrySlave_have_Set	1343	// NMC_SetGantrySlave:设置错误
#define RTN_MC_SetGantryMaster_Busy		1344	// NMC_SetGantrySlave:正在运动
#define RTN_MC_SetGantrySlave_HANDLE	1345	// NMC_SetGantrySlave:句柄错误
#define RTN_MC_SetGantryMaster_HANDLE	1346	// NMC_SetGantryMaster:句柄错误
#define RTN_MC_SetGantryMaster_have_master	1347	// NMC_SetGantryMaster:master存在
#define RTN_MC_CrdLineXYZ_Len_Zero		1348	// NMC_CrdLineXYZ:直线插补长度为0
#define RTN_MC_CrdGotoBreak_VEL				1349	// CrdGotoBreak:速度设置错误
#define RTN_MC_CrdGotoBreak_ACC				1350	// CrdGotoBreak:加速度设置错误
#define RTN_MC_CrdGotoBreak_axis_busy  1351	// CrdGotoBreak:回断点轴正忙
#define RTN_MC_CrdSetOffset_count			1352	// CrdSetOffset 设置的偏移个数错误
#define RTN_MC_CrdStartMtn_stPos_err	1353	// CrdStartMtn 启动时的位置与计算起点不一致，或者需要回到断点处
#define RTN_MC_MtSetLmtCfg_Handle	1354	// NMC_MtSetLmtCfg:限位配置句柄错误
#define RTN_MC_MtSetAlarmCfg_Handle	1355	// NMC_MtSetAlarmCfg报警配置句柄错误
#define RTN_MC_CrdGotoBreak_En          1356            // NMC_CrdGotoBreak未启用
#define RTN_MC_CrdGotoBreak_Handle		1357            // NMC_CrdGotoBreak:crd句柄错误
#define RTN_MC_CrdSetOffset_En          1358            // NMC_CrdSetOffset未启用
#define RTN_MC_CrdSetOffset_Handle		1359            // NMC_CrdSetOffset:crd句柄错误
#define RTN_MC_CrdSetOffset_Axis_Busy	1360            // NMC_CrdSetOffset:电机正在运动
#define RTN_MC_CrdGotoBreak_NoData		1361			// NMC_CrdGotoBreak:无断点信息
#define RTN_MC_MtSetEncPos_Busy			1362			// NMC_MtSetEncPos:忙，正在运动
#define RTN_MC_SetGantrySlave_Busy		1363			// NMC_SetGantrySlave:忙
#define RTN_MC_SetGantrySlave_Pos		1364			// NMC_SetGantrySlave:主从轴当前位置超?
#define RTN_MC_GantryGroup_Range		1365			// gantry gourp参数范围不正确，有效范围[0,]
#define RTN_MC_SetGantrySlave_ErrLmt_Range 1367			// NMC_SetGantrySlave：gantryErrLmt必须大于0


#define RTN_MC_BufSHIOGateOn_HANDLE			500	// NMC_BufSHIOGateOn:句柄错误
#define RTN_MC_BufSHIOGateOn_EN			501		//  NMC_BufSHIOGateOn:调用该指令未启动插补坐标系
#define RTN_MC_BufSHIOGateOff_HANDLE			502	//  NMC_BufSHIOGateOff:句柄错误
#define RTN_MC_BufSHIOGateOff_EN			503		//  NMC_BufSHIOGateOff:调用该指令未启动插补坐标系
#define RTN_MC_LaserConfig_mode_err			504	//  NMC_LaserConfig:输入模式错误，没有该模式
#define RTN_MC_ConfigSHIOPara_isArray			505  //  NMC_ConfigHSIOPara:isArray参数错误
#define RTN_MC_ConfigSHIOPara_outMode			506	//  NMC_ConfigHSIOPara:outMode参数错误
#define RTN_MC_ConfigSHIOPara_posSrc			507	//  NMC_ConfigHSIOPara:posSrc参数错误
#define RTN_MC_ConfigSHIOPara_gateTime			508	//  NMC_ConfigHSIOPara:gateTime参数错误
#define RTN_MC_ConfigSHIOPara_delay			509	//  NMC_ConfigHSIOPara:delay参数小于0
#define RTN_MC_ConfigSHIOPara_gateDistance			510	//  NMC_ConfigHSIOPara:gateDistance参数错误
#define RTN_MC_SHIOTriggerOn_triggerFreq			511	//  NMC_SHIOTriggerOn:triggerFreq参数错误
#define RTN_MC_SHIOTriggerOn_triggerWidth			512	//  NMC_SHIOTriggerOn:triggerWidth参数错误
#define RTN_MC_SetLaserMode_mode			513	//  NMC_SetLaserMode:输入模式错误，没有该模式
#define RTN_MC_ConfigSHIOPara_axisMask			514	//  NMC_SetLaserMode:输入模式错误，没有该模式
#define RTN_MC_SHIOChangeAxisMask_axisMask			515	//  NMC_SetLaserMode:输入模式错误，没有该模式
#define RTN_MC_MtClrError_Handle				516	//  NMC_MtClrStsByBits或者NMC_MtClrError:句柄错误
#define RTN_MC_MtClrCaptSts_Handle				517	//  NMC_MtClrCaptSts:句柄错误
#define RTN_MC_ExitHandWheel_HANDLE				518	//  NMC_ExitHandWheel:句柄错
#define RTN_MC_SetHandWheel_HANDLE				519	//  NMC_SetHandWheel:句柄错
#define RTN_MC_SetHandWheel_Ratio				520	//  NMC_SetHandWheel:ratio 范围不正确
#define RTN_MC_SetHandWheel_Acc					521	//  NMC_SetHandWheel:acc 范围不正确
#define RTN_MC_SetHandWheel_Vel					522	//  NMC_SetHandWheel:vel 范围不正确
#define RTN_MC_SetHandWheel_Busy				523	//  NMC_SetHandWheel:busy
#define RTN_MC_ExitHandWheel_Busy				524	//  NMC_ExitHandWheel:busy
#define RTN_MC_SetHandWheel_isHandWheel_Mode 	525	//  NMC_SetHandWheel:已经是手轮模式
#define RTN_MC_SelectHandWheelInput_Index 		526	//  NMC_SelectHandWheelInput:通道范围不正确，[0,9]
#define RTN_MC_ExitHandWheel_Mode				527	//  NMC_ExitHandWheel:busy
#define RTN_MC_SetHandWheelRatio_Ratio			528	//  NMC_SetHandWheelRatio:ratio不能为0
#define RTN_MC_SetWatchDog_Mode	                529	//  NMC_SetWatchDog:stopMode参数不正确
#define RTN_MC_SetWatchDog_DoGroup              530	//  NMC_SetWatchDog:groupID参数不正确
#define RTN_MC_MtPtSetStatic_HANDLE				531	//  NMC_MtPtSetStatic:句柄
#define RTN_MC_MtPtGetStatic_HANDLE				532 //  NMC_MtPtGetStatic:句柄
#define RTN_NMC_MtPtSetStatic_no_pt_mode		533 //  NMC_MtPtSetStatic:非PT模式
#define RTN_NMC_MtPtSetStatic_onOff				534 //  NMC_MtPtSetStatic:onOff参数不正确[0,1]
#define RTN_MC_MtPtGetSpace_HANDLE				535 //  NMC_MtPtGetSpace:句柄 
#define RTN_NMC_MtPtGetSpace_no_pt_mode			536 //  NMC_MtPtGetSpace:非PT模式
#define RTN_MC_MtPtPush_HANDLE					537 //  NMC_MtPtPush:句柄 
#define RTN_NMC_MtPtPush_no_pt_mode				538 //  NMC_MtPtPush:非PT模式 
#define RTN_NMC_MtPtPush_count					539 //  NMC_MtPtPush:count参数不正确 
#define RTN_NMC_MtPtPush_pos					540 //  NMC_MtPtPush:位置参数不正确 
#define RTN_NMC_MtPtPush_time					541 //  NMC_MtPtPush:时间参数不正确  
#define RTN_NMC_MtPtPush_type					542 //  NMC_MtPtPush:类型参数不正确   
#define RTN_MC_MtPtBufClr_HANDLE				543 //  NMC_MtPtBufClr:句柄     
#define RTN_NMC_MtPtBufClr_no_pt_mode			544 //  NMC_MtPtBufClr:非PT模式
#define RTN_NMC_MtPtBufClr_busy					545 //  NMC_MtPtBufClr:忙        
#define RTN_MC_MtPtStartMtn_HANDLE				546 //  NMC_MtPtStartMtn:句柄         
#define RTN_NMC_MtPtStartMtn_syncAxCnts			547 //  NMC_MtPtStartMtn:axCnts参数不正确
#define RTN_NMC_MtPtStartMtn_no_pt_mode			548 //  NMC_MtPtStartMtn:非PT模式 
#define  RTN_NMC_MtPtStartMtn_one_axis_isBusy  	549 //  NMC_MtPtStartMtn:轴正在运动
#define  RTN_NMC_MtPtStartMtn_no_data			550 //  NMC_MtPtStartMtn:无PT数据
#define RTN_MC_Password_Paser                   551	//  系统密码解析错误
#define RTN_MC_Password_Format                  552	//  系统密码格式错误
#define RTN_MC_Password_Verify                  553	//   系统密码验证失败
#define RTN_MC_Password_Deny             	    554	//   系统密码验证过于频繁
#define RTN_MC_Password_Load             	    555	//   系统密码验证:加载
#define RTN_MC_Password_Save             	    556	//   系统密码验证:保存
#define RTN_MC_SetTime_TimeFormat               557	//  NMC_SetTime:时间格式不正确
#define RTN_MC_SetTime_Save			            558	//  NMC_SetTime:保存系统时间错误
#define RTN_MC_DacChanelInvalid			        559	//  dac通道无效
#define RTN_MC_SetDacMode_ModeInvalid	        560	//  dac模式无效
#define RTN_MC_SetDacMode_Set			        561	//  dac模式设置错误
#define RTN_MC_SetDac_Value						562 //  dac设定值范围不正确
#define RTN_MC_SetDac_Set						563 //  dac输出错误
#define RTN_MC_GetAdc_Get						564 //  adc读取错误
#define RTN_MC_CrdLaserFollow_Handle			565 //  CrdLaserFollow:CrdHandle
#define RTN_MC_CrdLaserFollow_not_set_laserType 566 // CrdLaserFollow:激光类型未设置
#define RTN_MC_CrdLaserFollow_followType_err		567 // CrdLaserFollow：坐标系激光跟随的速度类型参数错误
#define RTN_MC_CrdEnableLaserFollow_Handle			568 // CrdEnableLaserFollow:CrdHandle
#define RTN_MC_CrdEnableLaserFollow_onOff				569 // CrdEnableLaserFollow：onOff参数错误
#define RTN_MC_AdcChanelInvalid					570	// adc通道无效
#define RTN_MC_CrdBufOut_DacValue				571 // CrdBufOut:da设定值无效
#define RTN_MC_LaserSetParam_OnDelay				572 // NMC_LaserSetParam:onDelay范围错误
#define RTN_MC_LaserSetParam_OffDelay				573 // NMC_LaserSetParam:offDelay范围错误
#define RTN_MC_LaserSetParam_Ch					574 // NMC_LaserSetParam:ch范围错误
#define RTN_MC_LaserGetParam_Ch							575	// NMC_LaserGetParam:ch范围错误
#define RTN_MC_CrdBufLaserOnOff_Handle					576	// NMC_LaserGetOnOffDelay:ch范围错误
#define RTN_MC_CrdBufLaserOnOff_En					    577	// NMC_LaserGetOnOffDelay:坐标系未使能
#define RTN_MC_CrdBufLaserOnOff_OnOff					578	// NMC_LaserGetOnOffDelay:onOff范围错误
#define RTN_MC_CrdBufLaserOnOff_Ch					    579	// NMC_LaserGetOnOffDelay:ch范围错误
#define RTN_MC_CrdBufLaserPower_Handle					580	// NMC_CrdBufLaserPower:handle错误
#define RTN_MC_CrdBufLaserPower_En					    581	// NMC_CrdBufLaserPower:坐标系未使能
#define RTN_MC_CrdBufLaserPower_Power					582	// NMC_CrdBufLaserPower:power范围错误
#define RTN_MC_CrdBufLaserPower_Ch					    583	// NMC_CrdBufLaserPower:ch范围错误
#define RTN_MC_SetDac_CtrlMode						    584	// SetDac:DAC控制模式错误
#define RTN_MC_LaserSetParam_LaserType				585 // LaserSetParam: 设置时，激光类型未设置
#define RTN_MC_LaserSetMode_Ch				586 // NMC_LaserSetMode:ch参数不正确
#define RTN_MC_LaserSetMode_Set				587 // NMC_LaserSetMode:设置模式
#define RTN_MC_LaserSetParam_StandbyPower		588 // NMC_LaserSetStandbyPower:ch参数不正确
#define RTN_MC_LaserSetOutputType_Index		589 // NMC_LaserSetOutputType:index参数不正确
#define RTN_MC_LaserSetOutputType_Set		590 // NMC_LaserSetOutputType:设置错误
#define RTN_MC_LaserSetOutputType_Ch				591 // NMC_LaserSetOutputType:ch范围错误
#define RTN_MC_LaserTimeArrayOn_Ch				592 // NMC_LaserTimeArrayOn:ch范围错误
#define RTN_MC_LaserTimeArrayOff_Ch				593 // NMC_LaserTimeArrayOff:ch范围错误
#define RTN_MC_LaserSetPower_Ch	    594	// NMC_LaserSetPower:ch范围错误
#define RTN_MC_LaserOnOff_Mode		595	// NMC_LaserOnOff:当前模式下不支持
#define RTN_MC_LaserOnOff_OnOff     596	// NMC_LaserOnOff:onOff参数范围错误
#define RTN_MC_LaserOnOff_Ch		597 // NMC_LaserOnOff:ch参数范围错误
#define RTN_MC_SHIOGateOnOff_Mode		598 // NMC_SHIOGateOn:mode不正确
#define RTN_MC_LaserConfig_laserType_occupied		599 // NMC_LaserConfig:配置的laserType被占用了
#define RTN_MC_LaserConfig_conflict_laserType		600 // NMC_LaserConfig:配置的laserType类型有冲突
#define RTN_MC_SetLaserMode_conflict_mode				601 // NMC_SetLaserMode:配置的模式有冲突
#define RTN_MC_CrdBufMotion_LookaheadDis				602 // Crd:lookaheadDis参数范围错误
#define RTN_MC_SetLaserPower_Time					603 // NMC_LaserSetTimeArrayPower:时间设置错误

#define RTN_MC_LinearCompSetParam_dimens	  	604 // NMC_LinearCompSetParam：设置的维数参数不对
#define RTN_MC_LinearCompSetParam_axisMask		605 // NMC_LinearCompSetParam：设置的轴映射不对
#define RTN_MC_LinearCompSetParam_src			606 // NMC_LinearCompSetParam：设置的比较源参数不对
#define RTN_MC_LinearCompSetParam_cmpMode		607 // NMC_LinearCompSetParam：设置的比较源参数不对
#define RTN_MC_LinearCompSetParam_gateTime		608 // NMC_LinearCompSetParam：设置的比较输出的脉冲宽度参数不对
#define RTN_MC_LinearCompSetParam_chn			609 // NMC_LinearCompSetParam：设置的输出通道参数不对


#define RTN_MC_LinearCompInterval_count			610 // NMC_LinearCompInterval：设置的比较数量参数不对
#define RTN_MC_LinearCompInterval_section		611 // NMC_LinearCompInterval：设置的比较数据细分段数过大
#define RTN_MC_LinearCompInterval_cmpmode		612 // NMC_LinearCompInterval：设置的比较数据的比较模式不对

#define RTN_MC_LinearCompOnOff_onOff			613	// NMC_LinearCompOnOff: onOff参数错误

#define RTN_MC_Comp2DimensSetParam_chnType			614	// NMC_Comp2DimensSetParam: chnType参数错误	
#define RTN_MC_Comp2DimensSetParam_dirNo				615	// NMC_Comp2DimensSetParam: dirNo参数错误	
#define RTN_MC_Comp2DimensSetParam_errZone			616	// NMC_Comp2DimensSetParam: errZone参数错误	
#define RTN_MC_Comp2DimensSetParam_gateTime			617	// NMC_Comp2DimensSetParam: gateTime参数错误	
#define RTN_MC_Comp2DimensSetParam_outputType		618	// NMC_Comp2DimensSetParam: outputType参数错误	
#define RTN_MC_Comp2DimensSetParam_outputchn		619	// NMC_Comp2DimensSetParam: outputchn参数错误	
#define RTN_MC_Comp2DimensSetParam_posSrc				620	// NMC_Comp2DimensSetParam: posSrc参数错误	
#define RTN_MC_Comp2DimensSetParam_stLevel			621	// NMC_Comp2DimensSetParam: stLevel参数错误	
#define RTN_MC_Comp2DimensSetData_count					622	// NMC_Comp2DimensSetData: count参数错误	
#define RTN_MC_Comp2DimensOnoff_onOff						623	// NMC_Comp2DimensOnoff: onOff参数错误	
#define RTN_MC_Comp2DimensSetData_push_data_failed 624 //NMC_Comp2DimensSetData:压入数据失败 
#define RTN_MC_Comp2DimensSetParam_group				625	// NMC_Comp2DimensSetParam:group参数错误
#define RTN_MC_Comp2DimensGetParam_group				626 // NMC_Comp2DimensGetParam:group参数错误
#define RTN_MC_Comp2DimensSetData_group					627	// NMC_Comp2DimensSetData:group参数错误
#define RTN_MC_Comp2DimensOnoff_group						628	// NMC_Comp2DimensOnoff:group参数错误
#define RTN_MC_Comp2DimensStatus_group					629	// NMC_Comp2DimensStatus:group参数错误
#define RTN_MC_SetDiFilter_Range					630	// NMC_SetDIFilter:参数错误

#define RTN_MC_CrdEnableMatrixCalc_enable											630	// NMC_CrdEnableMatrixCalc:enable参数错误
#define RTN_MC_CrdEnableMatrixCalc_rotAxisNo									631	// NMC_CrdEnableMatrixCalc:rotAxisNo参数错误
#define RTN_MC_CrdEnableMatrixCalc_angleRadEqual							632	// NMC_CrdEnableMatrixCalc:angleRadEqual参数错误
#define RTN_MC_LinearCompSetData_count			633 // NMC_LinearCompSetData：设置的比较数量参数不对
#define RTN_MC_LinearCompSetData_section		634 // NMC_LinearCompSetData：设置的比较数据细分段数过大
#define RTN_MC_LinearCompSetData_cmpmode		635 // NMC_LinearCompSetData：设置的比较数据的比较模式不对
#define RTN_MC_LaserSetParam_Busy				636 // NMC_LaserSetParam:激光打开情况下不允许设置参数


#define RTN_MC_CrdEnableMatrixCalc_HANDLE 	637   // NMC_CrdEnableMatrixCalc:句柄错误
#define RTN_MC_CrdSetSafePara_HANDLE 				638   // NMC_CrdSetSafePara:句柄错误
#define RTN_MC_CrdEnableMatrixCalc_En 			639   // NMC_CrdEnableMatrixCalc:坐标系未使能

#define RTN_MC_CrdSetPolarType_En						640   // NMC_CrdSetPolarType:坐标系不允许使能
#define RTN_MC_CrdSetPolarType_HANDLE				641   // NMC_CrdSetPolarType:句柄错误
#define RTN_MC_CrdSetPolarType_rotAxNo			642   // NMC_CrdSetPolarType:极坐标的旋转轴号超范围
#define RTN_MC_CrdSetPolarType_transAxNo		643   // NMC_CrdSetPolarType:极坐标的平移轴号超范围
#define RTN_MC_CrdSetPolarType_rotAxNo_transAxNo_equal		644   // NMC_CrdSetPolarType:极坐标旋转轴和平移轴选定的轴号相同
#define RTN_MC_CrdSetPolarType_rotEquiv			645   // NMC_CrdSetPolarType:极坐标旋转轴当量错误

#define RTN_MC_CrdRunToPolarPos_HANDLE			646   // NMC_CrdRunToPolarPos:句柄错误

#define RTN_MC_CrdDeletePolar_HANDLE				647   // NMC_CrdDeletePolar:句柄错误
#define RTN_CrdDeletePolar_En								648   // NMC_CrdDeletePolar:坐标系未关闭
#define RTN_MC_CrdRunToPolarPos_En					649		// NMC_CrdRunToPolarPos:坐标系不允许使能
#define RTN_MC_CrdRunToPolarPos_not_polar		650		// NMC_CrdRunToPolarPos:坐标系未设置成极坐标

#define RTN_MC_CrdRunToPolarTheta_HANDLE		651
#define RTN_MC_CrdRunToPolarTheta_En				652
#define RTN_MC_CrdRunToPolarTheta_not_polar			653
#define RTN_MC_CrdRunToPolarTheta_clrRoundFlag 		654
#define RTN_MC_LaserSetTimeArrayPara_Ch 			655	//NMC_LaserSetTimeArrayPara参数错误：ch
#define RTN_MC_LaserSetTimeArrayPara_OutType 		656	//NMC_LaserSetTimeArrayPara参数错误：ouputType
#define RTN_MC_LaserSetTimeArrayPara_OutCh 		657	//NMC_LaserSetTimeArrayPara参数错误：outputCh
#define RTN_MC_LaserSetTimeArrayPara_PWMWidth 		658	//NMC_LaserSetTimeArrayPara参数错误：pwmWidth
#define RTN_MC_LaserSetTimeArrayPara_Period		659	//NMC_LaserSetTimeArrayPara参数错误：pwmPeriod
#define RTN_MC_LaserTimeArrayOn_group				660	//NMC_LaserTimeArrayExe参数错误：group
#define RTN_MC_CrdBufLaserTimeArrayExe_En			661 //NMC_CrdBufLaserTimeArrayExe:crd not enable
#define RTN_MC_CrdBufLaserTimeArrayExe_Ch			662	//NMC_CrdBufLaserTimeArrayExe参数错误：ch
#define RTN_MC_CrdBufLaserTimeArrayExe_Group		663	//NMC_CrdBufLaserTimeArrayExe参数错误：gourp
#define RTN_MC_CrdBufWaitEncInPosition_En		664	//NMC_CrdBufWaitEncInPosition坐标系未启用
#define RTN_MC_CrdBufWaitEncInPosition_AxisMask		665	//NMC_CrdBufWaitEncInPosition参数错误：axisMask
#define RTN_MC_CrdBufWaitEncInPosition_overTime		666	//NMC_CrdBufWaitEncInPosition参数错误：overTime

#define RTN_MC_MtSetAxisArrivalPara_HANDLE					667 //NMC_MtSetAxisArrivalParan参数错误：handle
#define RTN_MC_MC_MtSetAxisArrivalPara_arrivalBand	668 //NMC_MtSetAxisArrivalParan参数错误：arrivalBand
#define RTN_MC_MC_MtSetAxisArrivalPara_stableTime		669  //NMC_MtSetAxisArrivalParan参数错误：stableTime
#define RTN_MC_MtGetAxisArrivalPara_HANDLE					670  //NMC_MtGetAxisArrivalParan参数错误：Handle


#define RTN_MC_CrdArc3D_HANDLE						671  //NMC_CrdArc3D参数错误：Handle
#define RTN_MC_CrdArc3D_EN							672  //NMC_CrdArc3D参数错误：en
#define RTN_MC_CrdArc3D_VEL							673  //NMC_CrdArc3D参数错误：vel
#define RTN_MC_CrdArc3D_ACC							674  //NMC_CrdArc3D参数错误：acc
#define RTN_MC_CrdArc3D_Less_3D						675  //NMC_CrdArc3D 调用时，未建立3D坐标系

#define RTN_MC_INN_CD_3D_S							676	// 3D圆弧下载：三点重合
#define RTN_MC_INN_CD_3D_L							677	// 3D圆弧下载：三点共线
#define RTN_MC_INN_CD_3D_CIR_DEGRAD					678	// 3D圆弧计算参数退化
#define RTN_LIB_NOT_ACTIVE						    679	// 没有激活的功能

#define RTN_MC_LinearCompSetData_pos		 	680 // 线性位置比较的位置错误

#define RTN_MC_CompXDimensSetParam_chn					681				//NMC_CompXDimensSetParam参数错误：chn
#define RTN_MC_CompXDimensSetParam_outCnts			682				//NMC_CompXDimensSetParam参数错误：outCnts
#define RTN_MC_CompXDimensSetParam_outChnType		683				//NMC_CompXDimensSetParam参数错误：outChnType
#define RTN_MC_CompXDimensSetParam_gateTime			684				//NMC_CompXDimensSetParam参数错误：gateTime
#define RTN_MC_CompXDimensSetParam_stLevel			685				//NMC_CompXDimensSetParam参数错误：stLevel	
#define RTN_MC_CompXDimensSetParam_dimens				686				//NMC_CompXDimensSetParam参数错误：dimens
#define RTN_MC_CompXDimensSetParam_errZone			687				//NMC_CompXDimensSetParam参数错误：errZone
#define RTN_MC_CompXDimensSetParam_posSrc				688				//NMC_CompXDimensSetParam参数错误：posSrc
#define RTN_MC_CompXDimensSetParam_outType     	689				//NMC_CompXDimensSetParam参数错误：outType 
#define  RTN_MC_CompXDimensSetParam_outIndex   	690				//NMC_CompXDimensSetParam参数错误：outIndex

#define RTN_MC_CompXDimensGetParam_chn                	691				//NMC_CompXDimensGetParam参数错误：chn

#define RTN_MC_CompXDimensSetData_chn                 	692				//NMC_CompXDimensSetData参数错误：chn
#define RTN_MC_CompXDimensSetData_count               	693				//NMC_CompXDimensSetData参数错误：count
#define RTN_MC_CompXDimensSetData_push_data_failed    	694				//NMC_CompXDimensSetData数据压入SDARM错误

#define RTN_MC_NMC_CompXDimensOnoff_chn               	695				//NMC_CompXDimensOnoff参数错误：chn
#define RTN_MC_NMC_CompXDimensOnoff_onOff             	696				//NMC_CompXDimensOnoff参数错误：onOff 

#define RTN_MC_CompXDimensStatus_chn                  	697				//NMC_CompXDimensStatus参数错误：chn

#define RTN_MC_CrdBufMotion_Polar_err_start							698				// 极坐标运动不允许直线的起点从（0,0）位置出发


#define RTN_MC_AX_ON_BUSY                  							699	
#define RTN_MC_AX_ON_closeloop_no_encoder               700	
#define RTN_MC_AX_ON_closeloop_encoder_with_vel         701	
#define RTN_MC_AX_ON_closeloop_kp_less_zero            	702		
#define RTN_MC_AX_ON_closeloop_no_dac                  	703		

#define RTN_MC_SetCloseLoopDac_HANDLE                  	704		
#define RTN_MC_SetCloseLoopDac_axis_Busy                705	
#define RTN_MC_SetCloseLoopDac_bias                  		706	
#define RTN_MC_SetCloseLoopDac_dacLmt                  	707	
#define RTN_MC_SetCloseLoopDac_inverse                  708	

#define RTN_MC_GetCloseLoopDac_HANDLE                  	709	
#define RTN_MC_GetCloseLoopDac_no_closeloop_dac         710		

#define RTN_MC_MtSetCtrlMode_HANDLE                  		711		
#define RTN_MC_MtSetCtrlMode_axis_Busy                  712	
#define RTN_MC_MtSetCtrlMode_axis_svon                  713	
#define RTN_MC_MtSetCtrlMode_mode                  			714	
#define RTN_MC_MtSetCtrlMode_no_dac                  		715

	
#define RTN_MC_MtGetCtrlMode_HANDLE                  		716	
#define RTN_MC_SetPIDPara_HANDLE                  			717	
#define RTN_MC_SetPIDPara_index                  				718	
#define RTN_MC_SetPIDPara_ctrlMode                  		719	
#define RTN_MC_SetPIDPara_kp                  					720	
#define RTN_MC_SetPIDPara_ki                  					721	
#define RTN_MC_SetPIDPara_kd                  					722
#define RTN_MC_SetPIDPara_kvff                  				723	
#define RTN_MC_SetPIDPara_integralLimit                 724
#define RTN_MC_SetPIDPara_derivativeLimit               725
#define RTN_MC_SetPIDPara_outLimit                  		726

#define RTN_MC_GetPIDPara_HANDLE                  			727
#define RTN_MC_GetPIDPara_ctrlMode                  		728

#define RTN_MC_SelectPID_HANDLE                  				729		// NMC_MtSetPIDIndex:句柄错误
#define RTN_MC_GetUsingPIDIndex_HANDLE                  730		// NMC_MtGetPIDIndex：句柄错误
#define RTN_MC_GetUsingPIDIndex_ctrlMode                731		// NMC_MtGetPIDIndex：控制模式
#define RTN_CrdBufSetEstopDI_HANDLE 										732		// NMC_CrdBufSetEstopDI：句柄
#define RTN_CrdBufSetEstopDI_Axis 											733		// NMC_CrdBufSetEstopDI：轴号范围不正确
#define RTN_MC_UserPassword_UserNotSupport 							734		// 用户名不支持，当前只支持"USER1"

// 临时定义
#define RTN_MC_MtSetLeadScrewPara_HANDLE 				735	// NMC_MtSetLeadScrewPara:句柄错误
#define RTN_MC_MtSetLeadScrewPara_number 				736
#define RTN_MC_MtSetLeadScrewPara_lenPos 				737
#define RTN_MC_MtSetLeadScrewCompPos_HANDLE 		738
#define RTN_MC_MtSetLeadScrewCompPos_index 			739
#define RTN_MC_MtEnableLeadScrew_HANDLE 				740
#define RTN_MC_MtSetLeadScrewCompPos_not_config 741
#define RTN_MC_MtSetLeadScrewCompPos_enable 		742
#define RTN_MC_MtSetEstopDI_HANDLE							743
#define RTN_MC_MtGetEstopDI_HANDLE							744
#define RTN_MC_SetDIBitRevs_Index 							745 // NMC_SetDIBitRevs:bitIndex范围不正确

#define RTN_MC_MtSetAdvCaptParam_HANDLE					746
#define RTN_MC_MtSetAdvCaptParam_capPosType			747
#define RTN_MC_MtSetAdvCaptParam_capPosIndex		748
#define RTN_MC_MtSetAdvCaptParam_trigSrc				749
#define RTN_MC_MtSetAdvCaptParam_trigIndex			750
#define RTN_MC_MtSetAdvCaptParam_trigValue			751
#define RTN_MC_MtSetAdvCaptParam_singleTrigEn		752
#define RTN_MC_MtSetAdvCaptParam_ch							753
#define RTN_MtClrAdvCaptSts_HANDLE							754
#define RTN_MC_MtClrAdvCaptSts_ch								755
#define RTN_MC_MtGetAdvCaptPos_HANDLE						756
#define RTN_MC_MtGetAdvCaptPos_ch								757
#define RTN_MC_MtGetAdvCaptPos_no_active				758
#define RTN_MC_CrdBufDataPack_HANDLE						759	// NMC_CrdBufDataPack:句柄错误
#define RTN_MC_CrdBufDataPack_En								760	// NMC_CrdBufDataPack:坐标系未启用
#define RTN_MC_CrdBufDataPack_UnknowCmd					761	// NMC_CrdBufDataPack:未知的命令
#define RTN_MC_SetDOBitAutoReverse_Index				762	// NMC_SetDOBitAutoReverse:bitindex
#define RTN_MC_SetDOBitAutoReverse_RevsTime			763	// NMC_SetDOBitAutoReverse:reverseTime

#define RTN_MC_MtClrErrorEx_HANDLE							764
#define RTN_NMC_SetDOGroupEx_GetDOVal						765


#define RTN_MC_CrdBufSetStopOffset_HANDLE				766
#define RTN_MC_CrdBufSetStopOffset_EN						767
#define RTN_MC_CrdBufSetStopOffset_Sdram_no_use	768
#define RTN_MC_CrdBufClrStopOffset_HANDLE				769
#define RTN_MC_CrdBufClrStopOffset_EN						770
#define RTN_MC_CrdBufClrStopOffset_Sdram_no_use	771

#define RTN_MC_CompXDimensSetCmpOutMode_chn									772
#define RTN_MC_CompXDimensSetCmpOutMode_outMode							773
#define RTN_MC_CompXDimensSetCmpOutMode_outputchn_not_set		774
#define RTN_MC_MtSetAdvCaptParam_Filter		775								// NMC_MtSetAdvCaptParam:filter取值范围不正确


#define RTN_MC_CrdSetBufLengthFlag_Handle			776
#define RTN_MC_CrdSetBufLengthFlag_flag				777
#define RTN_MC_CrdGetBufLength_Handle					778

#define RTN_MC_CrdSetBufIOAfterLen_HANDLE   		779
#define RTN_MC_CrdSetBufIOAfterLen_EN						780
#define RTN_MC_CrdSetBufIOAfterLen_outLength		781
#define RTN_MC_CrdSetBufIOAfterLen_outType			782
#define RTN_MC_CrdSetBufIOAfterLen_outVal				783

#define RTN_MC_CrdSetBufIOBeforeLen_HANDLE   		784
#define RTN_MC_CrdSetBufIOBeforeLen_EN					785
#define RTN_MC_CrdSetBufIOBeforeLen_outLength		786
#define RTN_MC_CrdSetBufIOBeforeLen_outType			787
#define RTN_MC_CrdSetBufIOBeforeLen_outVal			788
#define RTN_MC_ClrPassword_Err									789			// ClrPassword:解密数据不正确

#define RTN_MC_CrdSetIsShortLine_HANDLE									790
#define RTN_MC_CrdSetIsShortLine_EN											791
#define RTN_MC_CrdSetIsShortLine_isShortLine						792

#define RTN_MC_CrdSetLookAheadCentriAcc_HANDLE					793
#define RTN_MC_CrdSetLookAheadCentriAcc_EN							794
#define RTN_MC_CrdSetLookAheadCentriAcc_isUsingSetAcc		795
#define RTN_MC_CrdSetLookAheadCentriAcc_centriAcc				796

#define RTN_NMC_SetDioMapping_PinGrp				797 // NMC_SetDioMapping:pinGrp/newGrp范围错误
#define RTN_NMC_SetDioMapping_PinIndex				798 // NMC_SetDioMapping:pinIndex/newIndex范围错误
#define RTN_NMC_SetDioMapping_Full				799 // NMC_SetDioMapping:最多只能配置16条映射数据

#define RTN_MC_INN_ARC_ONLYYZ											800
#define RTN_MC_INN_ARC_ONLYZX											801						
#define RTN_MC_INN_ARC_ONLYYZ2										802
#define RTN_MC_INN_ARC_ONLYZX2										803
#define RTN_MC_INN_ARC_X													804
#define RTN_MC_INN_ARC_Y													805
#define RTN_MC_CrdArcRYZ_HANDLE										806
#define RTN_MC_CrdArcRYZ_EN												807
#define RTN_MC_Crd_Less_Three_axes								808
#define RTN_MC_CrdArcRYZ_VEL											809
#define RTN_MC_CrdArcRYZ_ACC											810
#define RTN_MC_CrdArcRZX_HANDLE										811
#define RTN_MC_CrdArcRZX_EN												812
#define RTN_MC_CrdArcRZX_VEL											813
#define RTN_MC_CrdArcRZX_ACC											814
#define RTN_MC_CrdArcC_YZ_HANDLE									815
#define RTN_MC_CrdArcC_YZ_EN											816
#define RTN_MC_CrdArcC_YZ_VEL											817
#define RTN_MC_CrdArcC_YZ_ACC											818
#define RTN_MC_CrdArcC_ZX_HANDLE									819
#define RTN_MC_CrdArcC_ZX_EN											820
#define RTN_MC_CrdArcC_ZX_VEL											821
#define RTN_MC_CrdArcC_ZX_ACC											822
#define RTN_MC_LaserGetOnOff_Ch										823			// NMC_LaserGetOnOff:ch范围不正确
#define RTN_MC_LaserSetOutputType_DacMode					824			// MC_LaserSetOutputType:DAC被占用
#define RTN_MC_MtSetCtrlMode_dac_mode							825			// MC_MtSetCtrlMode:DAC被占用
#define RTN_MC_AdcFilterRange											826			// ADC滤波范围设置不正确
#define RTN_MC_MtXXX_HANDLE												827			// 轴句柄无效
#define RTN_MC_SetDacMode_Busy										828			// SetDacMode:DAC通道被占用（如配置为了激光输出等）
#define RTN_MC_LaserSetParam_MinValue							829 // NMC_LaserSetParam:onDelay范围错误
#define RTN_MC_LaserSetParam_MaxValue							830 // NMC_LaserSetParam:offDelay范围错误
#define RTN_MC_LinearCompSetParam_Busy						831 // NMC_LinearCompSetParam:激活中
#define RTN_MC_SHIOGatePulse_Ch										832 // NMC_SHIOGatePulse:通道号范围不正确
#define RTN_MC_SHIOGatePulse_Busy									833 // NMC_SHIOGatePulse:GateOn时不能输出
#define RTN_MC_PwmPulseOut_Ch											834 // NMC_PwmPulseOut:通道号范围不正确
#define RTN_MC_PwmPulseOut_Busy										835 // NMC_PwmPulseOut:LaserOn时不能输出
#define RTN_MC_ClrErrorEx_Count										836 // NMC_MtClrErrorEx:count范围错误

#define RTN_MC_CrdBufSHIOGatePulse_HANDLE													862
#define RTN_MC_CrdBufSHIOGatePulse_EN															863														
#define RTN_MC_CrdBufSHIOGatePulse_gateTime												864										
#define RTN_MC_CrdBufSHIOGatePulse_gateFrq												865											
#define RTN_MC_CrdBufSHIOGatePulse_outCount												866												
#define RTN_MC_CrdBufSHIOGatePulse_ch															867
#define RTN_MC_CrdBufSHIOGatePulse_Gate_Busy	

#ifdef __cplusplus
}
#endif


#endif  // _H_NMC_LIB20_H_
