///******************************************************************
//
// Moudle Name  :   mtn_lib20_ext.h
// Abstract     :   GaoChuan Motion 2.0 external user header 
// Note :            1.结构体定义中所有的‘reservedxxx’的成员都是保留参数,为保持兼容性,请设置为0
//                    2.无特别说明,所有API返回RTN_CMD_SUCCESS（即0值）表示执行成功,其他则表示错误代码
//                    3.所有的API参数中,无特别说明,axisHandle表示操作轴的句柄,devHandle表示目标控制器的句柄,crdHandle表示目标坐标系组句柄
//                  4.mtn_lib20中所有的结构体都是以四字节对齐方式编译，为了避免结构体对齐引起的问题，请将编译环境设置为四字节对齐
// Modification History :
///******************************************************************
#ifndef _H_MTN_LIB20_EXT_H_
#define _H_MTN_LIB20_EXT_H_
#include "mtn_lib20.h"

#ifdef __cplusplus
extern "C" {
#endif

//------------------------------------------------------------------------------------------------------------
//
//           指令分组索引
//
//------------------------------------------------------------------------------------------------------------
//    1.设备高级配置等
//    2.单轴配置读取
//    3.单轴高级指令
//    4.缓冲区高级指令
//    5.硬件捕获及不常用指令
//    6.平台相关指令
//    7.数据采集模块(高级指令)
//    8.激光
//    9.龙门
//  10.通讯扩展等其他
//  11.手轮
//  12.PT
//  13.线性距离位置比较
//  14.二维位置点比较
//  15.多维位置比较输出
//  16.坐标系输出转换
//  17.结构体初始化函数及常见习惯指令
//  18.闭环
//  19.高级BufIo输出配置及控制
//  20.模拟量控制
//  21.scara
//  22.坐标系干涉保护指令
//  23.不常用指令
//  24.自动状态返回
//  25 : 点位自动收发
//  26 : 高速一维位置比较
//  27 ：带count及clock
//  28.PVT
///////////////////////////////////////////////////////////////////指令
//------------------------------------------------------------------------------------------------------------
//
//    1.设备高级配置等
//
//------------------------------------------------------------------------------------------------------------

// 设置通讯参数,默认值为10000us*1000
// devHandle : 设备句柄
// waitTimeInUs：等待时间,微秒
// retryTimes： 通讯重试次数
MTN_API Int16 __stdcall NMC_SetCommPara( HAND devHandle, UInt32 waitTimeInUs, UInt32 retryTimes );

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

// 板卡打开（根据IP地址）
// pIPv4Array: 板卡IP地址,四个字节,例如：unsinged char ipv4[4] = {192,168,1,110};
// pDevHandle: 返回设备操作句柄
MTN_API Int16 __stdcall NMC_DevOpenByIP   (UInt8 *pIPv4Array, PHAND pDevHandle );

// 板卡打开 通过地址拨码
// addr : 地址拨码,从0开始
// pDevHandle : 设备操作句柄标识（序号）
MTN_API Int16  __stdcall NMC_DevOpenByAddr ( Int16 addr, PHAND pDevHandle );

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

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

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

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

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

typedef struct TCardInfoEx
{
    char strVer[16];           // 控制器版本号
    char strOemVer[16];        // OEM版本号(定制控制器才有),默认为0
    Int16 time[6];          // 时间,年月日,时分秒
    Int16 axisNum;          // 支持的轴数
    Int16 encNum;           // 支持的编码器数
    Int16 diNum;            // 数字输入数量
    Int16 doNum;            // 数字输出数量
    Int16 daNum;            // 模拟量通道
    Int16 adNum;            // 模拟量输入通道
    Int16 shioNum;          // 同步高速IO通道
    Int16 address;         // 控制器的拨码地址
    UInt8 ipv4[4];  // IP地址
    char idStr[16];         // 板卡名称,多卡时可用名称打开参考NMC_DevOpenByID
    UInt32 uid[4];   // 唯一序列号
    char macAddr[6];        // 网口mac地址
    char resv[256];
}TCardInfoEx;

// 读取当前运动控制器信息
MTN_API Int16 __stdcall NMC_GetCardInfoEx ( HAND devHandle, TCardInfoEx *pInfo );

// 检查PCIe卡的驱动顺序是否正常
// instCardNum:返回系统安装的卡数量
// 返回0表示安装顺序正常，返回1表示不正常，通常为刚安装完驱动或者硬件有更改，重启windows即可
MTN_API Int16  __stdcall NMC_DevIndexCheck(int *instCardNum);

// 启动指令调试
// enable:0关闭调试信息,默认关闭,1:打开通讯的debug输出；2:打印到文件；3：打印输出到GCS;4:打印到DebugView
// debugOutputFile:调试输出文件，仅在enable=2时需要
MTN_API Int16  __stdcall NMC_SetCmdDebug( Int16 enable,char *debugOutputFile);

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

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

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

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

// 获取平台版本号
MTN_API Int16  __stdcall NMC_GetVersion( HAND devHandle, UInt8 *verArray );

// 获取控制器功能信息 example : char flags[1024];NMC_DevGetMcInfoFlag(g_hDev,flags);
MTN_API Int16 __stdcall NMC_DevGetMcInfoFlag(HAND devHandle,char *flags);

// 控制器状态
#define BIT_DEV_TERMINALBOARD_ONLINE            (0x00000001)        // bit 0  , 端子板通讯状态（PCIe卡），1：正常:,0：错误    
#define BIT_DEV_TERMINALBOARD_POWER                (0x00000002)        // bit 1  , 端子板供电是否正常（PCIe卡），1：正常:,0：错误    

// 获取控制器状态，按位表示
MTN_API Int16  __stdcall NMC_DevGetSts(HAND devHandle,  Int32 *sts);

// 获取指令的重试计数
// pRetryCnt:重试计数
MTN_API short __stdcall NMC_DevGetCmdRetryCnt(HAND devHandle, UInt32* pRetryCnt);
MTN_API short __stdcall NMC_DevSetCmdRetryCnt( HAND devHandle, UInt32 retryCnt);

//------------------------------------------------------------------------------------------------------------
//
//    2.单轴配置读写
//
//------------------------------------------------------------------------------------------------------------
// 获取轴规划模式
// pMode：返回轴运动模式
MTN_API Int16 __stdcall NMC_MtGetPrfMode(HAND axisHandle,Int16 *pMode);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// 设置螺距误差补偿参数,注意：调用前，必须先关闭螺距补偿
// num：补偿的段数,取值范围[2,128]
// startPos：补偿起始位置，终止位置为 startPos + cmpLen
// cmpLen:补偿长度
// pCompPos:正向补偿值
// pCompNeg:负向补偿值
MTN_API Int16  __stdcall NMC_MtSetLeadScrewCompPara(HAND axisHandle,Int16 num,
                        Int32 startPos,Int32 cmpLen,Int16 *pCompPos,Int16 *pCompNeg);

// 使能或禁止螺距位置补偿
MTN_API Int16 __stdcall NMC_MtEnableLeadScrew(HAND axisHandle, Int16 enable);

// 获取螺距位置补偿的状态
// pEnable:是否启用
// pCompDir:当前的补偿方向
// pCompVal:当前的补偿值
MTN_API short __stdcall NMC_MtGetLeadScrewSts(HAND axisHandle, short *pEnable,short *pCompDir,Int32 *pCompVal);

// 同步轴位置到编码器位置.
// flag:保留，写0
MTN_API Int16 __stdcall OEM_MtSyncAxisPosToEncPos(HAND axisHandle, Int16 flag);

// 设置反向间隙补偿
// compValue： 补偿量
// compDelta： 周期补偿量，比如补偿量为100，周期补偿量为10，则反向补偿会在10个规划周期完成100个脉冲的补偿
// compDir：     补偿方向,0:负向补偿，往负向运动时叠加补偿量，1：正向补偿，往正向运动时叠加补偿量
MTN_API Int16  __stdcall NMC_MtSetBacklash(HAND axisHandle, Int32 compValue,double compDelta,Int32 compDir);

// 获取反向间隙补偿
MTN_API Int16  __stdcall NMC_MtGetBacklash(HAND axisHandle,Int32 *pCompValue,double *pCompDelta,Int32 *pCompDir);

// 设置单轴急停DI
// gpiIndex：通用输入序号,[0,]，设置为-1，则表示取消急停DI
// sense :触发电平,0：低电平,1：高电平
MTN_API Int16 __stdcall NMC_MtSetEstopDI( HAND axisHandle, Int16 gpiIndex,Int16 sense);

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

// 设置单轴急停DI Mask,可以配置多个急停DI
// gpiMask：通用输出的位掩码
// senseMask :触发电平的位掩码，对应位,0：低电平,1：高电平
MTN_API Int16 __stdcall NMC_MtSetEstopDIMask( HAND axisHandle, Int32 gpiMask,Int32 senseMask);

// 设置单轴急停DI Mask,可以配置多个急停DI
// gpiMask：通用输出的位掩码
// senseMask :触发电平的位掩码，对应位,0：低电平,1：高电平
MTN_API Int16 __stdcall NMC_MtGetEstopDIMask( HAND axisHandle, Int32 *pGpiMask,Int32 *pSenseMask);

// 设置单轴急停DI 触发动作
// flag:标记  bit0:是否触发急停标记
MTN_API Int16 __stdcall NMC_MtSetEstopDIAction(HAND axisHandle, Int32 flag);
MTN_API Int16 __stdcall NMC_MtGetEstopDIAction(HAND axisHandle, Int32 *pFlag);

// 高级急停
#define ESTOP_DI_EX_CH_NUM                2   // 高级急停最大通道数量

typedef struct TEstopExParam
{
    Int16 axMask;            // 轴掩码
    Int16 diType;            // DI类型，0-通用输入，1-负限位，2-正限位，3-原点，4-Z相
    Int16 diIndex;            // 通道序号,[0,]
    Int16 filter;            // 滤波系数,取值范围[0,255]
    Int32 diSense;            // 触发电平,0：低电平,1：高电平
    Int32 reserved[3];        // 保留
    
    #ifdef MTN_ST_INIT_EN
    TEstopExParam(){
     axMask = 0;
     diType = 0;
     diIndex = 0;
     filter = 0;
     diSense = 0;
     reserved[0] = reserved[1] = reserved[2] = 0;
    }
    #endif
}TEstopExParam;

// 设置单轴急停DI,触发后会置起BIT_AXIS_ESTP标志位
// 注意:单轴高级急停触发后，规划位置与实际位置可能存在差值
// pParam:高级急停参数
// group:通道号，取值[0,ESTOP_DI_EX_CH_NUM-1]
MTN_API Int16 __stdcall NMC_SetEstopDIEx( HAND devHandle, TEstopExParam *pParam,Int16 group);

// 读取单轴急停DI
MTN_API Int16 __stdcall NMC_GetEstopDIEx( HAND devHandle, TEstopExParam *pParam,Int16 group);

// 缓冲区高级急停IO启动关闭
// onOff:1-启用高级急停IO，0-关闭高级急停IO
// group:通道号，取值[0,ESTOP_DI_EX_CH_NUM-1]
MTN_API Int16 __stdcall NMC_CrdBufEstopDIExOnOff( HAND crdHandle, Int32 segNo,Int16 onOff,Int16 group);

// 清除高级单轴急停DI
MTN_API Int16 __stdcall NMC_ClrEstopDIEx( HAND devHandle,Int16 group);

// 高级捕获通道数目
#define CAPT_EX_CH_NUM                6   // 

// 捕获源
#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 TAdvCaptureParam
{
    Int16 capPosIndex;    // 捕获的位置源序号,0~N：轴1~N+1。（默认0）注：捕获的编码器位置根据用户设置的编码器模式决定 
    
    Int16 trigSrc;        // 触发源,见上面的定义。（默认：CAPT_EX_SRC_GPI）
    Int16 trigIndex;    // 触发源序号。（默认0）
    Int16 filter;        // 滤波时间常数,单位0.1毫秒,取值范围[0,255]
    Int32  trigValue;    // 触发值,对于触发源为IO,表示信号触发的有效电平；对于触发源为位置,则表示触发捕获的位置。（默认0）
    
    #ifdef MTN_ST_INIT_EN
    TAdvCaptureParam(){
     capPosIndex = 0;
     trigSrc = 0;
     trigIndex = 0;
     filter = 0;
      trigValue = 0;
    }
    #endif
}TAdvCaptureParam;

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

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

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

// 设置轴补偿参数
// enable: 0:取消 1：使能
// para1: 参数1，数值范围在（10~500）,建议先从大到小进行设置测试
// para2: 参数2，数值为控制频率HZ
MTN_API Int16  __stdcall  NMC_MtSetAxisDampCompParam(HAND axisHandle,Int16 enable,Int16 param1,Int16 param2);

// 设置越限报警的动作
// actionsBits:轴越限报警后的处理方法，按位表示，默认为0，即只置起轴超限标志位
//        bit0:关闭使能
//        bit1:停止轴运动
//        其他保留
MTN_API Int16  __stdcall NMC_MtSetPosErrAction( HAND axisHandle,Int16 actionsBits);

// 读取越限报警的动作
MTN_API Int16  __stdcall NMC_MtGetPosErrAction( HAND axisHandle,Int16 *pActionsBits);

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

// 坐标系运动：扩展参数
typedef struct TExtCrdPara
{
    double startVel;                    //起跳速度（默认0）
    double T;                            //前瞻时间常数,越大则速度变化越小 (默认1)
    double smoothDec;                    //停止减速度（默认accMax）
    double abruptDec;                    //急停减速度（默认无穷大）
    Int16  lookAheadSwitch;                //前瞻启动开关,0:不需要前瞻，1:使用下位机前瞻，[2,n]：使用上位机前瞻，数值为前瞻段数缓存段数,推荐
    Int16 eventTime;                    // 最小的匀速段时间,单位ms,(默认为10)
    Int16 reserved[2];
    
    #ifdef MTN_ST_INIT_EN
    TExtCrdPara(){
        startVel = 0;
        T = 0.01;
        smoothDec = 0.5;
        abruptDec = 1000;
        lookAheadSwitch = 100;
        eventTime = 10;
        reserved[0] = reserved[1] = 0;
    }
    #endif
}TExtCrdPara;

// 设置坐标系扩展参数 
// extCrdPara:坐标系扩展参数,参考坐标系运动：扩展参数’TExtCrdPara结构体定义
MTN_API Int16 __stdcall NMC_CrdSetExtPara( HAND crdHandle, TExtCrdPara *extCrdPara);

typedef struct TLookaheadPara
{
    Int16 lookAheadSwitch;            // 前瞻功能控制，0:不需要前瞻，1:使用下位机前瞻，[2,n]：使用上位机前瞻，数值为前瞻段数缓存段数
    Int16 centAccEn;                // 是否使用指定的向心加速度，默认为0，即不使用
    Int16 crossEn;                    // 短线段合并开关,0:关闭合并；1：启用合并
    Int16 eventTime;                // 最小的匀速段时间,单位ms,(默认为10)

    double accMax;                    // 机台允许的最大加速度,默认1000
    double T;                        // 前瞻时间常数,越大则速度变化越小 (默认1)
    double slowAng;                    // 减速角度,小于设定角度，则不减速
    double stopAng;                    // 停止角度，大于设定角度，则减速为0
    double crossProp;                // 短线段合并粒度，取值范围(0,n],数值越大，则合并越夸张    
    double centAcc;                    // 向心加速度
    double dvMax[CRD_MAX_DIMENSION];// 单轴允许的速度变化量，单位:用户单位/时间单位
    double daMax[CRD_MAX_DIMENSION];// 单轴允许的最大加速度
    double radiusCoef;                // 曲率系数，系数越大，则同曲率曲线内的速度越大，默认值1.5，为0表示取消曲率计算
    double radiusErr;                // 曲率误差，默认值200,请根据实际误差要求配置，单位:用户单位
    double radiusAngMax;            // 曲率角度最大值，默认值7
    double radiusAngMin;            // 曲率角度最小值，默认值0.5

    Int16 preHandleEn;                // 轨迹预处理功能开关
    Int16 axPropTimeUnitProp;        // 当启用axProp时，速度及加速度使用的时间单位
                                        // 0:不启用传动比功能
                                        // 1:秒，即速度单位为‘用户单位/秒’，加速度单位为‘用户单位/秒平方’
                                        // 2:毫秒，即速度单位为‘用户单位/毫秒’，加速度单位为‘用户单位/毫秒平方’
    F32 preHandleDisAngMin;        // 轨迹预处理最小角度，保留尖角
    F32 preHandleDisAngMax;        // 轨迹预处理最大角度
    F32 preHandleTol;                // 预处理误差，单位:用户单位
    F32 axProp[CRD_MAX_DIMENSION];// 各轴传动比,即用户单位转为脉冲单位系数
    F32 minCornerVel;                // 最小的拐角速度
    Int32 radiusMaxLen;             // 曲率:曲率计算的最大轨迹长度，大于该值则不进行曲率计算
    Int32 reserved1[2];                // 保留
    double reserved2[8];            // 保留

    
    #ifdef MTN_ST_INIT_EN
    TLookaheadPara(){
        lookAheadSwitch = 100;
        centAccEn = 0;
        crossEn = 0;
        eventTime = 0;
        accMax = 1000;
        T = 0.01;
        slowAng = 5;
        stopAng = 170;
        crossProp = 0;
        centAcc = 0;
        dvMax[0] = dvMax[1] = dvMax[2] = dvMax[3] = 500;
        daMax[0] = daMax[1] = daMax[2] = daMax[3] = 500;
        radiusCoef = 0;
        radiusErr = 20;
        radiusAngMax = 7;
        radiusAngMin = 0.5f;
        radiusMaxLen = 1000;
        preHandleEn = 0;
        axPropTimeUnitProp = 0;
        preHandleDisAngMin = 5;
        preHandleDisAngMax = 170;
        preHandleTol = 10;
        axProp[0] = axProp[1] = axProp[2] = axProp[3] = 1;
        minCornerVel = 2;
        reserved1[0] = reserved1[1] = reserved1[2] = 0;
        memset(reserved2,0,sizeof(double)*8);
    }
    #endif
}TLookaheadPara;

// 设置前瞻参数
// lkhPara:前瞻相关的参数,注意：前瞻模块预留参数请务必初始化为0
MTN_API Int16 __stdcall NMC_CrdSetLookaheadPara( HAND crdHandle, TLookaheadPara *lkhPara);

// 更新前瞻参数
// lkhPara:前瞻相关的参数,注意：前瞻模块预留参数请务必初始化为0
MTN_API Int16 __stdcall NMC_CrdBufUpdateLookaheadPara(HAND crdHandle, Int32 segNo,TLookaheadPara* lkhPara);

// 设置对应group的前瞻参数
// group:组号，取值范围[0,255],注意重新建立坐标系会清除全部的前瞻参数
// 说明: NMC_CrdSetLookaheadPara设置的是第一组的前瞻参数，默认始终使用第一组参数
MTN_API Int16 __stdcall NMC_CrdSetLookaheadParaGroup(HAND crdHandle, TLookaheadPara* lkhPara,Int16 group);

// 缓冲区更新当前使用的前瞻参数
MTN_API Int16 __stdcall NMC_CrdBufUpdateLookaheadParaGroup(HAND crdHandle, Int32 segNo, Int16 group);

// 设置坐标系的起跳速度
// startVel:起跳速度
MTN_API Int16 __stdcall NMC_CrdSetStartVel( HAND crdHandle, double startVel);

// 获取当前缓冲区指令的当前终点位置
// pTgtPos:终点位置，须定义为四维数组指针
MTN_API Int16 __stdcall NMC_CrdGetBufEndPos(HAND crdHandle, double *pTgtPos);

// 四轴直线插补,使用双精度脉冲单位
// segNo:段号；
// endVel:终点速度;vel:最大速度,单位:pulse/ms
// synAcc:合成加速度,单位:pulse/ms*ms
// crdAxMask:参与的轴,按位表示
// pTgPosArray：目标位置数组,单位:pulse
// lookaheadDis:是否使用前瞻,0：使用前瞻,则控制器自动计算终点速度,1：禁用前瞻,使用设定的终点速度（endVel）
MTN_API Int16 __stdcall NMC_CrdLineDbXYZA(  HAND crdHandle,  Int32 segNo, Int16 mask,
                            double *pTgPosArray, double endVel, double vel,double synAcc ,Int16 lookaheadDis);

// 四轴执行插补，走相对位置，注意：仅支持上位机前瞻
MTN_API short __stdcall NMC_CrdLineDbXYZARel(HAND crdHandle, Int32 segNo, short mask,
    double* pTgPosArrayRel, double endVel, double vel, double synAcc, short lookaheadDis);

// 获取前瞻参数
// lkhPara:前瞻相关的参数
// defaultFlag:1表示获取默认值，0表示获取当前值
MTN_API Int16 __stdcall NMC_CrdGetLookaheadPara( HAND crdHandle, TLookaheadPara *lkhPara,Int16 defaultFlag);

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

// 读取坐标系扩展参数
// extCrdPara:坐标系扩展参数
MTN_API Int16 __stdcall NMC_CrdGetExtPara( HAND crdHandle, TExtCrdPara *extCrdPara);
 
// 坐标系运动：圆弧插补配置
#define MAX_ERR_TABLE_SECTION    2
typedef struct TArcSecSetting
{
    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

    
    #ifdef MTN_ST_INIT_EN
    TArcSecSetting(){
     minSectionLen = 1;
     maxArcDiff = 10;
     r[0] = 100;
     r[1] = 10000;
     err[0] = 5;
     err[1] = 10;
     err[2] = 20;
    }
    #endif
}TArcSecSetting;
// 设置圆弧插补参数（高级指令）
// pSetting : 设置
MTN_API Int16 __stdcall NMC_CrdSetArcSecPara( HAND crdHandle,  TArcSecSetting *pSetting);
                                          
// 读圆弧插补参数（高级指令）
MTN_API Int16 __stdcall NMC_CrdGetArcSecPara( HAND crdHandle,  TArcSecSetting *pSetting);

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

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

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

// 获取坐标系速度倍率
// overRide：坐标系速度倍率
MTN_API Int16 __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缓冲区计算错误  
#define BIT_CORD_SCARA_CALC_ERR (0x00000800)    // bit 11 , SCARA计算数据错误
#define BIT_CORD_CHECKSUM        (0x00001000)    // bit 12 , 校验和出错
#define BIT_CORD_POP_CMD        (0x00002000)    // bit 13 , 校验和出错
// 读取内部坐标系状态
// pStsWord：返回状态字,定义64bits(二维的long数组),便于后续扩展状态位
MTN_API Int16 __stdcall NMC_CrdGetInnerSts     ( HAND crdHandle, Int32 *pStsWord );

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

// 缓冲区设置急停DI
// axis:轴号,取值范围[0,n)
// gpiIndex:通用输入序号
// sense:触发电平
MTN_API Int16  __stdcall NMC_CrdBufSetEstopDI ( HAND crdHandle,Int32 segNo,Int16 axis,Int16 gpiIndex,Int16 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_LASER_SETPOWER        8    // 激光：设置能量
#define BUF_LASER_ONOFF            9    // 激光：缓冲区开关光
#define BUF_LASER_SETFOLLOW        10    // 激光：设置跟随
#define BUF_LASER_SETPARAM        11    // 激光：设置参数
#define BUF_LINEXYZA            12    // 缓冲区四轴直线插补
#define BUF_SHIO_GATEPULSE        13    // 缓冲区输出Gate脉冲
#define BUF_DOBITPULSE            14    // DoBitPulse功能
#define BUF_XYZD8                  15    // LineXYZD8,数据结构体为：TCrdLineXYZD8Unit
#define BUF_SHIOMINFRQ             16    // 设置或清除SHIO最小频率
#define BUF_SHIOSETPARAM        17    // 设置SHIO参数
#define BUF_SHIOGATEONOFF       18    // 设置Gate开关
#define BUF_WAITENCINPOS        19    // 等待电机到位
#define BUF_WAITDI              20    // 等待DI
#define BUF_LASER_SETBIAS       21    // 缓存区设置激光bias
#define BUF_LINEDBXYZA            22    // 双精度直线插补
#define BUF_AXSTOP                23    // 缓冲区停止运动

#pragma pack(push)
#pragma pack(4)
typedef struct TCrdBufLine
{  
    Int32 segNo;        // 用户自定义段号
    Int32 tgPos[3];     // 目标位置
    double endVel;     // 终点速度
    double vel;        // 最大速度
    double synAcc;     // 插补加速度
    Int16 mask;        // crdAxMask,参与的插补轴,按位表示
    Int16 lookaheadDis;//是否使用前瞻
    Int32  reserved;     // 保留
    
    #ifdef MTN_ST_INIT_EN
    TCrdBufLine(){
     segNo = 0;
     tgPos[0] = tgPos[1] = tgPos[2] = 0;
     endVel = 0;
     vel = 0;
     synAcc = 0;
     mask = 0;
     lookaheadDis = 0;
     reserved = 0;
    }
    #endif
}TCrdBufLine;

typedef struct TCrdBufLineXYZA
{  
    Int32 tgPos[4];     // 目标位置
    double endVel;     // 终点速度
    double vel;        // 最大速度
    double synAcc;     // 插补加速度
    Int32 segNo;        // 用户自定义段号
    Int16 mask;        // crdAxMask,参与的插补轴,按位表示
    Int16 lookaheadDis;//是否使用前瞻
    
    #ifdef MTN_ST_INIT_EN
    TCrdBufLineXYZA(){
     tgPos[0] = tgPos[1] = tgPos[2] = tgPos[3] = 0;
     endVel = 0;
     vel = 0;
     synAcc = 0;
     segNo = 0;
     mask = 0;
     lookaheadDis = 0;
    }
    #endif
}TCrdBufLineXYZA;

typedef struct TCrdBufOut
{
    Int32 segNo;     // 用户自定义段号
    Int16 group;    // Out输出类型 
    Int16 ch;       // 通道号,取值范围[0,n]
    Int32 outValue;    // 输出
    
    #ifdef MTN_ST_INIT_EN
    TCrdBufOut(){
     segNo = 0;
     group = 0;
     ch = 0;
     outValue = 0;
    }
    #endif
}TCrdBufOut;

typedef struct TCrdBufDO
{
    Int32 segNo;     // 用户自定义段号
    Int16 group;    // 缓冲区输出DO组 
    Int16 ch;       // 位序号,取值范围[0,31]
    Int32 value;     // 输出值,取值范围[0,1]
    
    #ifdef MTN_ST_INIT_EN
    TCrdBufDO(){
     segNo = 0;
     group = 0;
     ch = 0;
     value = 0;
    }
    #endif
}TCrdBufDO;

typedef struct TCrdBufDelay
{
    Int32 segNo;     // 用户自定义段号
    Int32 scale;     // 延时单位,0表示单位为毫秒,1表示单位为秒
    Int32 count;     // 延时时长
    
    #ifdef MTN_ST_INIT_EN
    TCrdBufDelay(){
     segNo = 0;
     scale = 0;
     count = 0;
    }
    #endif
}TCrdBufDelay;

typedef struct TCrdBufDOEx
{
    Int32 segNo;     // 用户自定义段号
    Int32 group;    // 缓冲区输出DO组
    Int32 doMask;    // 输出操作位,bit位为1表示要输出
    Int32 value;     // 输出值,bit位指示输出值
    
    #ifdef MTN_ST_INIT_EN
    TCrdBufDOEx(){
     segNo = 0;
     group = 0;
     doMask = 0;
     value = 0;
    }
    #endif
}TCrdBufDOEx;

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

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

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

typedef struct TCrdBufLaserSetFollow
{  
    Int32 segNo;        // 用户自定义段号
    Int16 followType;    // 跟随类型
    Int16 ch;            // 激光通道号
    double overRide;     // 跟随倍率
    
    #ifdef MTN_ST_INIT_EN
    TCrdBufLaserSetFollow(){
     segNo = 0;
     followType = 0;
     ch = 0;
     overRide = 0;
    }
    #endif
}TCrdBufLaserSetFollow;

typedef struct TCrdBufLaserOnOff
{  
    Int32 segNo;        // 用户自定义段号
    Int16 onOff;        // 开关,0：关光,1：开光
    Int16 ch;            // 激光通道号
    
    #ifdef MTN_ST_INIT_EN
    TCrdBufLaserOnOff(){
     segNo = 0;
     onOff = 0;
     ch = 0;
    }
    #endif
}TCrdBufLaserOnOff;

typedef struct TCrdBufLaserSetPower
{  
    Int32 segNo;        // 用户自定义段号
    Int16 ch;            // 激光通道号
    Int16 reserved;        // 保留
    double power;        // 能量
    
    #ifdef MTN_ST_INIT_EN
    TCrdBufLaserSetPower(){
     segNo = 0;
     ch = 0;
     reserved = 0;
     power = 0;
    }
    #endif
}TCrdBufLaserSetPower;

typedef struct TCrdBufSHIOGatePulse
{  
    Int32 segNo;        // 用户自定义段号
    Int32 outCount;        // 输出个数
    double gateTime;    // gate输出的脉宽，单位：微秒
    double gateFrq;        // gate输出的频率，单位：HZ
    Int16 ch;            // ch:通道
    Int16 reserved[3];  // 保留
    
    #ifdef MTN_ST_INIT_EN
    TCrdBufSHIOGatePulse(){
     segNo = 0;
     outCount = 0;
     gateTime = 0;
     gateFrq = 0;
     ch = 0;
     reserved[0] = reserved[1] = reserved[2] =0;
    }
    #endif
}TCrdBufSHIOGatePulse;


typedef struct TCrdBufDoBitPulse
{  
    Int32 segNo;            // 用户自定义段号
    Int32 highLevelTime;    // 高电平宽度，单位:us
    Int32 lowLevelTime;    // 低电平宽度，单位:us
    Int32 outCount;        // 输出脉冲个数
    Int32 initialLevel;    // 0：先输出低电平，1：先输出高电平
    Int16 ch;            // ch:通道
    Int16 enable;        // 1:使能,0:关闭
    Int16 doType;        // DO类型,默认CRD_BUFF_DO_GPDO1
    Int16 doIndex;        // DO序号，取值范围[0,n]
    
    #ifdef MTN_ST_INIT_EN
    TCrdBufDoBitPulse(){
     segNo = 0;
     highLevelTime = 0;
     lowLevelTime = 0;
     outCount = 0;
     initialLevel = 0;
     ch = 0;
     enable = 0;
     doType = 0;
     doIndex = 0;
    }
    #endif
}TCrdBufDoBitPulse;

typedef struct TCrdBufSHIOMinFrq
{  
    Int32 segNo;            // 用户自定义段号
    Int32 minFrq;        // 最小频率，仅当enable=1时有效
    Int16 ch;            // 通道
    Int16 setOrClr;        // 1:设置,0:清除
    
    #ifdef MTN_ST_INIT_EN
    TCrdBufSHIOMinFrq(){
     segNo = 0;
     minFrq = 0;
     ch = 0;
     setOrClr = 0;
    }
    #endif
}TCrdBufSHIOMinFrq;

typedef struct TCrdBufSHIOSetParam
{  
    Int32 segNo;            // 用户自定义段号
    Int16 ch;            // 通道
    Int16 reserved;        // 保留
    double delay;       // 延时开关光时间
    double gateTime;    // gate打开时间，单位:秒
    double gateDistance;// 固定模式下的位置间隔，单位pulse
    
    #ifdef MTN_ST_INIT_EN
    TCrdBufSHIOSetParam(){
     segNo = 0;
     ch = 0;
     reserved = 0;
     delay = 0;
     gateTime = 0;
     gateDistance = 0;
    }
    #endif
}TCrdBufSHIOSetParam;

typedef struct TCrdBufSHIOGateOnOff
{  
    Int32 segNo;            // 用户自定义段号
    Int16 ch;            // 通道
    Int16 onOff;        // 1:打开，0：关闭
    
    #ifdef MTN_ST_INIT_EN
    TCrdBufSHIOGateOnOff(){
     segNo = 0;
     ch = 0;
     onOff = 0;
    }
    #endif
}TCrdBufSHIOGateOnOff;

typedef struct TCrdBufWaitEncInPosition
{  
    Int32 segNo;            // 用户自定义段号
    Int32 axisMask;        // 轴掩码
    Int32 overTime;        // 等待超时时间，单位：毫秒
    
    #ifdef MTN_ST_INIT_EN
    TCrdBufWaitEncInPosition(){
     segNo = 0;
     axisMask = 0;
     overTime = 0;
    }
    #endif
}TCrdBufWaitEncInPosition;

typedef struct TCrdBufWaitDI
{  
    Int32 segNo;            // 用户自定义段号
    Int16 index;        // 通道号,取值范围[0,127],前64通道代表通用DI，后64通道代表扩展IO
    Int16 level;        // 等待值
    Int32 waitLastTime;  // 超时,单位：毫秒
    
    #ifdef MTN_ST_INIT_EN
    TCrdBufWaitDI(){
     segNo = 0;
     index = 0;
     level = 0;
     waitLastTime = 0;
    }
    #endif
}TCrdBufWaitDI;

typedef struct TCrdBufLaserSetBias
{  
    Int32 segNo;            // 用户自定义段号
    Int16 biasType;        // bias类型
    Int16 ch;            // 激光通道号
    double bias;        // bias
    
    #ifdef MTN_ST_INIT_EN
    TCrdBufLaserSetBias(){
     segNo = 0;
     biasType = 0;
     ch = 0;
     bias = 0;
    }
    #endif
}TCrdBufLaserSetBias;

typedef struct TCrdBufLineDbXYZA
{  
    double tgPos[4];    // 目标位置
    double endVel;     // 终点速度
    double vel;        // 最大速度
    double synAcc;     // 插补加速度
    Int32 segNo;        // 用户自定义段号
    Int16 mask;        // crdAxMask,参与的插补轴,按位表示
    Int16 lookaheadDis;//是否使用前瞻
    
    #ifdef MTN_ST_INIT_EN
    TCrdBufLineDbXYZA(){
     tgPos[0] = tgPos[1] = tgPos[2] = tgPos[3] =0;
     endVel = 0;
     vel = 0;
     synAcc = 0;
     segNo = 0;
     mask = 0;
     lookaheadDis = 0;
    }
    #endif
}TCrdBufLineDbXYZA;

typedef struct TCrdBufAxStop
{  
    Int32 segNo;        // 用户自定义段号
    Int32 axMask;        // 轴掩码
    Int32 flag;            //保留
    
    #ifdef MTN_ST_INIT_EN
    TCrdBufAxStop(){
     segNo = 0;
     axMask = 0;
     flag = 0;
    }
    #endif
}TCrdBufAxStop;

#pragma pack(pop)

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

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

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

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

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

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

MTN_API Int16  __stdcall NMC_CrdSetLookAheadCentriAcc(HAND crdHandle,Int16 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相触发 捕获 
#define CAPT_MODE_EX         3   // 扩展捕获模式

// 编码器硬件捕获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 


// 扩展捕获模式IO源选择 ，在CAPT_MODE_EX模式时，捕获的IO源选择
#define CAPT_HSIO0_OUT0    0   // 0通道位置比较out0信号
#define CAPT_HSIO0_OUT1    1   // 0通道位置比较out1信号
#define CAPT_HSIO1_OUT0    2   // 1通道位置比较out0信号
#define CAPT_HSIO1_OUT1    3   // 1通道位置比较out1信号
#define CAPT_HSIO2_OUT0    4   // 2通道位置比较out0信号
#define CAPT_HSIO2_OUT1    5   // 2通道位置比较out1信号
#define CAPT_HSIO3_OUT0    6   // 3通道位置比较out0信号
#define CAPT_HSIO3_OUT1    7   // 3通道位置比较out1信号 

// 设置捕获有效电平
// mode : 模式选择,参考宏定义
// ioSrc：IO输入源选择,参考宏定义
// level: 触发沿。bit0:index电平（0为下降沿,1为上升沿）,bit1:IO电平
MTN_API Int16  __stdcall NMC_MtSetCaptSns( HAND axisHandle, Int16 mode, Int16 ioSrc, Int16 level );

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

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

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

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

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

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

// 多轴同时启动
// axisHandle:起始轴号
// axisMask：按bit对应相应轴号,bit为1表示启动,bit为0表示不启动
MTN_API Int16 __stdcall NMC_MtUpdateMultiEx( HAND axisHandle,Int32 axisMask );

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

// 多轴同时停止 Ex
// axisHandle:起始轴号
// axisMask：按bit对应相应轴号,bit为1表示启动,bit为0表示不启动
MTN_API Int16 __stdcall NMC_MtStopMultiEx( HAND axisHandle,Int32 axisMask  );

// 多轴同时启动
// axisHandle:任意轴号
// axCnt：轴列表，取值范围[1,64]
// pAxList:轴列表，取值范围[0,n]
MTN_API Int16 __stdcall NMC_MtUpdateList(HAND axisHandle, Int16 axCnt,UInt8 *pAxList);

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

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

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

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

// DO输出持续设定时间后翻转
// bitIndex:取值范围[0,n],位序号,前64位为本地的通用输出,大于64为扩展Do
// value:设置通用数字量输出。1, 输出高电平,0,输出低电平
// reverseTime:持续的电平,单位:毫秒
MTN_API Int16  __stdcall NMC_SetDOBitAutoReverse(HAND devHandle,Int16 bitIndex,Int16 value,Int16 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 TDioMappingCfg
{
    UInt8  enable;        // 1：启用，0：禁用
    UInt8  pinGrp;      // 映射的信号类型
    UInt8  pinIndex;    // 映射的信号序号
    UInt8  outEnable;    // 输出允许       
    UInt8  newGrp;      // 映射到的信号类型
    UInt8  newIndex;    // 映射到的信号序号
    
    #ifdef MTN_ST_INIT_EN
    TDioMappingCfg(){
      enable = 0;
      pinGrp = 0;
      pinIndex = 0;
      outEnable = 0;
      newGrp = 0;
      newIndex = 0;
    }
    #endif
}TDioMappingCfg;

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

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

// 清除所有的DIO映射关系
MTN_API Int16  __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
#define     VAR_INNNER_VAR1    1000
#define     VAR_INNNER_VAR2    1001
#define     VAR_INNNER_VAR3    1002
#define     VAR_INNNER_VAR4    1003
#define     VAR_INNNER_VAR5    1004
#define     VAR_INNNER_VAR6    1005
#define     VAR_INNNER_VAR7    1006
#define     VAR_INNNER_VAR8    1007
#define        VAR_ECAT_LOCAL_AX_NUM        10000
#define        VAR_ECAT_BUS_AX_NUM            10001
// 设置通用可寻址变量 8字节数据类型（可涵盖常用的类似,如：char/short/long/double 等）
MTN_API Int16 __stdcall NMC_SetVar8B( HAND devHandle, Int32 varID, Int64 value );

// 读取通用可寻址变量 8字节数据类型（可涵盖常用的类似,如：char/short/long/double 等）
MTN_API Int16 __stdcall NMC_GetVar8B( HAND devHandle, Int32 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 Int16 __stdcall NMC_SysSetVar8B( HAND devHandle, Int32 varID, Int64 value );

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

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

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

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


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

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

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

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

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

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

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

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

// 读扩展用户参数
// add ：参数区的偏移地址(字节地址)
// len : 写入长度,单位：byte
// pRdData ：要读取的数据存储
// 注：一次最多读1000字节。参数区总长度为32K字节。（参考函数 ： NMC_UserParaWr）
MTN_API Int16  __stdcall NMC_UserParaRdEx( HAND devHandle, UInt32 add, UInt32 len, UInt8 *pRdData );


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

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

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

// 读取当前自动备份的开启状态
// pEn:当前的开启状态
MTN_API Int16 __stdcall NMC_GetBackedVarOnOff( HAND devHandle, Int16 *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        // 参数保存
// 读取系统参数（Int32 型）
// paraID :　系统参数ID,参见后面定义。pValue : 返回值
// 注：此函数可用于设置板卡上的扩展资源
MTN_API Int16  __stdcall NMC_DevGetPara( HAND devHandle, UInt32 paraID, Int32 *pValue );

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

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

// 用户登陆,注意：NMC_DevReset将复位登录状态
// pUserName    : 指定的用户名,目前只支持"USER1"
// pPassword    : 该用户的密码
MTN_API Int16  __stdcall NMC_UserLogin( HAND devHandle, char *pUserName,char *pPassword);

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

// 设置控制器的规划周期，默认1000
// period：单位us    只能为250 500 1000
// 注意：1.规划周期设置后立即生效，只能在控制器启动时配置
//       2.NMC_DevReset会复位规划周期为默认值
MTN_API Int16 __stdcall NMC_SetProfilePeriod(HAND devHandle,Int16 period);

// 获取控制器的规划周期
// period：单位us    只能为250 500 1000
MTN_API Int16 __stdcall NMC_GetProfilePeriod(HAND devHandle,Int16 *pPeriod);

// 打印信息
MTN_API Int16 __stdcall NMC_UserPrint(char *msg);

// 获取输出信息
MTN_API Int16 __stdcall NMC_DevGetOutputMsg(HAND devHandle,char *szBuf,Int16 maxLen,Int16 *pGetLen);

//------------------------------------------------------------------------------------------------------------
//
//    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信号状态
#define COLLECT_ADDRESS_LASER_POWER            (13)// 激光能量当前输出值
#define COLLECT_ADDRESS_DI                  (14)// 数字量输入状态
#define COLLECT_ADDRESS_DO                  (15)// 数字量输出状态
#define COLLECT_ADDRESS_CRD_USERSEG            (16)// 坐标系用户段号
#define COLLECT_ADDRESS_DAC                    (17)// 模拟量输出
#define COLLECT_ADDRESS_ADC                    (18)// 模拟量输入
#define COLLECT_ADDRESS_AXISSTS                (19)// 轴状态
#define COLLECT_ADDRESS_PRF_ACC                (20)// 规划加速度
#define COLLECT_ADDRESS_POS_ERR                (21)// 位置误差
#define COLLECT_ADDRESS_CRD_STS                (22)// 坐标系状态
#define COLLECT_ADDRESS_INNER_VAR            (23)// 内部变量
#define COLLECT_ADDRESS_DBG_VAR                (24)// 调试变量
#define COLLECT_ADDRESS_MIO                    (25)// 轴专用信号

// 获取需要采集数据变量的地址，函数无意义，数据地址及长度无须通过函数获取
//  index:变量的序号(从0开始)
//  type: 变量的类型,参数‘Collect模块：变量类型’宏定义
//  pAddr: 返回的数据地址
// pDataLen: 返回的该数据长度
MTN_API Int16  __stdcall NMC_GetCollectDataAddr( HAND devHandle, Int16 index,Int16 dataType,UInt32 *pAddr, Int16 *pDataLen);

// 采集模块：采集配置
#define COLLECT_LIST_MAX        (8)             //每组最多采集8个数据
typedef struct TCollectCfg
{
    Int16  count;                                // 需要采集的变量个数
    Int16  interval;                            // 采集的间隔时间,0表示每隔1个周期采集一次数据,1表示每隔2个周期...
    UInt32  address[COLLECT_LIST_MAX];            // 变量的地址
    Int16  length[COLLECT_LIST_MAX];            // 每个变量的长度（单位：char），即数据序号
    
    #ifdef MTN_ST_INIT_EN
    TCollectCfg(){
      count = 0;
      interval = 0;
      memset(address,0,sizeof(UInt32)*COLLECT_LIST_MAX);
      memset(length,0,sizeof(Int16)*COLLECT_LIST_MAX);
    }
    #endif
}TCollectCfg;

// 采集模块：采集配置
#define COLLECT_EX_LIST_MAX        (16)             //每组最多采集8个数据
typedef struct TCollectCfgEx
{
    Int16  count;                                // 需要采集的变量个数
    Int16  interval;                            // 采集的间隔时间,0表示每隔1个周期采集一次数据,1表示每隔2个周期...
    UInt32  address[COLLECT_EX_LIST_MAX];            // 变量的地址
    Int16  length[COLLECT_EX_LIST_MAX];            // 每个变量的长度（单位：char），即数据序号

#ifdef MTN_ST_INIT_EN
    TCollectCfgEx() {
        count = 0;
        interval = 0;
        memset(address, 0, sizeof(UInt32) * COLLECT_EX_LIST_MAX);
        memset(length, 0, sizeof(Int16) * COLLECT_EX_LIST_MAX);
    }
#endif
}TCollectCfgEx;

// 采集模块：触发模式
#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两项差值大于比较值
#define COLLECT_MODE_AND    4    // 采集源1按位与比较值不为0（仅限整数变量，32bit整形处理）
#define COLLECT_MODE_AND0    5    // 采集源1按位与比较值为0（仅限整数变量）
#define COLLECT_MODE_OR        6    // 采集源1按位或比较值不为0（仅限整数变量）
#define COLLECT_MODE_OR0    7    // 采集源1按位或比较值为0（仅限整数变量）

typedef struct TCollectTrig
{
    Int16  mode;                                // 触发模式,
    Int16  source1;                                // 触发源1,保留，无意义
    Int16  source2;                                // 触发源2,保留，无意义
    Int16  startDelay;                            // 触发启动的延时
    double  value;                                // 触发比较值
    
    #ifdef MTN_ST_INIT_EN
    TCollectTrig(){
      mode = 0;
      source1 = 0;
      source2 = 0;
      startDelay = 0;
      value = 0;
    }
    #endif
}TCollectTrig;

typedef struct TCollectTrigEx
{
    Int16  mode;                                // 触发模式,
    Int16  source1;                                // 触发源1,保留，无意义
    Int16  source2;                                // 触发源2,保留，无意义
    Int16  startDelay;                            // 触发启动的延时
    double  value;                                // 触发比较值
    Int32 reserved[16];

#ifdef MTN_ST_INIT_EN
    TCollectTrigEx() {
        mode = 0;
        source1 = 0;
        source2 = 0;
        startDelay = 0;
        value = 0;
        memset(reserved, 0, sizeof(Int32) * 16);
    }
#endif
}TCollectTrigEx;

// 配置采集数据通道,需要配置对应结构体参数
// pCollect:采集模块配置
// pTrig:采集模块触发方式配置
MTN_API Int16  __stdcall NMC_ConfigCollect( HAND devHandle, TCollectCfg *pCollect,TCollectTrig *pTrig );
MTN_API Int16  __stdcall NMC_ConfigCollectEx(HAND devHandle, TCollectCfgEx* pCollect, TCollectTrigEx* pTrig);

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

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

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

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

typedef struct TCollectDbgVarMap
{
    Int16  varType;                                // 变量类型，参考MC_VAR_xxx定义
    Int16  varPrm1;                                // 变量参数1
    Int16  varPrm2;                                // 变量参数2
    Int16  varPrm3;                                // 变量参数3
    Int16  varPrm4;                                // 变量参数4
    Int16  varPrm5;                                // 变量参数5
    Int16 reserved[2];
    double prop;                                   // 原始变量系数，采集到的数值为原始变量乘以系数得到最终变量

#ifdef MTN_ST_INIT_EN
    TCollectDbgVarMap() {
        varType = 0;
        varPrm1 = varPrm2 = varPrm3 = varPrm4 = varPrm5 = 0;
        reserved[0] = reserved[1] = 0;
        prop = 1;
    }
#endif
}TCollectDbgVarMap;

// 设置采集调试变量映射参数
// pDbgVarMapParam:映射参数定义
//     MC_VAR_MtPrfPos：varPrm1表示轴号  
//     MC_VAR_Slv32Bit/MC_VAR_Slv16Bit：varPrm1表示从站地址，varPrm2表示变量Offset
// varIdx:映射到的变量索引，取值范围[0,15]
MTN_API Int16  __stdcall NMC_CollectSetDbgVarMap(HAND devHandle, TCollectDbgVarMap* pDbgVarMapParam, Int16 varIdx);
MTN_API Int16  __stdcall NMC_CollectGetDbgVarMap(HAND devHandle, TCollectDbgVarMap *pDbgVarMapParam,Int16 varIdx);

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

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

//设置激光控制的模式。该模式的设定,约束相应指令的功能和操作
//mode: 激光控制模式,参考上述宏定义
MTN_API Int16  __stdcall NMC_LaserSetMode  (HAND devHandle, Int16 mode, Int16 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 Int16  __stdcall NMC_LaserSetOutputType ( HAND devHandle,Int16 outputType,Int16 index,Int32 optionVal,Int16 ch);

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

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

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

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

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

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

// 激光开关控制参数
typedef struct TLaserOnOffCtrlParam
{
    Int16 mode;                 // 模式:0:默认 基本模式,1:精确位置模式
    Int16 modePrm1;             // 参数1，精确位置模式：表示控制的容差
    Int16 reserved[14];         // 保留参数，请写为0


#ifdef MTN_ST_INIT_EN
    TLaserOnOffCtrlParam() {
        mode = 0;
        modePrm1 = 10;
        for (int i = 0; i < 14; i++) { reserved[i] = 0; }
    }
#endif
}TLaserOnOffCtrlParam;
// 激光的开关光控制参数设置
// crdHandle:坐标系句柄
MTN_API Int16  __stdcall NMC_LaserSetOnOffCtrlParam(HAND crdHandle, TLaserOnOffCtrlParam *pCtrlParam, Int16 ch);
MTN_API Int16  __stdcall NMC_LaserGetOnOffCtrlParam(HAND crdHandle, TLaserOnOffCtrlParam* pCtrlParam, Int16 ch);



// 设置激光参数
// onDelay:开光延时,单位us,取值范围[0,65535]
// offDelay:关光延时,单位us,取值范围[0,65535]
// minValue:最小输出值,取值范围[0,32767]
// maxValue:最大输出值,取值范围[0,32767]
// standbyPower:待机能量,为0表示取消待机能量输出功能
// ch:激光控制通道
MTN_API Int16  __stdcall NMC_LaserSetParam ( HAND devHandle, Int32 onDelay ,
                Int32 offDelay, Int32 minValue ,Int32 maxValue,Int32 standbyPower,Int16 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 Int16  __stdcall NMC_CrdBufLaserSetParam ( HAND crdHandle, Int32 segment,Int32 onDelay ,
                Int32 offDelay, Int32 minValue ,Int32 maxValue,Int32 standbyPower,Int16 ch);

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

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

// 设置缓冲区激光能量跟随
// powerFilter:能量输出滤波系数，取值范围[0,32]，0：不开启（默认）
// followAdvMode:能量输出计算方法
// ch:激光通道号,取值范围[0,n]
MTN_API Int16 __stdcall NMC_LaserSetFollowParam(HAND devHandle,Int16 powerFilter,Int16 followAdvMode,Int16 ch);

// 设置缓冲区激光能量跟随的速度前馈
// velFiltCoe:前馈的速度滤波系数，取值范围[0,8]，0：不开启（默认）
// kvffCoe:前馈计算系数
// onOff:是否开启
// ch:激光通道号,取值范围[0,n]
MTN_API Int16 __stdcall OEM_LaserSetFollowKvffParam(HAND devHandle,Int16 velFiltCoe,double kvffCoe,Int16 onOff,Int16 ch);


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

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

// 激光能量补偿数据表单方向长度最大值
#define LASER_CMP_DATA_LEN_MAX                (10)

// 设置激光能量补偿表
// tableNo： 补偿表号 ：支持20张表
// pXCmpPos：X方向轴的比较位置,长度为xCount  
// pYCmpPos: Y方向轴的比较位置,长度为yCount  
// xCount： 表X方向的长度,取值范围[2,10]
// yCount： 表Y方向的长度,取值范围[2,10]
// powerMin:    大于该最小能量才补偿
// powerMax:    小于该最大能量才补偿
// pLaserCmpPower：补偿表的值，该参数为2维数组的首地址
// chn:对应的激光通道号
MTN_API Int16  __stdcall NMC_SetLaserPowerCmpTable ( HAND devHandle,Int16 tableNo,Int32 *pXCmpPos,Int32 *pYCmpPos,
    Int16 xCount,Int16 yCount, UInt32 powerMin,UInt32 powerMax,UInt32 *pLaserCmpPower,Int16 chn);

// 启动激光能量补偿
// pAxisNo： pAxisNo[0]表X方向的位置比较轴号 pAxisNo[1]表Y方向的位置比较轴号
// chn：补偿输出给哪路激光通道
MTN_API Int16  __stdcall NMC_StartLaserPowerComp ( HAND devHandle,Int16 *pAxisNo,Int16 chn);

// 停止激光能量补偿
MTN_API Int16  __stdcall NMC_StopLaserPowerComp ( HAND devHandle,Int16 chn);

// 设置激光输出线性补偿
// compStartPw: 补偿能量起始值，输出能量在[cmpStartPw,cmpEndPw]之间才会补偿
// compEndPw: 补偿能量结束值，输出能量在[cmpStartPw,cmpEndPw]之间才会补偿
// compPtCnt: 补偿点数量,取值[2,256]
// pCompData:补偿值列表，长度为compPtCnt
// chn:激光输出通道
MTN_API Int16  __stdcall NMC_LaserPowOutCompConfig(HAND devHandle, Int32 compStartPw, Int32 compEndPw, Int16 compPtCnt, F32* pCompData, Int16 chn);
MTN_API Int16  __stdcall NMC_LaserPowOutCompGetConfig(HAND devHandle, Int32* pCompStartPw, Int32* pCompEndPw, Int16* pCompPtCnt, F32* pCompData, Int16 chn);

// 开启或者关闭激光输出线性补偿
MTN_API Int16  __stdcall NMC_LaserPowOutCompOnOff(HAND devHandle, Int16 onOff, Int16 chn);

// 激光输出线性补偿 状态查询
// pOnOff:开关状态
// pCurCompVal:当前的补偿值
MTN_API Int16  __stdcall NMC_LaserPowOutCompGetSts(HAND devHandle, Int16* pOnOff, F32* pCurCompVal, Int16 chn);


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

typedef struct TTimeArrayPara
{
    Int16 pwmEnable;            // 是否需要输出PWM,0:立即输出一个波形，1：根据位移周期输出,2:立即输出波形，但控制点按照距离
    Int16 outputType;           // 开关信号输出类型：0：gate,1：GPO
    Int16 outputCh;            // 开关信号输出通道
    Int16 stLevelRevs;          // SHIO输出电平取反,默认为0，不取反
    Int32 pwmPeriod;            // 保留,PWM周期,单位us,不能小于时间数组的总周期
    Int32 pwmWidth;             // 保留,PWM脉宽,单位us,此参数保留,脉宽等于时间数组的总周期
    Int32 gateDistance;         // 固定模式下的位置间隔 单位：pulse。
                                // 默认0,模式2~4 下会进行有效性检查
    Int32 minFrqFrq;            // 保留,SHIO输出最低频率，单位HZ
    Int16 posSrc;               // 比较模式,外部编码器还是内部规划值。
                                // 0：外部编码器（推荐）,1：内部规划值。
                                // 默认0。
    Int16 axisMask;             // 轴号,按bit 位对应。（一般两个轴）。
                                // 默认 0。
    Int16 minFrqEn;            // 保留,是否启用SHIO输出最低频率，默认0，不启用
    Int16 reserved2;            // 保留
    
    #ifdef MTN_ST_INIT_EN
    TTimeArrayPara(){
     pwmEnable = 0;
     outputType = 0;
     outputCh = 0;
     stLevelRevs = 0;
     pwmPeriod = 0;
     pwmWidth = 0;
     gateDistance = 0;
     minFrqFrq = 0;
     posSrc = 0;
     axisMask = 0;
     minFrqEn = 0;
     reserved2 = 0;
    }
    #endif
}TTimeArrayPara;

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

typedef struct TLaserPower
{
    UInt16 time[LASET_POINT];   // 每个点之间的间隔时间,单位:100微秒；当pwmEnable=2时，表示每个点的位置间隔
    Int16 power[LASET_POINT];   // 各点的能量大小
    Int16 count;                // 实际压入点数
    
    #ifdef MTN_ST_INIT_EN
    TLaserPower(){
     count = 0;
     memset(time,0,sizeof(UInt16)*LASET_POINT);
     memset(power,0,sizeof(Int16)*LASET_POINT);
    }
    #endif
}TLaserPower;

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

// 查询时间数组的输出状态
// pOnOff:当前的执行状态，1:执行中 0:停止
// pCurGroup:当前使用的组号
// pCurPtIdx:当前使用的点序号
// pCurTime:当前点的时间序号，单位:100us
// ch:激光通道，取值范围[0,n)
MTN_API Int16  __stdcall NMC_LaserTimeArrayGetSts  (HAND devHandle, Int16 *pOnOff, Int16 *pCurGroup,Int16 *pCurPtIdx,Int16 *pCurTime,Int16 ch );

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


// 激光距离补偿
typedef struct TLaserDistCompPt
{
    Int32 dist;                 // 运动距离，从启动补偿作为起点，单位：pulse
    Int32 reserved;             // 保留
    F32 compVel;              // 补偿速度值，单位：(pulse/ms)
    F32 compPower;            // 补偿功率值，单位：能量值

#ifdef MTN_ST_INIT_EN
    TLaserDistCompPt() {
        dist = reserved = 0;
        compVel = compPower = 0;
    }
#endif
}TLaserDistCompPt;

// 设置激光距离补偿的补偿表
// chn : 激光通道
// dataCnt: 数据项数，取值范围[1, 1024],距离必须为递增的
// pCompData ： 补偿数据
// 注意：需要启用距离计算功能
MTN_API Int16  __stdcall OEM_LaserDistCompSetData(HAND devHandle, Int16 dataCnt,TLaserDistCompPt* pCompData,Int16 chn);

// 缓冲区指令：开关补偿功能
MTN_API Int16  __stdcall OEM_CrdBufLaserDistCompOnOff(HAND crdHandle, Int32 segNo, Int16 onOff, Int16 chn);

// 获取激光距离补偿状态
MTN_API Int16  __stdcall OEM_LaserDistCompGetSts(HAND crdHandle, Int16 *pOnOff,double *pCurCompVel,double *pCurComPower,Int16 chn);


typedef struct TSHIOPara
{
    Int16 isArray;         // 是否固定间距还是数组。0：固定间距（仅支持）,默认0
    Int16 outMode;         // 输出模式。默认1
                        // 1：只输出gate 立即开或关,
                        // 2: 根据位移输出gate
                        // 3: 根据位移输出gate,gate 和同部trigger 信号同步
                        // 4: 根据位移输出gate,gate 和信号输入同步
    Int16 posSrc;         // 比较模式,外部编码器还是内部规划值。
                        // 0：外部编码器（推荐）,1：内部规划值。
                        // 默认0。
    Int16 axisMask;     // 轴号,按bit 位对应。（一般两个轴）。
                        // 默认 0。
    double delay;         // 延时开关光时间( 暂不用 ),单位：s。默认 0。
    double gateTime;     // 设置gate 打开时间,单位：s（内部最小值：1/36us ）,取值范围(0,0.0009)
                        // 默认0。
    Int32 gateDistance;     // 固定模式下的位置间隔 单位：pulse。
                        // 默认0,模式2~4 下会进行有效性检查。
    Int32 k;                // 低频过渡系数          
    Int32 startDot;         // 启动时出光打点
    Int32 lowFrqRange;     // 低频范围：0:100K,1:1M
    Int16 outType;        // 输出类型：0-Gate，1-GPO
    Int16 outIndex;        // 输出通道，取值[0,19]
    UInt16 reserved5;     // 保留参数,应设为0。
    UInt16 reserved6;     // 保留参数,应设为0。
    
    #ifdef MTN_ST_INIT_EN
    TSHIOPara(){
     isArray = 0;
     outMode = 0;
     posSrc = 0;
     axisMask = 0;
     delay = 0;
     gateTime = 0;
     gateDistance = 0;
     k = 0;
     startDot = 0;
     lowFrqRange = 0;
     outType = 0;
     outIndex = 0;
     reserved5 = 0;
     reserved6 = 0;
    }
    #endif
}TSHIOPara;

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

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

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

// 缓冲区配置SHIO功能的参数
MTN_API Int16  __stdcall NMC_CrdBufSHIOConfigPara  (HAND crdHandle, Int32 segment, TSHIOPara *pSHIOPara,Int16 ch);

// 缓冲区SHIO输出的最小频率功能开
// minFrq:最低频率，单位HZ
MTN_API Int16  __stdcall NMC_CrdBufSHIOSetMinFrq(HAND crdHandle, Int32 segment, Int32 minFrq,Int16 ch);

// 缓冲区SHIO输出的最小频率功能关闭
MTN_API Int16  __stdcall NMC_CrdBufSHIOClrMinFrq (HAND crdHandle, Int32 segment,Int16 ch);

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

// SHIO脉宽补偿功能
// ratio: 脉宽补偿比例,默认0，表示不启用补偿. 计算结果单位为us
// syncVelType:参考速度类型，0--实际合成速度  1--规划合成速度
MTN_API Int16  __stdcall NMC_CrdSHIOGateTimeVelComp(HAND crdHandle, double ratio,Int16 syncVelType, Int16 ch);

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

// 切换轴（允许和坐标系不完全一致）,缓冲区指令
MTN_API Int16  __stdcall NMC_CrdBufSHIOChangeAxisMask( HAND crdHandle, Int32 segment, Int16 axisMask,Int16 ch );

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

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

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

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

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

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

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

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

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

// 输出一段PWM脉冲 
// onTime:PWM输出的脉宽，单位：微秒
// pwmFrq:PWM输出的频率，单位：HZ
// outCount:输出个数
// ch:通道
MTN_API Int16  __stdcall NMC_PwmPulseOut ( HAND devHandle,double onTime, double pwmFrq,Int32 outCount,Int16 ch);

// 输出一段PWM脉冲 
// onTime:PWM输出的脉宽，单位：微秒
// pwmFrq:PWM输出的频率，单位：HZ
// outCount:输出个数
// ch:通道
MTN_API Int16  __stdcall OEM_CrdBufPwmPulseOut ( HAND crdHandle,Int32 segNo,double onTime, double pwmFrq,Int32 outCount,Int16 ch);

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

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

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

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

// 用户指令传输,只读
MTN_API Int16  __stdcall NMC_UserCmdRead( HAND devHandle, UInt8 *sendBuffer, 
    UInt32 sendLen, UInt8 *recBuffer, UInt32 waitLen );

// 批量数据传输,只写
MTN_API Int16  __stdcall NMC_DataTransfer( HAND devHandle, UInt8 *sendBuffer, UInt32 sendLen );        

// 禁止用户程序运行
MTN_API Int16 __stdcall NMC_SysSetUserApp   ( HAND devHandle, UInt8 mode );

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

// 升级固件
MTN_API Int16 __stdcall NMC_SysUpgradeEx( HAND devHandle, UInt8 cmd, 
    UInt8 *sendBuffer, UInt32 sendLen, UInt8 *recBuffer, UInt32 recvedLen );

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

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

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

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

// 指令通讯看门狗:获取看门狗触发次数
MTN_API short __stdcall NMC_WatchDogGetTrigCnt(HAND devHandle, Int32* pTrigCnt);

// 指令通讯看门狗:设置看门狗触发次数
MTN_API short __stdcall NMC_WatchDogSetTrigCnt(HAND devHandle, Int32 trigCnt);

// 看门狗参数
typedef struct TWatchDogEx
{
    Int32 timeOut;        // 看门狗超时时间,单位毫秒,小于等于0代表关闭看门狗功能
    Int16 stopMode;        // 超时运动停止模式,0:缓冲区执行完毕后停止 1:马上停止,2:不对轴进行操作
    Int16 stopModeVar;    // 超时内部变量处理模式:0:不进行操作 1:复位为0
    Int16 stopModeGpo;    // 超时GPO处理模式,0:不进行操作，1:按照配置的组号及mask进行操作
    Int16 gpoGroupID;    // 超时输出do的组号
    Int32 gpoOutMask;    // 超时输出do掩码
    Int32 gpoOutValue;    // 超时输出do状态
    Int32 reserved[8];    // 保留
    
    #ifdef MTN_ST_INIT_EN
    TWatchDogEx(){
     timeOut = 0;
     stopMode = 0;
     stopModeVar = 0;
     stopModeGpo = 0;
     gpoGroupID = 0;
     gpoOutMask = 0;
     gpoOutValue = 0;
     memset(reserved,0,sizeof(Int32)*8);
    }
    #endif
}TWatchDogEx;

// 设置指令通讯看门狗Ex
MTN_API Int16 __stdcall NMC_SetWatchDogEx(HAND devHandle,TWatchDogEx *pPrm);


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

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


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

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


//------------------------------------------------------------------------------------------------------------
//
//    12.PT
//
//------------------------------------------------------------------------------------------------------------
// 单轴PT运动参数结构
typedef struct TPtPara
{
    double smoothDec;        // 停止减速度
    double abruptDec;        // 急停减速度，暂时保留
    double reserved1[2];    // 保留
    short dataTimeUnit;		// PtPushData接口中，时间的单位，0：毫秒 1:控制周期
    short reseved3;
    Int32 reserved2[3];      // 保留
    
    #ifdef MTN_ST_INIT_EN
    TPtPara(){
     smoothDec = 1;
     abruptDec = 10;
     memset(reserved1,0,sizeof(double)*2);
     dataTimeUnit = 0; reseved3 = 0;
     memset(reserved2,0,sizeof(Int32)*3);
    }
    #endif
}TPtPara;
// 设置PT运动的相关参数 
// pPara：参数,参考结构定义
MTN_API Int16 __stdcall NMC_MtPtSetPara( HAND axisHandle, TPtPara *pPara );

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

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

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


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

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

// 向Pt运动缓存区中压运动数据段：相同的时间间隔及PT段类型
// count:压入的数据段数
// pPosArray:段运行距离
// timeIntv:段运行时间
// ptType:段类型,见宏定义
MTN_API Int16  __stdcall NMC_MtPtPushEx(HAND axisHandle,Int16 count,double *pPosArray,Int32 timeIntv,Int16 ptType);


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

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

// 向Pt运动缓存区中压人DO输出段
// segNo:用户段号
// doType:do类型，查看‘DO type’相关宏定义,如DO_TYPE_GPDO等
// doMask:do通道掩码
// doValueMask:do输出值掩码
MTN_API Int16  __stdcall NMC_MtPtPushDO(HAND axisHandle,Int32 segNo,Int16 doType,Int32 doMask,Int32 doValueMask);

// 向Pt运动缓存区中压人DO输出段
// segNo:用户段号
// doType:do类型，查看‘DO type’相关宏定义,如DO_TYPE_GPDO等
// doGroup:组号
// doMask:do通道掩码
// doValueMask:do输出值掩码
MTN_API Int16  __stdcall NMC_MtPtPushDOEx(HAND axisHandle,Int32 segNo,Int16 doType,Int16 doGroup,Int32 doMask,Int32 doValueMask);

// 获取PT运动当前的用户段号
MTN_API Int16  __stdcall NMC_MtPtGetUserSegNo(HAND axisHandle,Int32 *pSegNo);

// 向Pt运动缓存区中压运动数据段，带段号
// count:压入的数据段数，取值范围[1,32]
// pPosArray:段运行距离
// pTimeArray:段运行时间
// pTypeArray:段类型,见宏定义
// pSegNoArray:段号数组
MTN_API Int16  __stdcall NMC_MtPtPushMv(HAND axisHandle,Int16 count,double *pPosArray,Int32 *pTimeArray,Int16 *pTypeArray,Int32 *pSegNoArray);

//-------------------------------------------------------------------------------
// PTEx
//-------------------------------------------------------------------------------

// 打开PtEx句柄
MTN_API Int16 __stdcall NMC_PtExOpen( HAND devHandle, Int16 chn,HAND *pHandle );

// 多轴PT运动
typedef struct TPtExPara
{
    Int16 axMask;            // 参与轴掩码
    Int16 bufLen;            // 用户自定义缓冲区长度,取值范围[32,8096]
    Int16 posMode;            // 位置模式：0：相对起点的位置 1:移动距离
    Int16 extAxFlag;        // 是否存在高位轴，0：不存在，PT轴都在axMask里面，1:存在,则PT轴在extAxMask中   
    double smoothDec;        // 停止减速度
    double abruptDec;        // 急停减速度，暂时保留
    Int64 extAxMask;		// 当extAxFlag为1时,参与的轴掩码 
    double reserved1[7];    // 保留
    Int32 reserved2[8];      // 保留
    
    #ifdef MTN_ST_INIT_EN
    TPtExPara(){
     axMask = 0;
     bufLen = 0;
     posMode = 0;
     extAxFlag = 0;
     smoothDec = 0;
     abruptDec = 0;
     memset(reserved2,0,sizeof(Int32)*8);
     memset(reserved1,0,sizeof(double)*7);
    }
    #endif
}TPtExPara;

// 设置PTEx运动的相关参数 
// pPara：参数,参考结构定义
MTN_API Int16 __stdcall NMC_PtExSetPara( HAND ptExHandle, TPtExPara *pPara );


// PTEx的命令类型
#define PTEX_CMDTYPE_MV_NORMAL                (0)
#define PTEX_CMDTYPE_MV_STOP                (1)
#define PTEX_CMDTYPE_MV_EVEN                (2)
#define PTEX_CMDTYPE_IMD_DO                    (1000)
#define PTEX_CMDTYPE_IMD_DOBITPULSE            (1001)
#define PTEX_CMDTYPE_IMD_DAC                (1002)
#define PTEX_CMDTYPE_IMD_PWM                (1003)

typedef struct TPtExMvData
{
    Int32 mvType;        // 数据运动类型，比如 PTEX_CMDTYPE_MV_NORMAL
    Int32 segNo;            // 段号
    Int32 mvTime;        // 运动时长
    Int32 reseved;        // 保留
    double mvPos[8];    // 运动位置
    
    #ifdef MTN_ST_INIT_EN
    TPtExMvData(){
     mvType = 0;
     segNo = 0;
     mvTime = 0;
     reseved = 0;
     memset(mvPos,0,sizeof(double)*8);
    }
    #endif
}TPtExMvData;

typedef struct TPtExDo            // DO输出指令结构体
{
    Int32 mvType;        // 数据类型，必须为PTEX_CMDTYPE_DO
    Int32 segNo;            // 段号
    Int16 doType;        // do类型
    Int16 doGroup;        // do组号
    Int32 doMask;        // 输出位掩码
    Int32 doValueMask;    // 输出值掩码
    Int32 doOutDelay;    // 输出的延时，正数为延时，负数为提前
    
    #ifdef MTN_ST_INIT_EN
    TPtExDo(){
     mvType = 0;
     segNo = 0;
     doType = 0;
     doGroup = 0;
     doMask = 0;
     doValueMask = 0;
     doOutDelay = 0;
    }
    #endif
}TPtExDo;

typedef struct TPtExDac            // DAC输出指令结构体
{
    Int32 mvType;        // 数据类型，必须为PTEX_CMDTYPE_DO
    Int32 segNo;        // 段号
    Int32 dacGroup;        // dac组号，对于本地DAC，值为0,对于ecat模块dac，取值范围[2,n]
    Int32 dacChn;        // dac通道号，本地扩展DAC，通道号为256
    double dacValue;    // 模拟量输出电压值
    
    #ifdef MTN_ST_INIT_EN
    TPtExDac(){
     mvType = 0;
     segNo = 0;
     dacGroup = 0;
     dacChn = 0;
     dacValue = 0;
    }
    #endif
}TPtExDac;

typedef struct TPtExPWM            // PWM输出指令结构体
{
    Int32 mvType;        // 数据类型，必须为PTEX_CMDTYPE_DO
    Int32 segNo;        // 段号
    Int32 pwmGroup;        // pwm组号，对于本地PWM，值为0
    Int32 pwmChn;        // pwm通道号
    Int32 period;        // pwm周期，单位us
    Int32 width;        // pwm脉冲宽度，单位us
    
    #ifdef MTN_ST_INIT_EN
    TPtExPWM(){
     mvType = 0;
     segNo = 0;
     pwmGroup = 0;
     pwmChn = 0;
     period = 0;
     width = 0;
    }
    #endif
}TPtExPWM;

typedef struct TPtExDoBitPulse
{  
    Int32 mvType;        // 数据类型，必须为PTEX_CMDTYPE_IMD_DOBITPULSE
    Int32 segNo;            // 段号
    Int32 highLevelTime;    // 高电平宽度，单位:us
    Int32 lowLevelTime;    // 低电平宽度，单位:us
    Int32 outCount;        // 输出脉冲个数
    Int16 initialLevel;    // 0：先输出低电平，1：先输出高电平
    Int16 doDelay;        // 输出延时
    Int16 ch;            // ch:通道
    Int16 enable;        // 1:使能,0:关闭
    Int16 doType;        // DO类型,如DO_TYPE_GPDO
    Int16 doIndex;        // DO序号，取值范围[0,n]
    
    #ifdef MTN_ST_INIT_EN
    TPtExDoBitPulse(){
     mvType = 0;
     segNo = 0;
     highLevelTime = 0;
     lowLevelTime = 0;
     outCount = 0;
     initialLevel = 0;
     doDelay = 0;
     ch = 0;
     enable = 0;
     doType = 0;
     doIndex = 0;
    }
    #endif
}TPtExDoBitPulse;

// 向PtEx运动缓存区中压运动数据段
// count:压入的数据段数
// pMvData:运动数据区
MTN_API Int16  __stdcall NMC_PtExPushMvData(HAND ptExHandle,Int16 count,TPtExMvData *pMvDataArray);

// 向PtEx运动缓存区中压DAC输出指令
// count:数量，取值范围[1,16]
// pDataArray:数据
MTN_API Int16  __stdcall NMC_PtExPushDac(HAND ptExHandle,Int16 count,TPtExDac *pDataArray);

// 向PtEx运动缓存区中压PWM输出指令
// count:数量，取值范围[1,16]
// pDataArray:数据
MTN_API Int16  __stdcall NMC_PtExPushPWM(HAND ptExHandle,Int16 count,TPtExPWM *pDataArray);

// 向PtEx运动缓存区中压DO脉冲输出指令
// count:数量，取值范围[1,16]
// pDataArray:数据
MTN_API Int16  __stdcall NMC_PtExPushDoBitPulse(HAND ptExHandle,Int16 count,TPtExDoBitPulse *pDataArray);

// 向PtEx运动缓存区中压Dac输出指令
// count:数量，取值范围[1,16]
// pDataArray:数据
MTN_API Int16  __stdcall NMC_PtExPushDo(HAND ptExHandle,Int16 count,TPtExDo *pDataArray);


// 清空PTEx数据
MTN_API Int16  __stdcall NMC_PtExBufClr(HAND ptExHandle);

// 启动PtEx运动
// flag:1立即停止 0尝试缓停
MTN_API Int16  __stdcall NMC_PtExStartMtn(HAND ptExHandle);

// 停止PtEx运动
// flag:0-停止ptex，但是不会停止各个轴的pt运动，1-立即停止PTEx及各个轴的运动
MTN_API Int16  __stdcall NMC_PtExStopMtn(HAND ptExHandle,Int16 flag);

// 手动DO脉冲输出指令
// 说明:outCount为0，则表示电平模式，自动输出initialLevel指定的电平
// prm:输出参数
MTN_API Int16  __stdcall NMC_PtExDoBitPulse(HAND ptExHandle,TPtExDoBitPulse *pDoBitPulse);

typedef struct TPtExSts
{
    Int16 sts;            // 状态 0:stop 1:run 2:err
    Int16 errCode;        // 错误码
    Int32 timeSum;        // 剩余运动时间
    Int32 segNo;            // 当前工作段号
    Int32 leftSpace;        // 剩余空间
    Int32 usedSpace;        // 使用的空间
    Int32 reserved[5];
    Int32 mvPos[8];    // 各轴运动位置
    Int32 encPos[8];    // 各轴运动位置
    
}TPtExSts;

// 获取PtEx状态
MTN_API Int16  __stdcall NMC_PtExGetSts(HAND ptExHandle,TPtExSts *pSts);


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

// 精确输出结构体
typedef struct TLinearCmpPara
{
    Int16 dimens;
    Int16 compMode;
    Int16 axMask;       
    Int16 src;
    double gateTime;
    
    #ifdef MTN_ST_INIT_EN
    TLinearCmpPara(){
     dimens = 0;
     compMode = 0;
     axMask = 0;
     src = 0;
     gateTime = 0;
    }
    #endif
}TLinearCmpPara;


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


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


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


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


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


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

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

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

// 功能：设置2维位置比较的参数。注意注意：该接口必须在比较轴编码器没有抖动的情况下调用，否则会影响位置比较精度
// param: 二维比较参数
// group:位置比较的组号,取值范围[0,n)
// chn:保留,设为0
MTN_API Int16 __stdcall NMC_Comp2DimensSetParam(HAND devHandle,Int16 group,TComp2DimensParam *param,Int16 chn);

// 功能：获取2维位置比较的参数
// param: 二维比较参数
// group:位置比较的组号,取值范围[0,n)
// chn:保留,设为0
MTN_API Int16 __stdcall NMC_Comp2DimensGetParam(HAND devHandle,Int16 group,TComp2DimensParam *param,Int16 chn);

// 高速二维位置点比较结构体
typedef struct  TComp2DimensParamEx
{
    Int16 outputChn;                              // 比较输出的通道号，取值[0,n]
    Int16 outputType;                             // 输出方式:0-脉冲1-电平
    Int16 chnType;                                // 通道类型：0-GPO, 1-GATE通道
    Int16 dir1No;                                 // 方向1 的位置源轴号,取值范围[0,n)
    Int16 dir2No;                                 // 方向2 的位置源轴号,取值范围[0,n)
    Int16 posSrc;                                 // 轴位置类型:0-规划,1-编码器
    Int16 stLevel;                                // 电平模式下的起始电平（0或1）
    Int16 errZone;                                // 进入比较点容差半径范围,单位:pulse
    Int16 directOutZone;                          // 近距离直接触发范围,单位:pulse
    Int16 vibrateRange;                           // 抖动滤波范围    
    Int32 gateTime;                               // 脉冲方式脉冲时间,单位us
    Int32 minIntervalTime;                        // 最小触发时间间隔,单位us
    Int32 out2Delay;                              // 输出2的滞后时间，单位us
    Int32 reserved[7];                            // 保留，默认值 0（不使用）
    
    #ifdef MTN_ST_INIT_EN
    TComp2DimensParamEx(){
        outputChn = 0;
        outputType = 0;
        chnType = 0;
        dir1No = 0;
        dir2No = 0;
        posSrc = 0;
        stLevel = 0;
        errZone = 0;
        directOutZone = 0;
        vibrateRange = 0;
        gateTime = 0;
        minIntervalTime = 0;
        out2Delay = 0;
        memset(reserved,0,sizeof(Int32)*7);
    }
    #endif
} TComp2DimensParamEx;

// 功能：设置2维位置比较的参数.注意注意：该接口必须在比较轴编码器没有抖动的情况下调用，否则会影响位置比较精度
// param: 二维比较参数
// group:位置比较的组号,取值范围[0,n)
// chn:保留,设为0
MTN_API Int16 __stdcall NMC_Comp2DimensSetParamEx(HAND devHandle,Int16 group,TComp2DimensParamEx *param,Int16 chn);


// 高速二维位置点比较结构体
typedef struct  TComp2DimensParamEx2
{
    Int16 outputChn;                              // 比较输出的通道号，取值[0,n]
    Int16 outputType;                             // 输出方式:0-脉冲1-电平
    Int16 chnType;                                // 通道类型：0-GPO, 1-GATE通道
    Int16 dir1No;                                 // 方向1 的位置源轴号,取值范围[0,n)
    Int16 dir2No;                                 // 方向2 的位置源轴号,取值范围[0,n)
    Int16 posSrc;                                 // 轴位置类型:0-规划,1-编码器
    Int16 stLevel;                                // 电平模式下的起始电平（0或1）
    Int16 errZone;                                // 进入比较点容差半径范围,单位:pulse
    Int16 directOutZone;                          // 近距离直接触发范围,单位:pulse
    Int16 vibrateRange;                           // 抖动滤波范围    
    Int32 gateTime;                               // 脉冲方式脉冲时间,单位us
    Int32 minIntervalTime;                        // 最小触发时间间隔,单位us
    Int32 out2Delay;                              // 输出2的滞后时间，单位us
    Int16 stopMode;                               // 0:数据比较完成，则退出位置比较  1:不退出比较，直到用户调用off-
    Int16 pauseMode;                              // 0:不支持暂停  1:遇到(-1,-1)则进入暂停状态
    Int32 reserved[6];                            // 保留，默认值 0（不使用）
    
    #ifdef MTN_ST_INIT_EN
    TComp2DimensParamEx2(){
        outputChn = 0;
        outputType = 0;
        chnType = 0;
        dir1No = 0;
        dir2No = 0;
        posSrc = 0;
        stLevel = 0;
        errZone = 0;
        directOutZone = 0;
        vibrateRange = 0;
        gateTime = 0;
        minIntervalTime = 0;
        out2Delay = 0;
        memset(reserved,0,sizeof(Int32)*7);
    }
    #endif
} TComp2DimensParamEx2;

// 功能：设置2维位置比较的参数.注意注意：该接口必须在比较轴编码器没有抖动的情况下调用，否则会影响位置比较精度
// param: 二维比较参数
// group:位置比较的组号,取值范围[0,n)
// chn:保留,设为0
MTN_API Int16 __stdcall NMC_Comp2DimensSetParamEx2(HAND devHandle,Int16 group,TComp2DimensParamEx2 *param,Int16 chn);

// 功能：读取2维位置比较的参数
MTN_API Int16 __stdcall NMC_Comp2DimensGetParamEx(HAND devHandle,Int16 group,TComp2DimensParamEx *param,Int16 chn);


// 功能：设置二维比较数据
// pArrayPos:比较数组地址
// count:位置点数,取值范围[0,n),count=0表示清除已经缓存的数据
// group:位置比较的组号,取值范围[0,n)
// chn:保留,设为0
// 注意：请预留至少128个位置点
MTN_API Int16 __stdcall NMC_Comp2DimensSetData(HAND devHandle,Int16 group,Int32 *pArrayPos,Int16 count,Int16 chn);

// 功能：设置二维比较数据,带能量
// group:组号,0 或者1
// pArrayPos:比较位置数组
// pArrayPower:能量数组
// count:位置点数,取值范围[0,n),count=0表示清除已经缓存的数据
MTN_API short __stdcall OEM_Comp2DimensSetDataPowerEx(HAND devHandle, short group, Int32* pArrayPos, Int16* pArrayPower, short count);

// 二维比较能量输出映射
// outType:0-模拟量输出
// outChn:输出通道号
MTN_API short __stdcall OEM_Comp2DimensPowerOutConfig(HAND devHandle, Int16 outType, Int16 outChn, Int16 group);
MTN_API short __stdcall OEM_Comp2DimensPowerOutGetConfig(HAND devHandle, Int16* outType, Int16* outChn, Int16 group);

// 功能：2维位置比较使能
// onOff： 0 停止,1输出 2手动
// group:位置比较的组号,取值范围[0,n)
// chn:保留,设为0
MTN_API Int16 __stdcall NMC_Comp2DimensOnoff(HAND devHandle,Int16 group,Int16 onOff,Int16 chn);


// 功能：2维位置比较的输出状态
// pStatus: 0 未启动比较 1 比较输出中
// pOutCount：输出的个数
// group:位置比较的组号,取值范围[0,n)
// chn:保留,设为0
MTN_API Int16 __stdcall NMC_Comp2DimensStatus(HAND devHandle,Int16 group,Int16 *pStatus, Int16 *pOutCount,Int16 chn);

typedef struct  TComp2DimensSts
{
    Int16 sts;                // 运行状态，0 空闲 1 忙
    Int16 reserved1;        // 保留
    Int32 freeSpace;            // 控制器剩余空间
    Int32 usedSpace;            // 剩余位置比较点
    Int32 outCount;            // 已经输出的个数
    Int32 reserved2[4];        // 保留
    
    #ifdef MTN_ST_INIT_EN
     TComp2DimensSts(){
     sts = 0;
     reserved1 = 0;
     freeSpace = 0;
     usedSpace = 0;
     outCount = 0;
     memset(reserved2,0,sizeof(Int32)*4);
    }
    #endif
} TComp2DimensSts;

// 功能：2维位置比较的输出状态
// pStatus: 状态结构体
// group:位置比较的组号,取值范围[0,n)
// chn:保留,设为0
MTN_API Int16 __stdcall NMC_Comp2DimensStatusEx(HAND devHandle,Int16 group,TComp2DimensSts *pStatus,Int16 chn);

// 功能：缓存区位置比较开关
// onOff： 0 停止,1输出 2手动
// group:组号,取值范围[0,n]
// compareType:位置比较类型，0:高速一维，1：高速二维
MTN_API Int16 __stdcall NMC_CrdBufCompareOnOff( HAND crdHandle, Int32 segNo, Int16 group,   Int16  onOff,  Int16  compareType);

// 功能：设置二维比较数据
// pArrayPos:比较数组地址
// count:位置点数,count=0表示清除已经缓存的数据。一次性最多压入6个数据
// group:位置比较的组号,取值范围[0,n)
// compareType:位置比较类型，0:高速一维，1：高速二维
MTN_API Int16 __stdcall NMC_CrdBufComp2DimensSetData(HAND crdHandle,Int32 segNo,Int16 group,Int32 *pArrayPos,Int16 count,Int16  compareType);

// 功能：下载二维比较数据
// pArrayPos:比较数组地址
// pOutCnt:输出计数数组
// pGpoOutValMask:输出值数组
// count:位置点数,count=0表示清除已经缓存的数据,
MTN_API Int16 __stdcall OEM_Comp2DimensSetDataEx2(HAND devHandle,Int16 group,Int32 *pArrayPos,Int16 *pOutCnt,Int16 *pGpoOutValMask,Int16 count,Int16 chn);

// 缓冲区控制位置比较输出引脚
// group:组号,0 或者1
// outType:0 脉冲 1 电平
// initLevel:电平模式下的输出电平，0 低电平 1 高电平
// pulseTime:脉冲模式下的输出脉冲宽度，单位:us
MTN_API Int16 __stdcall NMC_CrdBufComp2DimensOut(HAND crdHandle, Int32 segNo, Int16 group, Int16 initLevel, Int16  outType,Int16 pulseTime);

// 功能：设置二维比较数据模式
// dataMode:0-默认，数据用完则自动关闭, 
//          1-保持开启状态，压入数据则使用新数据比较，另外如果遇到(-1,-1)则进入暂停状态，可以通过NMC_CrdBufCompareOnOff(11)恢复
MTN_API Int16 __stdcall OEM_Comp2DimensSetDataMode(HAND devHandle, Int16  dataMode);

//-------------------------------------------------------------------------------
//15.多维位置比较输出通用接口
//-------------------------------------------------------------------------------
// X维位置点比较结构体
typedef struct  TCompXDimensParam
{
    Int16 dimens;                             // 维度
    Int16 axMask;                           // 使用的轴,按位
    Int16 src;                                 // 轴位置类型 ：0规划1：编码器

    Int16 outCnts;                             // 输出数量
    Int16 outType[CMP_OUTPUT_CHN_MAX];         // 输出方式0：脉冲1：电平
    Int16 outChnType[CMP_OUTPUT_CHN_MAX];    // 通道类型：0 GPO, 1  GATE通道
    Int16 outIndex[CMP_OUTPUT_CHN_MAX];     // GPO：0~63  GATE：0
    Int16 outStLevel[CMP_OUTPUT_CHN_MAX];   // 电平模式下的起始电平（0或1）
    Int16 outGateTime[CMP_OUTPUT_CHN_MAX];     // 脉冲模式下的脉冲时间:单位ms
    Int16 errZone;                             // 进入比较点容差半径范围（pulse）
    
    #ifdef MTN_ST_INIT_EN
     TCompXDimensParam(){
     dimens = 0;
     axMask = 0;
     src = 0;
     outCnts = 0;
     memset(outType,0,sizeof(Int16)*CMP_OUTPUT_CHN_MAX);
     memset(outChnType,0,sizeof(Int16)*CMP_OUTPUT_CHN_MAX);
     memset(outIndex,0,sizeof(Int16)*CMP_OUTPUT_CHN_MAX);
     memset(outStLevel,0,sizeof(Int16)*CMP_OUTPUT_CHN_MAX);
     memset(outGateTime,0,sizeof(Int16)*CMP_OUTPUT_CHN_MAX);
     errZone = 0;
    }
    #endif
} TCompXDimensParam;

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

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

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

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

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

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


//-------------------------------------------------------------------------------
// Sw位置比较
//-------------------------------------------------------------------------------
// 多维位置软比较结构体
#define SW_COMP_MAX_AX      6
typedef struct  TSwCompareParam
{
    Int16 dimens;                            // 维度
    Int16 outputType;                        // 输出方式0：脉冲1：电平
    Int16 outputChnType;                     // 通道类型：0 GPO, 1  GATE通道
    Int16 outputChn;                         // 比较输出的通道号，取值[0,n]
    Int16 axList[SW_COMP_MAX_AX];            // 使用的轴列表
    Int16 srcList[SW_COMP_MAX_AX];           // 位置源列表 ：0规划1：编码器
    Int16 stLevel;                           // 输出初始电平，0-低电平 1-高电平
    Int16 directOutZone;                     // 近距离直接触发范围
    Int32 gateTime;                          // 脉冲方式脉冲时间,单位us
    Int16 vibrateRange;                      // 抖动滤波范围    
    Int16 reserved1[3];                      // 保留，写0
    double errZone;                           // 进入比较点容差半径范围（pulse）
    double errZoneAxCoe[SW_COMP_MAX_AX];      // 单轴的的位置误差coe 

    Int16 out2ChnType;                       // 通道类型：0 GPO, 1  GATE通道,其他值则表示没有out2输出
    Int16 out2OutputType;                    // 输出方式0：脉冲1：电平
    Int16 out2OutputChn;                     // 比较输出的通道号，取值[0,n]
    Int16 reserved[5];                       // 保留，默认值 0（不使用）
    Int32 out2GateTime;                      // out2脉冲方式脉冲时间,单位us
    Int32 out2Delay;                         // 输出2的滞后时间，单位us
    

    #ifdef MTN_ST_INIT_EN
     TSwCompareParam(){
     dimens = 2;
     memset(axList,0,sizeof(Int16)*SW_COMP_MAX_AX);
     memset(srcList,0,sizeof(Int16)*SW_COMP_MAX_AX);
     axList[1]=1;
     outputChnType = 0;
     reserved1[0] = reserved1[1] = reserved1[2] = 0;
     errZoneAxCoe[0]=errZoneAxCoe[1]=errZoneAxCoe[2]=1.0;
     errZoneAxCoe[3]=errZoneAxCoe[4]=errZoneAxCoe[5]=1.0;
     outputChn = 0;
     errZone=10;
     directOutZone=2;
     vibrateRange=0;
     out2ChnType=-1;
     out2OutputType=0;
     gateTime=1000;
     out2Delay=0;
     memset(reserved,0,sizeof(Int16)*5);
    }
    #endif
} TSwCompareParam;


// 功能：设置多维位置软比较的参数
// param:比较参数
// ch:组号,0~1
MTN_API Int16 __stdcall NMC_SwCompareSetParam(HAND devHandle,TSwCompareParam *param,Int16 chn);
MTN_API Int16 __stdcall NMC_SwCompareGetParam(HAND devHandle,TSwCompareParam *param,Int16 chn);

// 功能：设置多维位置软比较数据
// pArrayPos:比较数组地址,
// count:位置点数,注：设置为n维数组比较时,每n个数据为一个点数。
//       对于一维比较，取值范围为[1,320],对于二维比较，取值为[1,160],以此类推
// ch:组号,0~N
MTN_API Int16 __stdcall NMC_SwCompareSetData(HAND devHandle, Int32 *pPosArray, Int16 count, Int16 chn);

// 功能：多维位置软比较使能
// onOff： 0 停止,1输出,2手动输出
// chn： 组号
MTN_API Int16 __stdcall NMC_SwCompareOnoff(HAND devHandle,Int16 onOff, Int16 chn);

// 多维位置软比较 基本状态
typedef struct  TSwCompareSts
{
    Int16 sts;                  // 运行状态，0 空闲 1 忙 ,其他值:错误代码
    Int16 reserved1;            // 保留
    Int32 freeSpace;            // 控制器剩余空间，单位:比较点数
    Int32 usedSpace;            // 剩余位置比较点，单位:比较点数
    Int32 outCount;             // 已经输出的个数
} TSwCompareSts;

// 功能：多维位置软比较的输出状态
// pStatus: 状态结构体
// group:组号,0 或者1
// chn:保留,设为0
MTN_API Int16 __stdcall NMC_SwCompareGetStatus(HAND devHandle,TSwCompareSts *pStatus,Int16 chn);

// 多维位置软比较 基本状态
typedef struct  TSwCompareStsEx
{
    Int16 sts;                      // 运行状态，0 空闲 1 忙,其他值:错误代码
    Int16 reserved1;                // 保留
    Int32 freeSpace;                // 控制器剩余空间，单位:比较点数
    Int32 usedSpace;                // 剩余位置比较点，单位:比较点数
    Int32 outCount;                 // 已经输出的个数
    Int32 compPos[SW_COMP_MAX_AX];  // 当前比较的位置
    Int32 reserved[8];              // 保留
} TSwCompareStsEx;

// 功能：多维位置软比较的输出状态EX
// pStatus: 状态结构体
// group:组号,0 或者1
// chn:保留,设为0
MTN_API Int16 __stdcall NMC_SwCompareGetStatusEx(HAND devHandle,TSwCompareStsEx *pStatus,Int16 chn);







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

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

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

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

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

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

// XYZA机型设置接口
// 设置XYZA的映射轴号
// pAxisMapArray[0]~[3]分别对应X、Y、Z和A
MTN_API Int16  __stdcall NMC_CrdSetTransXYZA(HAND crdHandle, Int16 *pAxisMapArray );

// 销毁XYZA机型，回归XYZ结构
MTN_API Int16  __stdcall  NMC_CrdDelTransXYZA(HAND crdHandle);

// 求工具参数
// deltaTheta：从0°往正方向旋转过的角度值
// deltaX：旋转deltaTheta角度后，重新校正到同一点位置后，X轴的相对移动量
// deltaY：旋转deltaTheta角度后，重新校正到同一点位置后，Y轴的相对移动量
// pToolX: 工具的X值
// pToolY: 工具的Y值
MTN_API Int16  __stdcall NMC_CrdSetXYZAToolCalc(HAND crdHandle, double     deltaTheta,Int32 deltaX,Int32 deltaY,Int32 *pToolX,Int32 *pToolY );


// 设置XYZA机型参数
// pulse2Rad: A轴的每个脉冲对应的弧度值
// toolX：工具的X值
// toolY: 工具的Y值
MTN_API Int16  __stdcall NMC_CrdSetXYZAPara(HAND crdHandle, double    pulse2Rad,Int32 toolX,Int32 toolY );

// 设置XYZA机型参数
// pPulse2Rad:A轴的每个脉冲对应的弧度值
// pToolX:工具的X值
// pToolY:工具的Y值
MTN_API Int16  __stdcall NMC_CrdGetXYZAPara(HAND crdHandle, double    *pPulse2Rad,Int32 *pToolX,Int32 *pToolY );

// 设置压入插补数据的位置是否需要关节到笛卡尔的坐标转换
MTN_API Int16 __stdcall NMC_CrdSetXYZAJointTransCrdPos( HAND crdHandle, Int16 isTrans );

//-------------------------------------------------------------------------------
//17.结构体初始化函数
//-------------------------------------------------------------------------------

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

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

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

// PID参数
typedef struct  TPidPara
{
    F32 kp;                                            // 增益系数
    F32 ki;                                            // 积分系数
    F32 kd;                                            // 微分系数
    F32 kvff;                                            // 速度前馈系数
    Int32 integralLimit;                                 // 积分饱和极限
    Int32 derivativeLimit;                               // 微分饱和极限
    Int16 outLimit;                                     // 输出饱和极限
    
    #ifdef MTN_ST_INIT_EN
     TPidPara(){
     kp = ki = kd = kvff = 0;
     integralLimit = 100;
     derivativeLimit = 100;
     outLimit = 32767;
    }
    #endif
} TPidPara;

// Dac参数
typedef struct TDacMotor
{
    Int16 inverse;            // 电压是否取反
    Int16 bias;                // Dac零漂
    Int16 dacLmt;            // Dac输出极限值
    
    #ifdef MTN_ST_INIT_EN
    TDacMotor(){
     inverse = 0;
     bias = 0;
     dacLmt = 0;
    }
    #endif
}TDacMotor;

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

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

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

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


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

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

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

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

// PID扩展参数
typedef struct  TPidParaEx
{
    F32 kp;                                            // 增益系数
    F32 ki;                                            // 积分系数
    F32 kd;                                            // 微分系数
    F32 kvff;                                          // 速度前馈系数
    F32 kaff;                                          // 加速度前馈系数
    Int32 integralLimit;                                 // 积分饱和极限
    Int32 derivativeLimit;                               // 微分饱和极限
    Int32 outLimit;                                      // 输出饱和极限
    F32 kaffEx;                                         // 加速度前馈系数Ex
    Int16 dzEnter;										 // 死区进入，单位pulse
    Int16 dzExit;										 // 死区退出，单位pulse
    Int32 reserved[6];                                   // 保留参数，请务必写0

#ifdef MTN_ST_INIT_EN
    TPidParaEx() {
        kp = 0.5;
        kp = ki = kd = kvff = kaff = kaffEx = 0;
        integralLimit = 100;
        derivativeLimit = 100;
        outLimit = 32767; kaffEx = 0; dzEnter = dzExit = 0;
        for (int i = 0; i < 6; i++) { reserved[i] = 0; }
    }
#endif
} TPidParaEx;

//设置对应组号的PID参数
MTN_API Int16  __stdcall NMC_MtSetPIDParaEx(HAND axisHandle, Int16 index, TPidParaEx* pidPara);

// 获取对应组号的PID参数
MTN_API Int16  __stdcall NMC_MtGetPIDParaEx(HAND axisHandle, Int16 index, TPidParaEx* pPidPara);

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

// 高级BufIo输出参数
typedef struct TAdvBufIoParam
{
    // 输出点
    Int16 outType;                // 输出类型，0：通用输出；1：Gate信号；其他保留
    Int16 outGroup;                // 输出组，取值范围[0,n]
    Int16 outIndex;                // 输出序号，取值范围[0,n]
    Int16 outSns;                // 有效电平,0:低电平有效，1：高电平
    
    // 信号
    Int16 pulseMode;        // 0：电平输出，1：脉冲输出
    Int16 reserved1;        // 保留
    Int32  pulseOnTime;        // 有效电平时间（脉冲输出方式下有效），单位：微秒
    Int32  pulseOffTime;        // 无效电平时间（脉冲输出方式下有效），单位：微秒
    
    UInt8 reserved[32];    // 保留
    
    #ifdef MTN_ST_INIT_EN
    TAdvBufIoParam(){
    outType = 0;
    outGroup = 0;
    outIndex = 0;
    outSns = 0;
    pulseMode = 0;
    reserved1 = 0;
    pulseOnTime = 0;
    pulseOffTime = 0;
    memset(reserved,0,sizeof(UInt8)*32);
    }
    #endif
}TAdvBufIoParam;

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

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

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

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

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

// DO脉冲输出最大通道数
#define MAX_NUM_DOBIT_PULSE        4

// DO脉冲输出
// doType:DO类型,0：通用输出；其他保留
// doIndex:DO序号，取值范围[0,n]
// highLevelTime:高电平宽度，单位:us,部分卡可能单位为ms
// lowLevelTime:低电平宽度，单位:us,部分卡可能单位为ms
// outCount:输出脉冲个数
// firstLevel:0：先输出低电平，1：先输出高电平
// ch:输出脉冲通道号,取值范围:[0,MAX_NUM_DOBIT_PULSE-1]
MTN_API Int16  __stdcall NMC_DoBitPulseEnable(HAND devHandle,Int16 doType,Int16 doIndex,
    Int32 highLevelTime,Int32 lowLevelTime,Int32 outCount,Int16 initialLevel,Int16 ch);

// 关闭DO脉冲输出
MTN_API Int16  __stdcall NMC_DoBitPulseDisable(HAND devHandle,Int16 ch);

// DO脉冲输出 （缓冲区）
MTN_API Int16  __stdcall NMC_CrdBufDoBitPulseEnable(HAND crdHandle, Int32 segNo,Int16 doType,Int16 doIndex,
    Int32 highLevelTime,Int32 lowLevelTime,Int32 outCount,Int16 initialLevel,Int16 ch);

// 关闭DO脉冲输出（缓冲区）
MTN_API Int16  __stdcall NMC_CrdBufDoBitPulseDisable(HAND crdHandle, Int32 segNo,Int16 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 Int16 __stdcall NMC_SetDacMode(HAND devHandle,Int16 ch, Int16 mode);

// 读取DAC（模拟量输出）通道的模式
// ch:模拟量通道号,取值范围[0,n]
// pMode:返回的模拟量输出范围设定值
MTN_API Int16 __stdcall NMC_GetDacMode(HAND devHandle,Int16 ch,Int16 *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,6:正值+/-10V 
// 注意：目前只支持+/-10V
// filterCoe:滤波系数，取值范围[0,64],0表示取消Adc滤波，单位:ms，默认值为0
MTN_API Int16 __stdcall NMC_SetAdcMode(HAND devHandle,Int16 ch,Int16 range,Int16 filterCoe);

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

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

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

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

// 设置模拟量输出的偏移值
// ch:模拟量通道号，[0,n]表示本地,[256,n]表示扩展模拟量通道
// bias:DAC输出偏移值
MTN_API Int16  __stdcall NMC_SetDacBias(HAND devHandle,Int16 ch,Int16 bias);

// 读取模拟量输出的偏移值
// ch:模拟量通道号，[0,n]表示本地,[256,n]表示扩展模拟量通道
// pBias:DAC输出偏移值
MTN_API Int16  __stdcall NMC_GetDacBias(HAND devHandle,Int16 ch,Int16 *pBias);

// 设置模拟量输出的极限值
// ch:模拟量通道号，[0,n]表示本地,[256,n]表示扩展模拟量通道
// maxVal:输出最大值
// minVal:输出最小值
MTN_API Int16  __stdcall NMC_SetDacLmt(HAND devHandle,Int16 ch,Int16 maxVal,Int16 minVal);

// 读取模拟量输出的极限值
// ch:模拟量通道号，[0,n]表示本地,[256,n]表示扩展模拟量通道
// pMaxVal:输出最大值
// pMinVal:输出最小值
MTN_API Int16  __stdcall NMC_GetDacLmt(HAND devHandle,Int16 ch,Int16 *pMaxVal,Int16 *pMinVal);

//-------------------------------------------------------------------------------
//21.scara
//-------------------------------------------------------------------------------
// 相关结构体
typedef struct TScaraMechPara
{
    double arm1Len;         // 杆1长，单位是用户单位
    double arm2Len;         // 杆2长，单位是用户单位
    double pitch;           // Z轴的丝杆节距，单位是用户单位
    double reserved[16];    // 保留，设置为0
    
    #ifdef MTN_ST_INIT_EN
    TScaraMechPara(){
     arm1Len = 0;
     arm2Len = 0;
     pitch = 0;
     memset(reserved,0,sizeof(double)*16);
    }
    #endif
}TScaraMechPara;

typedef struct TScaraJiontPara
{
    Int32 encBits;          // 关节的电机一圈的脉冲数
    Int32 zeroPulsePos;     // 关节零点位置的脉冲位置
    F32 posLmt;           // 关节的正限位位置：单位 度
    F32 negLmt;           // 关节的负限位位置：单位 度
    F32 ratio;            // 减速比
    F32 maxVel;           // 最大关节速度  ：单位  °/s
    F32 maxAcc;           // 最大关节加速度: 单位 °/s^2
    F32 reserved1;        // 保留，设置为0
    double reserved[8];        // 保留，设置为0
    
    #ifdef MTN_ST_INIT_EN
    TScaraJiontPara(){
     encBits = 0;
     zeroPulsePos = 0;
     posLmt = negLmt = ratio = maxVel = maxAcc = reserved1 = 0;
     memset(reserved,0,sizeof(double)*8);
    }
    #endif
}TScaraJiontPara;

// 设置机械参数
MTN_API Int16  __stdcall NMC_CrdSetScaraMechPara(HAND crdHandle,TScaraMechPara *pScaraMechPara);

// 读取机械参数
MTN_API Int16  __stdcall NMC_CrdGetScaraMechPara(HAND crdHandle,TScaraMechPara *pScaraMechPara);

// 设置关节参数
MTN_API Int16  __stdcall NMC_CrdSetScaraJiontPara(HAND crdHandle,Int16 jointNo,TScaraJiontPara *pScaraJiontPara);

// 读取关节参数
MTN_API Int16  __stdcall NMC_CrdGetScaraJiontPara(HAND crdHandle,Int16 jointNo,TScaraJiontPara *pScaraJiontPara);

// 设置crd类型为scara
// jointNum: 2/3
// jointAxNoArray 数组长度为4，不用的数据设置为0
MTN_API Int16  __stdcall NMC_CrdSetTransScara(HAND crdHandle, Int16 jointNum, Int16 *jointAxNoArray );

// 销毁scara机型
MTN_API Int16  __stdcall NMC_CrdDelTransScara(HAND crdHandle);

typedef struct TFlyFollowPara
{
    Int16 masterAxNo;           // 传输带轴号，0~N
    Int16 useEnc;               // 使用编码器，0：规划，1：编码器
    Int16 dirReverse;           // 传输轴方向取反。0：不取反，1：取反

    Int16 followedAxNo;         // 跟随哪个轴，0:X，1:Y
    double posCoe;              // 传输轴当量和跟随轴的当量比例，跟随当量 / 传输轴当量
    F32  followAng;	 	    // 跟随轴与传送带之间的夹角，单位：度
    F32  crdXYCoe;		    // 坐标系XY轴中，跟随轴与另外一个轴的传动比，即 跟随轴长度*crdXYCoe = 另外那个轴的长度
    Int32  reserved2[14];        // 保留，设置为0
    
    #ifdef MTN_ST_INIT_EN
    TFlyFollowPara(){
     masterAxNo = 0;
     useEnc = 0;
     dirReverse = 0;
     followedAxNo = 0;
     posCoe = 0;
     followAng = 0;
     memset(reserved2,0,sizeof(Int32)*15);
    }
    #endif
}TFlyFollowPara;


// 设置crd启用飞行跟随模式
// *pFlyFollowPara 模式参数
MTN_API Int16  __stdcall NMC_CrdSetFlyFollow(HAND crdHandle, TFlyFollowPara *pFlyFollowPara);

// 销毁飞行跟随
MTN_API Int16  __stdcall NMC_CrdDelFlyFollow(HAND crdHandle);

// 查询是否在暂停后已经跟随上状态
// sts : 1表示跟随上  0表示没有跟随上
MTN_API Int16  __stdcall  NMC_CrdGetFlyFollowUpSts(HAND crdHandle,Int16 *pSts);

// 缓冲区设置飞行跟随功能的启动和关闭
// enable:0:关闭跟随，关闭跟随后，坐标系自动切换到非跟随状态
//        1:激活跟随
//        2:暂停跟随,跟固件相关
MTN_API Int16  __stdcall NMC_CrdBufEnableFlyFollow(HAND crdHandle, Int32 segNo,Int16 enable);

// 缓冲区：飞行跟随情况下，移动到机械位置
// 注意：跟固件相关，部分固件不支持
MTN_API Int16  __stdcall NMC_CrdBufFlyFollowLineXY(HAND crdHandle, Int32 segNo,Int32 *tgtPos,double acc,double vel);

// 缓冲区：等待缓冲区数据
// usedSpace:等待缓冲区数据段数（大于等于usedSpace继续往下执行）
MTN_API Int16  __stdcall NMC_CrdBufWaitData(HAND crdHandle, Int32 segNo,Int32 usedSpace);

// 缓冲区：坐标系内轴跟随
// crdAxMaster:跟随的主轴，取值范围[0,n],为坐标系内的轴，0:X轴，1:Y轴，2:Z轴，3:A轴
// axFllowMask:跟随的从轴掩码
// onOff：启动跟随或者关闭跟随,1:启动跟随，0:关闭跟随，此时，crdAxMaster和axFllowMask忽略，可任意值
MTN_API Int16  __stdcall NMC_CrdBufAxFollowOnOff(HAND crdHandle, Int32 segNo,Int16 crdAxMaster,Int16 axFllowMask,Int16 onOff);

//-------------------------------------------------------------------------------
//22.坐标系干涉保护指令
//-------------------------------------------------------------------------------
#define CRD_INTERF_GROUP_MAX        (2)

// 启动坐标系的干涉保护
// groupNo: 干涉坐标系组号（目前只有两个坐标系，所以该值为0）
// mode:    0:基本模式，出现干涉，两坐标系均停止  1：激光模式，出现干涉，其中一个停止并离开
MTN_API Int16  __stdcall NMC_SetMvProtect(HAND devHandle,Int16 groupNo,Int16 mode);

// 取消坐标系的干涉保护
// groupNo: 干涉坐标系组号（目前只有两个坐标系，所以该值为0）
MTN_API Int16  __stdcall NMC_DelMvProtect(HAND devHandle,Int16 groupNo);

// 获取坐标系的干涉状态
// groupNo: 干涉坐标系组号（目前只有两个坐标系，所以该值为0）
// pSts:    0 没有启动干涉功能 1  没有出现干涉  2 干涉发生
MTN_API Int16  __stdcall NMC_GetMvProtectSts(HAND devHandle,Int16 groupNo,Int16 *pSts);

typedef struct TMvProtectPara
{
   Int16 crdNo[2];        // 需要干涉保护的两坐标系号
   Int16 crdAxNo[2];    // 坐标系的干涉轴号,指XYZ中哪一个（X:0  Y:1    Z:2）
   Int16 moveDir[2];    // 两干涉轴分别往距离减小时的运动方向，1：正向 -1：负向

   Int32 orgDis;            // 两坐标系的crdAxNo轴在原点时的距离
   Int32 mvProtectDis;     // 干涉的保护距离   
   Int32 safeWaitPos;    // mode为激光模式时，干涉轴需要停止到的等待位置（mode为0时无效）
   double mvToSafeAcc;  // 运动到等待位置的移动加速度
   double mvToSafeVel;  // 运动到等待位置的移动速度
   Int16 stopCrdNo;        // mode为激光模式时，需要停止的坐标系号（mode为0时无效）
   Int16 reserved[3];      // 保留参数
   
    
    #ifdef MTN_ST_INIT_EN
    TMvProtectPara(){
     crdNo[0] = crdNo[1] =0;
     crdAxNo[0] = crdAxNo[1] =0;
     moveDir[0] = moveDir[1] =0;
     orgDis = 0;
     mvProtectDis = 0;
     safeWaitPos = 0;
     mvToSafeAcc = 0;
     mvToSafeVel = 0;
     stopCrdNo = 0;
     reserved[0] = reserved[1] = reserved[2] = 0;
    }
    #endif
}TMvProtectPara;

// 设置坐标系的干涉保护参数
// groupNo:    干涉坐标系组号（目前只有两个坐标系，所以该值为0）
// pCrdInterfProtectPara： 干涉参数
MTN_API Int16  __stdcall NMC_SetMvProtectMode01Para(HAND devHandle,Int16 groupNo,TMvProtectPara *pMvProtectPara);

// 获取坐标系的干涉保护参数
// groupNo:    干涉坐标系组号（目前只有两个坐标系，所以该值为0）
// pCrdInterfProtectPara： 干涉参数
MTN_API Int16  __stdcall NMC_GetMvProtectMode01Para(HAND devHandle,Int16 groupNo,TMvProtectPara *pMvProtectPara);


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

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

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

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

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

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

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

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

// 直线插补
// segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
// crdAxMask:参与的轴,按位表示
// pTgPosArray：目标位置数组,长度为3
MTN_API Int16 __stdcall NMC_CrdLineXYZ(  HAND crdHandle,  Int32 segNo, Int16 crdAxMask,Int32 *pTgPosArray, double endVel, double vel,double synAcc );

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

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

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

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

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

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

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

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

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

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

//------------------------------------------------------------------------
//                                                     
//  24.自动状态返回
//                                                   
//------------------------------------------------------------------------
#define AUTO_RTN_MAX_AXIS  12
// 打包返回状态结构
typedef struct TAutoRtnPackedSts
{
    Int16          mtSts[12];          // 单轴状态
    Int16          mtMio[12];          // 单轴专用IO
    Int32           mtPrfPos[12];       // 单轴规划位置
    Int32           mtEncPos[12];       // 单轴实际位置
    F32          mtPrfVel[12];       // 单轴规划速度

    Int16          crdSts[2];          // 坐标系状态
    F32          crdPrfVel[2];       // 坐标系运动速度
    Int32           crdUserSeg[2];      // 坐标系运行的缓冲区段号
    Int32           crdFreeSpace[2];    // 坐标系缓冲区剩余空间
    Int32           crdUsedSpace[2];    // 坐标系缓冲区使用空间

    Int32           gpi;                // 通用输入
    Int32           gpo;                // 通用输出
    Int16          reserved[32];       // 预留

}TAutoRtnPackedSts;

// 设置启用自动状态返回
// mode1 : 设置哪些状态主动返回，0：固定时间周期返回（默认）; 1：周期+轴状态变化，坐标系状态变化；
// mode2 : 备用
// cycleInMs: 周期，单位ms。取值5~10000。建议值100ms。
// port: 端口，写0（库里会修改）
// hostTag : 上位机标签，写0（库里会修改）
MTN_API Int16 __stdcall NMC_DevAutoRtnSet( HAND devHandle, Int32 mode1, Int32 mode2, Int32 cycleInMs, Int32 port, Int32 hostTag );

// 设置禁用自动状态返回
MTN_API Int16 __stdcall NMC_DevAutoRtnClr( HAND devHandle );

// 同步，
// 把之前的状态缓冲清除掉。以后读到的是同步指令发送后的状态
// hostTag : 上位机标签，写0
MTN_API Int16 __stdcall NMC_DevAutoRtnSyn( HAND devHandle, Int32 hostTag );

// 读状态
// packedSts : 打包状态
MTN_API Int16 __stdcall NMC_DevAutoRtnGet( HAND devHandle, TAutoRtnPackedSts * packedSts, Int16 *pReady );

// 设置PTP位置比较输出
// comparaPos： 目标位置，单位是 脉冲
// upDateVel：比较后的更新速度 pulse/ms
MTN_API Int16 __stdcall NMC_MtSetPtpComparePara( HAND axisHandle,Int16 dir, Int32 comparaPos, double upDateVel);

// 获取PTP比较输出状态
MTN_API Int16 __stdcall NMC_MtGetPtpCompareSts( HAND axisHandle,Int16 *pIsCompareActive,Int16 *pIsCompareOut);

//------------------------------------------------------------------------
//                                                     
//  Group 25 : 点位自动收发
//                                                   
//------------------------------------------------------------------------

// 设置启用点位自动收发
MTN_API Int16 __stdcall NMC_DevAsynCommSet( HAND devHandle, UInt32 delayInMs );

// 设置关闭点位自动收发
MTN_API Int16 __stdcall NMC_DevAsynCommClr( HAND devHandle );

// 设置启用自动状态返回
MTN_API Int16 __stdcall NMC_DevAsynGetSts( HAND devHandle, TAutoRtnPackedSts * packedSts, Int16 *pReady );

// 多轴点位运动     
MTN_API Int16 __stdcall NMC_DevAsynAbsMoveType1( HAND axisHandle, F32 acc,F32 dec,F32 vel,
    Int16 smooth,Int32 arrivalBand,Int32 stableTime,Int32 tgtPos);

// 设置Do
MTN_API Int16 __stdcall NMC_DevAsynSetDoBit( HAND devHandle, Int16 bitIdx,Int16 setValue);

//------------------------------------------------------------------------
//                                                     
//  Group 26 : 高速一维位置比较
//                                                   
//------------------------------------------------------------------------

#define CMP_HS1DIMENS_CHN_MAX    (4)         // 最大支持四个通道
#define CMP_HS1DIMENS_POS_MAX    (128)         // 每个通道最多支持8个位置点

// 一维高速位置比较参数结构
typedef struct  TCompHs1DimensParam
{
    Int16 dirNo;            // 编码器源（0~7），对应轴0~7的编码器。
    Int16 out1StLevel;      // out1起始电平（0或1）
    Int16 out2StLevel;      // out2起始电平（0或1）
    Int16 reserved;         // 保留
    Int32 out1Width;         // out1脉冲宽度，0~65535,单位us
    Int32 out2Width;         // out2脉冲宽度，0~65535,单位us
    Int32 out2Delay;         // out2延时，0~65535,单位us
    
    #ifdef MTN_ST_INIT_EN
     TCompHs1DimensParam(){
     dirNo = 0;
     out1StLevel = 0;
     out2StLevel = 0;
     reserved = 0;
     out1Width = 0;
     out2Width = 0;
     out2Delay = 0;
    }
    #endif
} TCompHs1DimensParam;

// 功能：设置高速1维位置比较的参数（比较编码器）
// param: 一维比较参数
// chn：通道号,范围0~3
// 注：1)需要先设置编码器模式，可设置外部编码器或内部计数。
//???? 2)比较输出引脚位置请参考硬件手册。
//???? 3)out1比较位置到后马上输出, out2到位后延时输出。
MTN_API Int16 __stdcall  NMC_CompHs1DimensSetParam(HAND devHandle, TCompHs1DimensParam *param,Int16 chn );

// 功能：读取高速1维位置比较的参数
// param, chn：同上
MTN_API Int16 __stdcall NMC_CompHs1DimensGetParam(HAND devHandle, TCompHs1DimensParam *param,Int16 chn);

// 功能：设置高速1维比较数据
// pArrayPos:比较数组地址
// count:位置点数
// chn: 同上
MTN_API Int16 __stdcall NMC_CompHs1DimensSetData(HAND devHandle,Int32 *pArrayPos,Int16 count,Int16 chn);


// OEM_CompHs1DimensSetDataEx操作标志位定义
#define HS1D_OP_PRE_OFF        0x1            // 更新数据前，是否先关闭位置比较
#define HS1D_OP_PRE_CLR        0x2            // 更新数据前，是否先清除位置比较数据
#define HS1D_OP_AFT_ON        0x4            // 更新数据后，是否立即启动位置比较

// 功能：设置高速1维比较数据,带操作标志位
// pArrayPos:比较数组地址
// count:位置点数
// opFlag:操作标志位
// chn: 同上
MTN_API Int16 __stdcall OEM_CompHs1DimensSetDataEx(HAND devHandle,Int32 *pArrayPos,Int16 count,Int16 opFlag,Int16 chn);

// 功能：高速1维位置比较使能
// onOff： 0:停止,1:输出,2:手动输出（必须在空闲状态下,也需要提前设置参数）
// chn: 同上
MTN_API Int16 __stdcall NMC_CompHs1DimensOnOff(HAND devHandle, Int16 onOff,Int16 chn);

// 功能：高速1维位置比较的状态
// pBusy: 0 未启动比较 1 比较输出中
// pOutCount：输出的个数
// pWaitCnts：等待比较的个数
// pFreeCnts：缓冲区空闲的个数
// chn: 同上
MTN_API Int16 __stdcall NMC_CompHs1DimensStatus(HAND devHandle, Int16 * pBusy, Int16 *pOutCount, Int16 *pWaitCnts, Int16 *pFreeCnts, Int16 chn);

//------------------------------------------------------------------------
//                                                     
//  Group 27 : 获取多轴信息
//                                                   
//------------------------------------------------------------------------
// 读取计时时钟，控制器上电开始
// pClock:计数值，单位:125us
// pLoop: 循环周期计数
MTN_API Int16  __stdcall NMC_GetClock(HAND devHandle,UInt32 *pClock,UInt32 *pLoop);

// 获取多轴状态
// firstAxisHandle:第一个轴句柄
// pSts:返回的状态数组
// count:轴数量
// pClock:返回当前控制器时钟，单位125us
MTN_API Int16  __stdcall NMC_MtGetStsMulti(HAND firstAxisHandle,Int16 *pStsArray,Int16 count,UInt32 *pClock);

// 获取多轴规划模式
// firstAxisHandle:第一个轴句柄
// pModes:返回的数组
// count:轴数量
// pClock:返回当前控制器时钟
MTN_API Int16  __stdcall NMC_MtGetPrfModeMulti(HAND firstAxisHandle,Int16 *pModeArray,Int16 count,UInt32 *pClock);
MTN_API Int16  __stdcall NMC_MtGetAxisPrfPosMulti(HAND firstAxisHandle,Int32 *pPosArray,Int16 count,UInt32 *pClock);
MTN_API Int16  __stdcall NMC_MtGetAxisPrfVelMulti(HAND firstAxisHandle,double *pVelArray,Int16 count,UInt32 *pClock);
MTN_API Int16  __stdcall NMC_MtGetAxisPrfAccMulti(HAND firstAxisHandle,double *pAccArray,Int16 count,UInt32 *pClock);
MTN_API Int16  __stdcall NMC_MtGetAxisEncPosMulti(HAND firstAxisHandle,Int32 *pPosArray,Int16 count,UInt32 *pClock);
MTN_API Int16  __stdcall NMC_MtGetAxisEncVelMulti(HAND firstAxisHandle,double *pVelArray,Int16 count,UInt32 *pClock);
MTN_API Int16  __stdcall NMC_MtGetAxisEncAccMulti(HAND firstAxisHandle,double *pAccArray,Int16 count,UInt32 *pClock);

// 获取多轴位置误差
MTN_API Int16  __stdcall NMC_MtGetAxisErrorMulti(HAND firstAxisHandle,Int32 *pErrArray,Int16 count,UInt32 *pClock);

MTN_API Int16  __stdcall NMC_GetEncPosMulti(HAND devHandle,Int16 encoder,Int32 *pEncPosArray,Int16 count,UInt32 *pClock);


// 设置DI的滤波系数
// diType:DI类型,见DI type宏定义
// groupID:DI组,取值范围[0,n],对于DI_TYPE_GPI，则0: 本地DI31~DI0, 1: 本地DI63~DI32,其他指扩展IO模块；对于其他DI类型，暂时保留
// diIndex:DI通道号，取值范围[0,n]
// filtTime:滤波时间，单位ms，默认为3,取值范围[0,32],默认为3毫秒
MTN_API Int16  __stdcall NMC_SetDIFilter( HAND devHandle,Int16 diType,Int16 diGroup,Int16 diIndex,Int16 filtTime);

// 获取DI的滤波系数
MTN_API Int16  __stdcall NMC_GetDIFilter( HAND devHandle,Int16 diType,Int16 diGroup,Int16 diIndex,Int16 *pFiltTime);

// 设置DI的滤波系数
// diType:DI类型,见DI type宏定义,暂时只支持GPI(0~7)/Home/Lmt
// diGroup,diIndex:保留参数
// filtTime:滤波时间，取值范围[0,255] 
MTN_API Int16  __stdcall NMC_SetDIHardwareFilter(HAND devHandle, Int16 diType, Int16 diGroup, Int16 diIndex, Int16 filtTime);

// 获取DI的滤波系数
MTN_API Int16  __stdcall NMC_GetDIHardwareFilter(HAND devHandle, Int16 diType, Int16 diGroup, Int16 diIndex, Int16* pFiltTime);

// 读取数字量输入信号值
// diType:DI类型,见DI type宏定义
// groupID:DI组,取值范围[0,n],对于DI_TYPE_GPI，则0: 本地DI31~DI0, 1: 本地DI63~DI32,其他指扩展IO模块；对于其他DI类型，暂时保留
// pDiValue:返回的输入值
MTN_API Int16  __stdcall NMC_GetDIEx( HAND devHandle,Int16 diType,Int16 groupID,Int32 *pDiValue);

// 读取数字量输入信号值(原始值)
// diType:DI类型,见DI type宏定义
// groupID:DI组,取值范围[0,n],对于DI_TYPE_GPI，则0: 本地DI31~DI0, 1: 本地DI63~DI32,其他指扩展IO模块；对于其他DI类型，暂时保留
// pDiValue:返回的输入值
MTN_API Int16  __stdcall NMC_GetDIRaw( HAND devHandle,Int16 diType,Int16 groupID,Int32 *pDiValue);

// 设置数字量输入信号的翻转计数
// diType:DI类型,见DI type宏定义
// diIndex:DI序号，取值范围[0,n]，对于通用输入，只支持0~15，对于其他只支持0~7
// pReverseCountArray:返回的翻转计数数组
// count:同时获取的数量，取值范围[1,16]
MTN_API Int16  __stdcall  NMC_SetDiReverseCount(HAND devHandle,Int16 diType,Int16 diIndex,UInt32 *pReverseCountArray,Int16 count);

// 获取数字量输入信号的翻转计数
// diType:DI类型,如DI_TYPE_GPI
// diIndex:DI序号，取值范围[0,n]
// pReverseCountArray:翻转计数数组
// count:同时获取的数量，取值范围[1,16]
MTN_API Int16  __stdcall  NMC_GetDiReverseCount(HAND devHandle,Int16 diType,Int16 diIndex,UInt32 *pReverseCountArray,Int16 count);

// 按位设置及读取输入信号取反配置
// diType:输入类型,如DI_TYPE_GPI
// group:组号，目前只对于GPI有意义
// bitIndex:位序号，取值[0,31]
// revs:是否取反，0：不取反，默认值，1：取反
MTN_API Int16  __stdcall NMC_SetDIBitRevsEx ( HAND devHandle,Int16 diType,Int16 group,Int16 bitIndex,Int16 revs);
MTN_API Int16  __stdcall NMC_GetDIBitRevsEx ( HAND devHandle,Int16 diType,Int16 group,Int16 bitIndex,Int16 *pRevs);

// DO type
#define DO_TYPE_MOTOR_ENABLE            1   // 电机使能
#define DO_TYPE_MOTOR_CLEAR             2   // 电机报警清除
#define DO_TYPE_GPDO                    3   // 通用输出1
#define DO_TYPE_HSIO                    4   // 高速IO

// 输出DO,按照掩码
// doType:do类型
// groupID:组号
// outMask:按位输出掩码
// outValue:按位输出数值
MTN_API Int16  __stdcall NMC_SetDOMask( HAND devHandle,Int32 outMask,Int32 outValue ,Int16 doType,Int16 groupID) ;

// 读取模拟量输入电压值
// ch:通道号，[0,n]表示本地，256表示扩展模拟量通道
// count:获取的通道数量,取值范围[1,8]
// pAdcVolArray:获取的电压值数组
MTN_API Int16  __stdcall NMC_GetAdcVoltageMulti( HAND devHandle,Int16 ch,Int16 count,double *pAdcVolArray);

// 设置模拟量输出电压值
// ch:通道号，[0,n]表示本地，256表示扩展模拟量通道
// count:获取的通道数量,取值范围[1,8]
// pDacVolArray:获取的电压值数组
MTN_API Int16  __stdcall NMC_SetDacVoltageMulti( HAND devHandle,Int16 ch,Int16 count,double *pDacVolArray);

// 读取模拟量输出电压值
// ch:通道号，[0,n]表示本地，256表示扩展模拟量通道
// count:获取的通道数量,取值范围[1,8]
// pDacVolArray:获取的电压值数组
MTN_API Int16  __stdcall NMC_GetDacVoltageMulti( HAND devHandle,Int16 ch,Int16 count,double *pDacVolArray);

#define REPEAT_CAPT_MAX_NUM        64      // 最大重复捕获次数

// 设置重复捕获次数
// count:重复捕获次数，取值范围[0,REPEAT_CAPT_MAX_NUM],0表示取消重复捕获
// 注意:设置后将清除捕获数据
MTN_API Int16  __stdcall NMC_MtSetCaptRepeat(HAND axisHandle,Int16 count);

// 读取重复捕获计数
// pCount:已经捕获次数
MTN_API Int16  __stdcall NMC_MtGetCaptRepeatStatus(HAND axisHandle,Int16 *pCount);

// 读取重复捕获位置值
// pPosArray:返回的位置值数组
// startNum:起始计数
// count:重复捕获次数，取值范围[1,32],一次最多读32个
MTN_API Int16  __stdcall NMC_MtGetCaptRepeatPosMulti(HAND axisHandle,Int32 *pPosArray,Int16 startNum,Int16 count);

// 获取中断的执行时间
// pServoRunTime:伺服周期当前值
// pProfileRunTime:规划周期当前值
MTN_API Int16  __stdcall NMC_GetInterruptTime(HAND devHandle,double *pServoRunTime,double *pProfileRunTime);

// 获取中断的最大执行时间
// pServoRunTimeMax:伺服周期最大值
// pProfileRunTimeMax:规划周期最大值
MTN_API Int16  __stdcall NMC_GetInterruptTimeMax(HAND devHandle,double *pServoRunTimeMax,double *pProfileRunTimeMax);

// 缓冲区停止坐标系运动
// crdIdx:停止坐标系序号，-1表示停止自身
MTN_API Int16  __stdcall NMC_CrdBufStopMtn(HAND crdHandle,Int32 segNo,Int16 crdIdx);

// 使能或关闭输入整形功能
// enable: 0:取消 1：使能
// bufCount: 整形的宽度
// kCoef: 整形的系数
MTN_API Int16  __stdcall  NMC_MtSetAxisInputShaping(HAND axisHandle,Int16 enable,Int16 bufCount,double kCoef);

// 获取输出DO
// doType:do类型
// groupID:组号
// pOutValue:获取的数值
MTN_API Int16  __stdcall NMC_GetDOEx( HAND devHandle,Int16 doType,Int16 groupID,Int32 *pOutValue );

// 按位设置通用输出信号取反
// doType:DO类型,例如：DO_TYPE_GPDO
// group:组号，暂时只对GPO有效，指DO的组号
// bitIndex:取值范围[0,n],位序号,前64位为本地的通用输出,大于64为扩展Do
// revs:是否取反,1：取反,0：不取反
MTN_API Int16  __stdcall NMC_SetDOBitRevsEx ( HAND devHandle,Int16 doType,Int16 group,Int16 bitIndex,Int16 revs);

// 按位读取通用输出信号取反
MTN_API Int16  __stdcall NMC_GetDOBitRevsEx( HAND devHandle,Int16 doType,Int16 group,Int16 bitIndex,Int16 *pRevs);

// 获取坐标系状态
// pSts：crd状态，按位表示
// pUserSeg：当前的用户段号
MTN_API Int16 __stdcall NMC_CrdGetStsEx( HAND crdHandle, Int16 *pSts,Int32 *pUserSeg );

// 输入沿触发
// diIndex:通用输入序号，只支持通用输入信号，取值范围[0,32]
// diSns:触发沿，0为下降沿,1为上升沿
MTN_API Int16  __stdcall  NMC_MtPtStartMtnEx(HAND axisHandle,Int16 diIndex,Int16 diSns);

///xy平面补偿
#define XY2DCOMP_MAX_TABLE_NUM    (4)    // 平面补偿的最大表格数量
typedef struct T2DCompensationTable
{
    Int16 count[2];                // Count[0]和Count[1]分别为X，Y方向的数据点数，每个方向最小2个
    Int16 maxCompVel;		// 每毫秒叠加的最大补偿值,单位pulse,非正值自动设为32767
    Int16 reserved;			// 保留
    Int32 posBegin[2];            // posBegin[0]和posBegin[1]分别为X,Y方向的起始补偿位置
    Int32 step[2];                // step[0]和step[1]分别为XY方向的补偿步长
    double angle;                // 标定坐标系与机械坐标系的夹角，单位：度
    
    #ifdef MTN_ST_INIT_EN
    T2DCompensationTable(){
     count[0] = count[1] = 0;
     reserved = 0;
     posBegin[0] = posBegin[1] = 0;
     step[0] = step[1] = 0;
     angle = 0;
    }
    #endif
}T2DCompensationTable;

typedef struct TCompData
{
    Int32 xDirComp;
    Int32 yDirComp;
    Int32 zDirComp;
    
    #ifdef MTN_ST_INIT_EN
    TCompData(){
     xDirComp = 0;
     yDirComp = 0;
     zDirComp = 0;
    }
    #endif
}TCompData;                        // 每个点三个方向上的补偿量

// 设置补偿表：以XY为基准参考，标定XYZ方向的偏差数据，并进行设置
// tableIndex: 取值0（为后续扩展准备）
// pData:数据包含X*Y个点，点数组总长度X*Y*3<= 3000,每个点包含XYZ3个方向的补偿值,数组按照x方向排列
MTN_API Int16  __stdcall  NMC_Set2DCompensationTable(HAND devHandle,Int16 tableIndex,T2DCompensationTable *pTable,TCompData *pData);

// 获取补偿表
MTN_API Int16  __stdcall  NMC_Get2DCompensationTable(HAND devHandle,Int16 tableIndex,T2DCompensationTable *pTable,TCompData *pData);

// 获取规划位置对应的补偿位置
// tableIndex: 补偿表序号，取值0（为后续扩展准备）
// posX,posY:补偿前的规划位置
// pCompPosX,pCompPosY,pCompPosZ:计算得到的补偿量
MTN_API Int16  __stdcall  OEM_Get2DCompensationPos(HAND devHandle,Int16 tableIndex,Int32 posX,Int32 posY,Int32 *pCompPosX,Int32 *pCompPosY,Int32 *pCompPosZ);

// 获取当前位置的补偿数据
// pOrgData:原始的压入数据，共包含相关的四个角点的数据，顺序为x0,y0,x0,y1,x1,y0,x1,y1
// pRotData:旋转之后的数据，共包含相关的四个角点的数据，顺序为x0,y0,x0,y1,x1,y0,x1,y1
MTN_API Int16  __stdcall  OEM_Get2DCompensationCurData(HAND devHandle, Int16 tableIndex, Int32 *pOrgData,Int32 *pRotData);



typedef struct T2DCompensation
{
    Int16 enable;            // 启动或停止补偿
    Int16 tableIndex;        // 使用的目录表：取值0
    Int16 axisType[2];        // 二维补偿表所使用的轴类型:0表示规划，1表示使用编码器,2表示用户设定的位置
                            //  axisType[0]对应X方向类型，axisType[1]对应Y方向类型
    Int16 axisIndex[3];        // axisIndex[0]表示X方向使用的轴号， axisIndex[1]表示Y方向使用的轴号
                                                // 注：axisIndex[2]表示Z方向需要补偿的轴号
    
    #ifdef MTN_ST_INIT_EN
    T2DCompensation(){
     enable = 0;
     tableIndex = 0;
     axisType[0] = axisType[1] = 0;
     axisIndex[0] = axisIndex[1] = axisIndex[2] = 0;
    }
    #endif
}T2DCompensation;

// 设置并启动XY平面误差补偿
MTN_API Int16  __stdcall  NMC_Set2DCompensation(HAND devHandle,T2DCompensation *pComp);

// 获取XY平面的误差补偿参数
MTN_API Int16  __stdcall  NMC_Get2DCompensation(HAND devHandle,T2DCompensation *pComp);

// 设置用户参考位置
// 仅仅在axisType等于2时有意义，控制器根据用户参考位置，计算补偿
MTN_API Int16  __stdcall  OEM_Set2DCompensationUserRefPos(HAND devHandle,Int32 xPos,Int32 yPos,Int16 tableIndex);

// 设置PWM的输出通道
// portType: 0:默认通道，1：GPDO
// portIdx: 　映射通道号
// ch: PWM通道
MTN_API Int16 __stdcall NMC_SetPWMPort     ( HAND devHandle,Int16 portType,Int16 portIdx,Int16 ch);

// 读取PWM的输出通道
MTN_API Int16 __stdcall NMC_GetPWMPort     ( HAND devHandle,Int16 *pPortType,Int16 *pGpoIdx,Int16 ch);

//------------------------------------------------------------------------------------------------------------
//
//    28.PVT
//
//------------------------------------------------------------------------------------------------------------
// 单轴PVT运动参数结构
typedef struct TPvtPara
{
    double smoothDec;        // 停止减速度
    double abruptDec;        // 急停减速度，暂时保留
    double reserved1[2];    // 保留
    Int32 dataMode;            // 工作模式，1：数据驻存模式   0：数据刷新模式(默认模式)
    Int32 loopCount;            // 循环次数 ：仅数据驻存模式下有效
    Int32 reserved2[4];      // 保留
    
    #ifdef MTN_ST_INIT_EN
    TPvtPara(){
     smoothDec = 0;
     abruptDec = 0;
     reserved1[0] = reserved1[1] = 0;
     dataMode = 0;
     loopCount = 0;
     reserved2[0] = reserved2[1] = reserved2[2] = reserved2[3] = 0;
    }
    #endif
}TPvtPara;
// 设置PVT运动的相关参数 
// pPara：参数,参考结构定义
MTN_API Int16 __stdcall NMC_MtPvtSetPara( HAND axisHandle, TPvtPara *pPara );
// 读取PVT运动的相关参数 
MTN_API Int16 __stdcall NMC_MtPvtGetPara( HAND axisHandle, TPvtPara *pPara );
 
// 向PVT运动缓存区中压运动数据段
// count:压入的数据段数：1~32
// pPosArray:段运行距离
// pTimeArray:段运行时间
// pVelArray:段运行速度
MTN_API Int16  __stdcall NMC_MtPvtData(HAND axisHandle,Int16 count,double *pPosArray,double *pTimeArray,double *pVelArray);

// 查询PVT数据剩余空间大小
// pFreeSpace:返回的剩余空间大小
// pUsedSpace: 已使用的空间段数
MTN_API Int16  __stdcall NMC_MtPvtBufGetSpace(HAND axisHandle,Int16 *pFreeSpace,Int16 *pUsedSpace);

// 清空PVT数据
MTN_API Int16  __stdcall NMC_MtPvtBufClr(HAND axisHandle);

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


//------------------------------------------------------------------------
//                                                     
//  Group 1 : 高速输入触发
//                                                   
//------------------------------------------------------------------------
#define ADV_CAPTEX_MAX_CH            2    // 最大通道数

// 捕获源
#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   // 编码器特定位置
#define CAPT_EX_SRC_COMP2D            7   // 高速位置点比较触发
#define CAPT_EX_SRC_LN_COMP            8   // 线性位置比较触发

typedef struct 
{
    Int16 capAxMask;                    // 指捕获的编码器位置源掩码
    Int16 trigSrc;                        // 触发信号类型,见上面的定义。（默认：CAPT_EX_SRC_GPI）
    Int16 trigIndex;                    // 触发源序号。（默认0）
    Int16 trigLev;                        // 触发电平，0：上升，1：下降沿
    Int16 filter;                          // 滤波时间常数,单位:微秒,取值范围[0,255]
    Int16 reserved[3];                    // 保留
    Int32 reserved2[8];                    // 保留

    
    //#ifdef MTN_ST_INIT_EN
    //TAdvCaptureParamEx(){
    // capAxMask = 0;
    // trigSrc = 0;
    // trigIndex = 0;
    // trigLev = 0;
    // filter = 0;
    // reserved[3] = 0;
    // reserved2[8] = 0;
    //}
    //#endif
}TAdvCaptureParamEx;

// 设置高级捕获参数
// ch:通道号
// pParam:参数
MTN_API Int16  __stdcall  OEMLY_SetConfig(HAND devHandle,TAdvCaptureParamEx *pParam,Int16 ch);

// 读取高级捕获参数
MTN_API Int16  __stdcall  OEMLY_GetConfig(HAND devHandle,TAdvCaptureParamEx *pParam,Int16 ch);

// 清除捕获数据
MTN_API Int16  __stdcall  OEMLY_Clear(HAND devHandle,Int16 ch);

// 启动或关闭捕获
MTN_API Int16  __stdcall  OEMLY_OnOff(HAND devHandle,Int16 onOff,Int16 ch);

// 清除
// firstAx：第一个轴,取值范围[0,n]
// count：清除位置的轴数量
// flag:0：用户坐标系零点，1：机械坐标系零点
MTN_API Int16  __stdcall  OEMLY_ZeroPos(HAND devHandle,Int16 firstAx,Int16 count,Int16 flag);

// 工作状态位
#define CAPT_STS_BIT_RUN                0x1         // 是否正在工作中
#define CAPT_STS_BIT_ERR_SDRAM            0x2         // SDRAM读写错误
#define CAPT_STS_BIT_ERR_FULL            0x4         // 硬件缓存满
#define CAPT_STS_BIT_HWRUN                0x100       // 硬件捕获运动状态

// 获取采集状态
// pSts：工作状态,按位表示，如上宏定义
// pDataLenByte: 采集到的数据量,单位:Byte
// pTrigCnt:触发计数
MTN_API Int16  __stdcall OEMLY_GetSts ( HAND devHandle, Int16 *pSts, Int32 *pTrigCnt,Int32 *pDataLenByte ,Int16 ch);

// 获取采数据
// byteLenToGet：采集数据长度,单位byte，取值范围[8,1024]（单位：Byte,一次最多读1024字节）
// pGetLenByte:实际返回的数据长度,单位:Byte
// pData: 采集的数据,每个通道的一个数据为32Bit，读取的数据按顺序排列
// 比如配置中capAxMask=0x3,则拿回来的数据，排列为：x1,y1,x2,y2,x3,y3....
// 比如配置中capAxMask=0x7,则拿回来的数据，排列为：x1,y1,z1,x2,y2,z2,x3,y3,z3....
// 以上（x1,y1,z1）指第一次触发采集到的数据，（x2,y2,z2）指第二次触发采集到的数据，依次类推
MTN_API Int16  __stdcall OEMLY_GetData ( HAND devHandle, Int16 byteLenToGet, Int16 *pGetLenByte,Int32 *pData ,Int16 ch);


// PSP模式运动参数
typedef struct TPspPara
{
    double setMaxVel;    // 目标速度，单位:pulse/ms
    F32 stVel;        // 起跳速度，单位:pulse/ms
    F32 endVel;        // 终止速度，单位:pulse/ms
    F32 stAcc;        // 初始加速度，单位:pulse/ms^2
    F32 setMaxAcc;    // 最大加速度，单位:pulse/ms^2
    F32 setMaxDec;    // 最大减速度，单位:pulse/ms^2
    F32 maxJerkAcc;    // 加速段最大加加速度，单位:pulse/ms^3
    F32 ratio;        // S平滑段在整个加减速过程所占的比例
    F32 maxJerkDec;    // 减速段的最大加加速度，单位:pulse/ms^3
    Int16 pspPrfMode;   // Psp的规划模式：0-默认 1-自动按照PTP等效时间规划
    Int16 usePtpSmoothCoe;     // 对于按照PTP运行时间计算，对应的SmoothCoe
    F32 reserved[2];    // 保留
    
    #ifdef MTN_ST_INIT_EN
    TPspPara(){
     setMaxVel = 0;
     stVel = 0;
     endVel = 0;
     stAcc = 0;
     setMaxAcc = 0.5f;
     setMaxDec = 0.5f;
     maxJerkAcc = 0.3f;
     ratio = 0.3f;
     maxJerkDec = 0.3f;
     pspPrfMode =0;
     usePtpSmoothCoe = 0;
     reserved[0] = 0;
    }
    #endif
}TPspPara;

// 设置PST模式的参数
MTN_API Int16  __stdcall NMC_MtPspSetPara(HAND axisHandle, TPspPara *pParam);
MTN_API Int16  __stdcall NMC_MtPspGetPara(HAND axisHandle, TPspPara *pParam);

// 设置PST模式的目标位置
MTN_API Int16  __stdcall NMC_MtPspSetTgtPos(HAND axisHandle, Int32 tgtPos);
MTN_API Int16  __stdcall NMC_MtPspGetTgtPos(HAND axisHandle, Int32 *tgtPos);

// 更新PST模式的目标位置
MTN_API Int16  __stdcall NMC_MtPspUpdateTgtPos(HAND axisHandle, Int32 tgtPos);

// 更新PST模式的目标位置及最大速度，可以同时多个轴
MTN_API Int16  __stdcall NMC_MtPspUpdateTgtPosAndVelMask(HAND axisHandle,Int32 mask,double *pVelList,Int32 *pTgtPosList);

 


// 变量类型定义
#define MC_VAR_MtSts               (1)                        // 轴状态，16bit，按位表示，参考NMC_MtGetSts
#define MC_VAR_MtPrfPos            (2)                        // 轴规划位置，32bit
#define MC_VAR_MtEncPos            (3)                        // 轴实际位置，32bit
#define MC_VAR_MtMio               (4)                        // 轴IO，16bit，按位指示，请参考NMC_MtGetMotionIO
#define MC_VAR_GPI                 (5)                        // 通用DI，32bit，varIdx表示组号
#define MC_VAR_GPO                 (6)                        // 通用DO，32bit，varIdx表示组号
#define MC_VAR_CrdSts              (7)                        // 坐标系状态，16bit,按位表示，参考NMC_CrdGetSts
#define MC_VAR_CrdLeftSpace        (8)                        // 坐标系剩余空间，32bit
#define MC_VAR_PtpBufSts           (9)                        // PtpBuf的状态，48bit,对应TPtpBufMvSts的sts，errcode，curIdx
#define MC_VAR_Adc                 (10)                         // 模拟量输入，16bit，varIdx表示通道号
#define MC_VAR_EncPos               (11)                        // 实际位置，32bit，varIdx 表示通道号
#define MC_VAR_EncVel               (12)                        // 实际速度，32bit 单精度浮点，varIdx 表示通道号
#define MC_VAR_Slv32Bit               (13)                        // 从站的32bit数，32bit Int32
#define MC_VAR_Slv16Bit               (14)                        // 从站的16bit数，16bit Int16


// 采集模块：采集配置
#define STS_EX_COUNT_MAX        (64)                     //每组最多变量个数
typedef struct TStsExCfg
{
    Int16  en;                                     // 是否启用，1-启用，0-关闭，默认为关闭状态
    Int16  count;                                        // 变量个数
    UInt16  varType[STS_EX_COUNT_MAX];            // 变量的类型
    UInt16  varIdx[STS_EX_COUNT_MAX];            // 变量的序号
    
    #ifdef MTN_ST_INIT_EN
    TStsExCfg(){
      en = 0;
      count = 0;
      memset(varType,0,sizeof(UInt16)*STS_EX_COUNT_MAX);
      memset(varIdx,0,sizeof(UInt16)*STS_EX_COUNT_MAX);
    }
    #endif
}TStsExCfg;

// 启用扩展的状态读取指令功能，注意：仅对PCIE卡
// pCfg:高速状态变量配置信息
MTN_API Int16 __stdcall NMC_DevSetStsExCmdEnEx( HAND devHandle, TStsExCfg *pCfg);
MTN_API Int16 __stdcall NMC_DevGetStsExCmdEnEx( HAND devHandle, TStsExCfg *pCfg);

// 读取高速状态数据，注意：仅对PCIE卡
// dataByteOffset:数据的Byte偏移
// dataLenBytes:数据的长度，单位:Byte
// pGetData:数据接收缓存
MTN_API Int16 __stdcall NMC_DevGetStsExData( HAND devHandle, Int16 dataByteOffset,Int16 dataLenBytes,void *pGetData);


//------------------------------------------------------------------------------------------------------------
//
//    4.中断处理
//
//------------------------------------------------------------------------------------------------------------
//中断回调函数指针定义
typedef void (*GCNIO_IntCallback)(void);

// 设置中断
// idx      : 中断序号，取值范围[0,1]
// sns      : 中断触发电平: 0下降沿 1上升沿
// autoClr: 中断触发后是否自动清除标志位
// onOff  : 操作标志位，0:关闭 1:打开 2:清除状态
MTN_API Int16 __stdcall NMC_IntConfig(HAND devHandle,Int16 idx,Int16 sns,Int16 autoClr,Int16 onOff,GCNIO_IntCallback pCallback);

// 中断清除，中断触发后，需要清除才能接收下一次中断
// idx      : 中断序号，取值范围[0,1]
MTN_API Int16 __stdcall NMC_IntClr(HAND devHandle,Int16 idx);

// 清除中断的触发计数
// idx      : 中断序号，取值范围[0,1]
MTN_API Int16 __stdcall NMC_IntZeroTrigCnt(HAND devHandle,Int16 idx);

// 中断软触发
// idx      : 中断序号，取值范围[0,1]
MTN_API Int16 __stdcall NMC_IntPreSet(HAND devHandle,Int16 idx);

// 读取中断状态
// idx      : 中断序号，取值范围[0,1]
// pTrigCnt      : 中断触发计数
// pOnOff  : 中断的开关状态，0:关闭 1:打开 2:清除状态
MTN_API Int16 __stdcall NMC_IntGetSts(HAND devHandle,Int16 idx,Int32 *pTrigCnt,Int16 *pOnOff);

//------------------------------------------------------------------------------------------------------------
//
//    12.连接检测功能
//
//------------------------------------------------------------------------------------------------------------
// 看门狗参数
typedef struct TConnectChkPara
{
    Int32 port;             // 用户指定端口号，一般为45470
    Int32 timeOut;        // 看门狗超时时间,单位毫秒,小于等于0代表关闭看门狗功能
    Int16 stopMode;        // 超时运动停止模式,0:缓冲区执行完毕后停止 1:马上停止,2:不对轴进行操作
    Int16 stopModeVar;    // 超时内部变量处理模式:0:不进行操作 1:复位为0
    Int16 stopModeGpo;    // 超时GPO处理模式,0:不进行操作，1:按照配置的组号及mask进行操作
    Int16 gpoGroupID;    // 超时输出do的组号
    Int32 gpoOutMask;    // 超时输出do掩码
    Int32 gpoOutValue;    // 超时输出do状态
    Int32 reserved[7];    // 保留

#ifdef MTN_ST_INIT_EN
    TConnectChkPara() {
        port = 45470;
        timeOut = 0;
        stopMode = 0;
        stopModeVar = 0;
        stopModeGpo = 0;
        gpoGroupID = 0;
        gpoOutMask = 0;
        gpoOutValue = 0;
        memset(reserved, 0, sizeof(Int32) * 8);
    }
#endif
}TConnectChkPara;

//  连接检测配置
MTN_API short  __stdcall NMC_DevConnectChkSetConfig(HAND devHandle, TConnectChkPara* pInfo);
MTN_API short  __stdcall NMC_DevConnectChkGetConfig(HAND devHandle, TConnectChkPara* pInfo);



#ifdef __cplusplus
}
#endif

#endif    // _H_MTN_LIB20_EXT_H_








