
///******************************************************************
//
// Moudle Name  :   mtn_lib20_oem.h
// Abstract     :   GaoChuan Motion 2.0 oem 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_OEM_H_
#define _H_MTN_LIB20_OEM_H_
#include "mtn_lib20.h"

#ifdef __cplusplus
extern "C" {
#endif

// 设置PTP的高级参数
// minEvenTime:最小匀速时间
// param1:保留
MTN_API Int16  __stdcall OEM_MtSetMinEventTime(HAND axisHandle,Int16 minEvenTime,Int16 param1,Int16 param2,Int16 param3);

// 读取PTP的高级参数
MTN_API Int16  __stdcall OEM_MtGetMinEventTime(HAND axisHandle,Int16 *minEvenTime,Int16 *param1,Int16 *param2,Int16 *param3);

// 多轴同步运动
// mask:轴掩码
// pPosArray:位置数组
MTN_API Int16  __stdcall OEM_PtpSync(HAND devHandle,Int16 mask,Int32 *pPosArray);

// 多轴同步运动
// axCnt:参与的轴数量
// pAxList:轴列表
// pPosArray:位置数组
MTN_API Int16  __stdcall OEM_PtpSyncEx(HAND devHandle,Int8 axCnt,Int8 *pAxList,Int32 *pPosArray);

// 设置PSP的高级参数
// minEvenTime:最小匀速时间
MTN_API Int16  __stdcall OEM_MtPspSetMinEventTime(HAND axisHandle,Int16 minEvenTime);
MTN_API Int16  __stdcall OEM_MtPspGetMinEventTime(HAND axisHandle,Int16 *minEvenTime);

// 启动带最小匀速时间的PSP运动
MTN_API Int16  __stdcall OEM_MtPspStartEx(HAND axisHandle,Int32 tgtPos);

// 多轴同步运动
// mask:轴掩码
// pPosArray:位置数组
MTN_API Int16  __stdcall OEM_PspSync(HAND devHandle,Int16 axMask,Int32 *pPosArray);

typedef struct  TPrfMvParam
{
    Int16 prfMode;        // 规划模式,0:PTP规划,1:PSP规划方式
    Int16 smooth;        // 平滑时间,仅PTP规划模式下有效
    F32 stVel;        // 起跳速度，单位:Pulse/ms
    F32 endVel;        // 终点速度，单位:Pulse/ms
    F32 tgtVel;        // 目标速度，单位:Pulse/ms
    F32 acc;            // 加速度，单位:Pulse/ms^2
    F32 dec;            // 减速度，单位:Pulse/ms^2
    F32 jerkAcc;        // 加加速度，单位:Pulse/ms^3,仅PSP规划模式下有效
    F32 jerkDec;        // 减加速度，单位:Pulse/ms^3,仅PSP规划模式下有效
    F32 sRatio;        // S段占比，取值范围[0,1],仅PSP规划模式下有效
    F32 minEventTm;    // 最小的匀速段时间
    Int32  mvDistance;    // 运动距离，单位:Pulse
    F32 reserved[3];    // 保留
    
    #ifdef MTN_ST_INIT_EN
     TPrfMvParam(){
     prfMode = 0;
     smooth = 0;
     mvDistance = 0;
     stVel = 0;
     endVel = 0;
     tgtVel = 1;
     acc = 0.5;
     dec = 0.5;
     jerkAcc = 0;
     jerkDec = 0;
     sRatio = 0;
     minEventTm = 0;
     reserved[0] = reserved[1] = reserved[2] = 0;
    }
    #endif
} TPrfMvParam;

// 获取点到点运动的理论规划时间
// pPrfMvParam:运动参数
// pPrfTimeMs:计算得到的规划耗时，单位:毫秒
MTN_API Int16  __stdcall OEM_MtGetPrfTime(HAND axisHandle,TPrfMvParam *pPrfMvParam,double *pPrfTimeMs);


typedef struct  TComp2DimensDataGroup
{
    Int32 xStart;            // X起点
    Int32 yStart;            // Y起点
    Int32 xIntv;                // X间距
    Int32 yIntv;                // Y间距
    Int32 cnt;                // 数量
    Int32 reserved;
    
    #ifdef MTN_ST_INIT_EN
     TComp2DimensDataGroup(){
     xStart = 0;
     yStart = 0;
     xIntv = 0;
     yIntv = 0;
     cnt = 0;
     reserved = 0;
    }
    #endif
} TComp2DimensDataGroup;

// 功能：设置二维比较数据
// pArrayGroup:比较数组地址
// count:位置点数,取值范围[0,n),count=0表示清除已经缓存的数据
// group:组号,0 或者1
// chn:保留,设为0
MTN_API Int16 __stdcall OEM_Comp2DimensSetDataGroup(HAND devHandle,Int16 group,TComp2DimensDataGroup *pArrayGroup,Int16 count,Int16 chn);

// 功能：高速一维位置比较数据下载
// pArrayPos:比较数组地址
// count:数据数量，如果是大批量数据，一般要一次性压入大量数据，建议4096个数据
// group:比较通道号，0 或者1
MTN_API Int16 __stdcall OEM_Comp2DimensSetDataEx(HAND devHandle, Int16 group, Int32 *pArrayPos, Int16 count);

// 功能：高速一维位置比较数据下载,带能量控制
// pArrayPower:能量控制数组
MTN_API Int16 __stdcall OEM_Comp2DimensSetDataPower(HAND devHandle, Int16 group, Int32 *pArrayPos, Int16 *pArrayPower,Int16 count);

// 功能：设置双头运动中的第二个头相对第一个头的参数
// 参数：offsetX:双头回原点后，在X方向，第2个头的原点相对第1个头的原点的偏置量
//             offsetY:双头回原点后，在Y方向，第2个头的原点相对第1个头的原点的偏置量
//             pAxisNo:[0]第二个头的X轴对应的轴号  [1]第二个头的Y轴对应的轴号
MTN_API Int16 __stdcall NMC_CrdSetDoubleHeadPara(HAND crdHandle,Int32 offsetX,Int32 offsetY,Int16 *pAxisNo);

// 功能：读取双头运动中的第二个头相对第一个头的参数
// 参数：pOffsetX:双头回原点后，在X方向，第2个头的原点相对第1个头的原点的偏置量
//             pOffsetY:双头回原点后，在Y方向，第2个头的原点相对第1个头的原点的偏置量
//             pAxisNo:[0]第二个头的X轴对应的轴号  [1]第二个头的Y轴对应的轴号
MTN_API Int16 __stdcall NMC_CrdGetDoubleHeadPara(HAND crdHandle,Int32 *pOffsetX,Int32 *pOffsetY,Int16 *pAxisNo);

// 功能：实现第二个点胶头的图元切换动作,在没加工完一个图元后，切换到另外一个图元需要配合调用该指令
// 参数：    rotX,rotY:下一个图元的旋转中心（一般为相机拍照的位置）
//            tgtPosX,tgtPosY:是下一个图元的起始点位置XY的坐标 
//            deltaX、deltaY和theta:是下一个图元的中心相对第一个图元中心的偏移和旋转量。
//            deltaX、deltaY单位为脉冲，theta单位为度
//            vel,acc:第二个点胶头移动到起点的速度和加速度
// 注：没有对deltaX deltaY以及theta进行判断，后续根据第二号头的XY行程增加判断。
MTN_API Int16 __stdcall NMC_CrdBufObjectSwitch(HAND crdHandle, Int32 segNo,Int32 rotX,Int32 rotY, 
    Int32 tgtPosX,Int32 tgtPosY, Int32 deltaX,Int32 deltaY,double theta,double vel,double acc);

// 功能：建立2号头的与1号头的同步运动关系
MTN_API Int16 __stdcall NMC_CrdBufSecondHeadSyncMoveOn(HAND crdHandle, Int32 segNo);

// 功能：结束2号头的与1号头的同步运动关系
MTN_API Int16 __stdcall NMC_CrdBufSecondHeadSyncMoveOff(HAND crdHandle, Int32 segNo);


#define DB_HEAD_MAX_CHN        4

// 功能：设置多头运动中的第二个头相对第一个头的参数
// 参数：offsetX:双头回原点后，在X方向，第2个头的原点相对第1个头的原点的偏置量
//         offsetY:双头回原点后，在Y方向，第2个头的原点相对第1个头的原点的偏置量
//         pAxisNo:[0]第二个头的X轴对应的轴号  [1]第二个头的Y轴对应的轴号
//       chn:通道号，取值范围[0,MAX)
MTN_API Int16 __stdcall NMC_CrdSetMultiHeadParaEx(HAND crdHandle,Int32 offsetX,Int32 offsetY,Int16 *pAxisNo,Int16 chn);

// 功能：读取多头运动中的第二个头相对第一个头的参数
// 参数：pOffsetX:双头回原点后，在X方向，第2个头的原点相对第1个头的原点的偏置量
//         pOffsetY:双头回原点后，在Y方向，第2个头的原点相对第1个头的原点的偏置量
//         pAxisNo:[0]第二个头的X轴对应的轴号  [1]第二个头的Y轴对应的轴号
//       chn:通道号，取值范围[0,MAX)
MTN_API Int16 __stdcall NMC_CrdGetMultiHeadParaEx(HAND crdHandle,Int32 *pOffsetX,Int32 *pOffsetY,Int16 *pAxisNo,Int16 chn);

// 功能：实现第二个点胶头的图元切换动作,在没加工完一个图元后，切换到另外一个图元需要配合调用该指令
// 参数：    rotX,rotY:下一个图元的旋转中心（一般为相机拍照的位置）
//            tgtPosX,tgtPosY:是下一个图元的起始点位置XY的坐标 
//            deltaX、deltaY和theta:是下一个图元的中心相对第一个图元中心的偏移和旋转量。
//            deltaX、deltaY单位为脉冲，theta单位为度
//            vel,acc:第二个点胶头移动到起点的速度和加速度
//          chn:通道号，取值范围[0,MAX)
MTN_API Int16 __stdcall NMC_CrdBufMultiHeadObjectSwitchEx(HAND crdHandle, Int32 segNo,Int32 rotX,Int32 rotY, 
    Int32 tgtPosX,Int32 tgtPosY, Int32 deltaX,Int32 deltaY,double theta,double vel,double acc,Int16 chn);

// 启动跟随头的与主动头的同步运动
// mask:通道掩码
MTN_API Int16 __stdcall NMC_CrdBufMultiHeadSyncMoveOnEx(HAND crdHandle, Int32 segNo,Int16 mask);

// 结束启动跟随头的与主动头的同步运动
// mask:通道掩码
MTN_API Int16 __stdcall NMC_CrdBufMultiHeadSyncMoveOffEx(HAND crdHandle, Int32 segNo,Int16 mask);

// 缓冲区设置激光输出的optionVal
MTN_API Int16  __stdcall OEM_CrdBufLaserSetOptionVal( HAND crdHandle,Int32 segNo,double optionVal,Int16 laserCh);

#define LASER_PARAM_TAB_UNIT_MAX    64        // 最大的激光参数表数量
typedef struct TLaserParamTableUnit
{
    // SHIO模式下的参数
    double gateTime;         // 设置gate 打开时间,单位：s（内部最小值：1/36us ）,取值范围(0,0.0009)
    Int32 minFrq;            // 最低频率，单位HZ
    Int16 gateDistance;     // 固定模式下的位置间隔 单位：pulse
    Int16 k;                // 低频过渡系数          
    Int16 startDot;         // 启动时出光打点
    Int16 lowFrqRange;         // 低频范围：0：100k，1：1M,2:9M
    Int16 accLowFrqOnVel;    // 加速段低频功能的启用速度值
    Int16 decLowFrqOffVel;    // 减速段低频功能的关闭速度值
    Int16 yCoe;                // Y向补偿，取值范围[0,255],实际比例为0~2的比例，coe*256后设到这个变量
    Int16 yAng;                // 光斑的旋转角度
    
    // 普通模式下的参数
    Int32 onDelay;        //开光延时,单位us,取值范围[0,65535]
    Int32 offDelay;        //关光延时,单位us,取值范围[0,65535]
    Int32 minValue;        //最小输出值，DA输出时，范围[0,32767],占空比输出时，范围[0,100],频率输出时，范围[0,2000000]
    Int32 maxValue;        //最大输出值，DA输出时，范围[0,32767],占空比输出时，范围[0,100],频率输出时，范围[0,2000000]
    Int32 standbyPower;    //待机能量,为0表示取消待机能量输出功能
    double overRide;    //跟随倍率,为0表示取消激光能量跟随
    Int16 followType;    //跟随类型,0：跟随规划速度,1：跟随实际速度
    F32 optionVal;    // 当作为占空比输出时,该值为PWM的频率,单位HZ；
                        // 当为LASER_PWM_FRQ时,该值作为占空比值,单位为百分比；
                        // 当为LASER_PWM_FRQ_EXT时,该值为脉宽,单位为微秒,取值范围(0,~)
    Int16 reserved[5];    // 保留

    
    #ifdef MTN_ST_INIT_EN
    TLaserParamTableUnit(){
     gateTime = 0;
     minFrq = 0;
     gateDistance = 0;
     k = 0;
     startDot = 0;
     lowFrqRange = 0;
     accLowFrqOnVel = 0;
     decLowFrqOffVel = 0;
     yCoe = 0;
     yAng = 0;
     onDelay = 0;
     offDelay = 0;
     minValue = 0;
     maxValue = 32767;
     standbyPower = 0;
     overRide = 0.1;
     followType = 0;
     optionVal = 0;
     reserved[0] = reserved[1] = reserved[2] = reserved[3] = reserved[4] = 0;
    }
    #endif
}TLaserParamTableUnit;


MTN_API Int16  __stdcall OEM_CrdBufLaserSetParamTableIdx( HAND crdHandle,Int32 segNo,Int16 tableIdx,Int16 laserCh);
MTN_API Int16  __stdcall OEM_LaserSetParamTableIdx( HAND devHandle,Int16 tableIdx,Int16 laserCh);
MTN_API Int16  __stdcall OEM_LaserSetParamTableUnit( HAND devHandle,Int16 tableIdx,TLaserParamTableUnit *pParamUnit);
MTN_API Int16  __stdcall OEM_LaserGetParamTableUnit( HAND devHandle,Int16 tableIdx,TLaserParamTableUnit *pParamUnit);

//------------------------------------------------------------------------------------------------------------
//
//         多段速运动
//
//------------------------------------------------------------------------------------------------------------
// 高速变低速
typedef struct TPvtMoveHighToLow
{
    double startVel;    // 第一段起跳速度
    double highVel;        // 高速段最大速度
    double highAcc;        // 高速段加速度
    double highDec;        // 高速段减速度
    double lowVel;        // 低速段最大速度
    double lowDec;        // 低速段减速度
    Int32 highDist;        // 高速段目标位置
    Int32 lowDist;        // 低速段目标位置
    Int16 smooth;        // 平滑系数，取值[0,50]
    Int16 reseved[3];    // 保留字段
    
    #ifdef MTN_ST_INIT_EN
    TPvtMoveHighToLow(){
     startVel = 0;
     highVel = 0;
     highAcc = 0;
     highDec = 0;
     lowVel = 0;
     lowDec = 0;
     highDist = 0;
     lowDist = 0;
     smooth = 0;
     reseved[0] = reseved[1] = reseved[2] = 0;
    }
    #endif
}TPvtMoveHighToLow;

// 多段速：高速变低速
MTN_API Int16  __stdcall OEM_MtPvtMoveHighToLow(HAND axisHandle,TPvtMoveHighToLow *pPrm);

// 低速变高速
typedef struct TPvtMoveLowToHigh
{
    double startVel;    // 第一段起跳速度
    double highVel;        // 高速段最大速度
    double highAcc;        // 高速段加速度
    double highDec;        // 高速段减速度
    double lowVel;        // 低速段最大速度
    double lowAcc;        // 低速段加速度
    Int32 highDist;        // 高速段目标位置
    Int32 lowDist;        // 低速段目标位置
    Int16 smooth;        // 平滑系数，取值[0,50]
    Int16 reseved[3];    // 保留字段
    
    #ifdef MTN_ST_INIT_EN
    TPvtMoveLowToHigh(){
     startVel = 0;
     highVel = 0;
     highAcc = 0;
     highDec = 0;
     lowVel = 0;
     lowAcc = 0;
     highDist = 0;
     lowDist = 0;
     smooth = 0;
     reseved[0] = reseved[1] = reseved[2] = 0;
    }
    #endif
}TPvtMoveLowToHigh;

// 多段速：低速变高速
MTN_API Int16  __stdcall OEM_MtPvtMoveLowToHigh(HAND axisHandle,TPvtMoveLowToHigh *pPrm);

// 三段速运动（高低高）
typedef struct  TPvtMove3Stage
{
    double startVel;    //起跳速度
    double vel1;        //第1段匀速运动的速度（单位：脉冲/毫秒）
    double acc1;        //第1段加速度（单位：脉冲/毫秒^2）
    double dec1;        //第1段减速度（单位：脉冲/毫秒^2）
    double vel2;        //第2段匀速运动的速度（单位：脉冲/毫秒）
    double vel3;        //第3段匀速运动速度
    double acc3;        //第3段加速到第3段的加速度
    double dec3;        //第3段减速度

    Int32 dist1;            //第1段行程（单位：脉冲）
    Int32 dist2;            //第2段行程（单位：脉冲）
    Int32 dist3;            //第3段行程
    Int32 reserved2;        // 保留
    Int16 smooth;        // 平滑系数，取值[0,50]
    Int16 reseved[3];    // 保留字段
    
    #ifdef MTN_ST_INIT_EN
     TPvtMove3Stage(){
     startVel = 0;
     vel1 = 0;
     acc1 = 0;
     dec1 = 0;
     vel2 = 0;
     vel3 = 0;
     acc3 = 0;
     dec3 = 0;
     dist1 = 0;
     dist2 = 0;
     dist3 = 0;
     reserved2 = 0;
     smooth = 0;
     reseved[0] = reseved[1] = reseved[2] = 0;
    }
    #endif
} TPvtMove3Stage;

// 多段速：三段速运动（高低高）
MTN_API Int16  __stdcall OEM_MtPvt3Stage(HAND axisHandle,TPvtMove3Stage *pPrm);

// 更新目标位置
MTN_API Int16  __stdcall OEM_MtUpdateTgtPos(HAND axisHandle,Int32 tgtPos);

// 更新目标位置及目标速度
MTN_API Int16  __stdcall OEM_MtUpdateTgtPosAndVel(HAND axisHandle,Int32 tgtPos,F32 maxVel);

//------------------------------------------------------------------------------------------------------------
//
//         坐标系的速度，补偿激光
//
//------------------------------------------------------------------------------------------------------------
// 根据坐标系的速度，补偿激光输出的相关控制量
#define LASER_CRDVELCOMP_PT_MAX            64
#define LASER_CRDVELCOMP_GROUP_MAX        4
typedef struct TLaserCrdVelCompTable
{
    Int16 count;                                // 实际点数
    Int16 mode;                                    // 补偿对象，0：补偿option值，1：补偿输出能量 2:更新能量跟随倍率
    Int16 src;                                    // 跟随类型,0:编码器速度，1：规划速度
    Int16 reserved[5];                            // 保留
    F32 vel[LASER_CRDVELCOMP_PT_MAX];            // 速度表
    F32 comp[LASER_CRDVELCOMP_PT_MAX];        // 补偿值
    
    #ifdef MTN_ST_INIT_EN
    TLaserCrdVelCompTable(){
     count = 0;
     mode = 0;
     src = 0;
     memset(vel,0,sizeof(float)*LASER_CRDVELCOMP_PT_MAX);
     memset(comp,0,sizeof(float)*LASER_CRDVELCOMP_PT_MAX);
     reserved[0] = reserved[1] = reserved[2] = reserved[3] = reserved[4] = 0;
    }
    #endif
}TLaserCrdVelCompTable;

// 配置坐标系速度补偿表
// pCompTable：补偿表
// group:补偿表格的序号，取值范围[0,LASER_CRDVELCOMP_GROUP_MAX)
MTN_API Int16  __stdcall OEM_LaserSetCrdVelCompTable(HAND devHandle, TLaserCrdVelCompTable *pCompTable,Int16 group);
MTN_API Int16  __stdcall OEM_LaserGetCrdVelCompTable(HAND devHandle, TLaserCrdVelCompTable *pCompTable,Int16 group);

// 启用或关闭速度补偿功能
// crdNo: 坐标系编号，[0,1]
// onOff：启用或关闭，0：关闭补偿功能，1：启用补偿功能
// group:补偿表格的序号，取值范围[0,LASER_CRDVELCOMP_GROUP_MAX)
// laserCh:激光通道号
MTN_API Int16  __stdcall OEM_LaserCrdVelCompOnOff(HAND devHandle, Int16 crdNo,Int16 onOff,Int16 group,Int16 laserCh);

// 启用或关闭速度补偿功能,缓冲区指令
// onOff：启用或关闭，0：关闭补偿功能，1：启用补偿功能
// group:补偿表格的序号，取值范围[0,LASER_CRDVELCOMP_GROUP_MAX)
// laserCh:激光通道号
MTN_API Int16  __stdcall OEM_CrdBufLaserCrdVelCompOnOff( HAND crdHandle,Int32 segNo,Int16 onOff,Int16 group,Int16 laserCh);

// 读取单轴急停DI的触发状态
// pTrigSts:是否触发，1表示已经触发。NMC_MtSetEstopDIMask/NMC_MtSetEstopDI指令会复位触发状态。
// pTrigIndex:本次触发的di序号。NMC_MtSetEstopDIMask/NMC_MtSetEstopDI指令会复位触发状态。
MTN_API Int16  __stdcall OEM_MtGetEstopDITrigSts(HAND axisHandle, Int16 *pTrigSts ,Int16 *pTrigIndex);

// 缓冲区启动单轴PTP二段速运动
// segNo:段号
// axisNo：轴号，取值[0,n),非坐标系内轴
// tgtPos：目标位置
// blockEn:0:非阻塞非同步，1：阻塞
// 二段速的参数参考TPtpTwoStagePrm定义
MTN_API Int16 __stdcall OEM_CrdBufSetPtpTwoStage(HAND crdHandle, Int32 segNo,Int16 axisNo,Int32 tgtPos,Int16 inType,
            Int16 inIndex,Int16 inTrigLevel,Int16 action,double prm1,double prm2,double prm3,double prm4,Int16 blockEn);

// 缓冲区单轴移动参数设置
// segNo:段号
// axisNo：轴号,[0,n]
// vel:运动速度
// acc:运动加速度
// dec:运动减加速度
// velS:运动启动速度
// velE:运动终点速度
// smoothCoef:平滑系数
MTN_API Int16 __stdcall OEM_CrdBufSetPtpMoveParaEx(HAND crdHandle, Int32 segNo,Int16 axisNo,double vel,double acc,double dec,double velS,double velE,Int16 soomthCoef);


// 缓冲区补偿激光偏移值
// segNo:段号
// compType:bias类型，0:能量 1:跟随系数 2:option值
// bias:偏移值
// ch:激光通道
MTN_API Int16 __stdcall OEM_CrdBufSetLaserBias(HAND crdHandle, Int32 segNo,Int16 biasType,double bias,Int16 ch);

MTN_API Int16 __stdcall OEM_LaserSetBias(HAND devHandle, Int16 biasType,double bias,Int16 ch);

///////////////////////////////////////////// UART
//奇偶校验位选项
#define UART_PARITY_N                       0        // 无校验
#define UART_PARITY_O                       1        // 奇校验
#define UART_PARITY_E                       2        // 偶校验

//停止位
#define UART_STOP_BITS_10                   0        // 停止位为1
#define UART_STOP_BITS_15                   1        // 停止位为1.5
#define UART_STOP_BITS_20                   2        // 停止位为2

typedef struct TUartPara
{
    Int32 baudrate;            // 波特率
    Int16 mode;                // 端口的工作模式:0:默认，扩展模块工作模式，1:自由协议模式
    Int16 dataBits;            // 数据位,取值范围[7,8]
    Int16 stopBits;            // 停止位,取值范围[0,2]，参考宏定义，如UART_STOP_BITS_10等
    Int16 parity;            // 校验方式，如UART_PARITY_N等
    Int16 rxBufLen;            // 接收缓存长度，默认128
    Int16 txBufLen;            // 发送缓存长度，默认128
    Int16 uartCtrlFlag;        // 控制标记，bit0:电平取反，0-取反 1-不取反，bit1:大小端，注意：仅特定控制器支持    
    Int16 reserved[3];        // 保留
    
    #ifdef MTN_ST_INIT_EN
    TUartPara(){
     baudrate = 19200;
     mode = 0;
     dataBits = 8;
     stopBits = 0;
     parity = 0;
     rxBufLen = 128;
     txBufLen = 128;
     uartCtrlFlag = 0;
     reserved[0] = reserved[1] = reserved[2] =  0;
    }
    #endif
}TUartPara;        

// 配置Uart端口在自由模式下的通讯参数
// pParam:参数
// ch:保留，请写0
MTN_API Int16 __stdcall OEM_DevUartSetPara( HAND devHandle, TUartPara  *pParam,Int16 ch);

// 获取Uart端口的参数
MTN_API Int16 __stdcall OEM_DevUartGetPara( HAND devHandle, TUartPara  *pParam,Int16 ch);

// 打开或关闭UART
// onOff:0：关闭，1：打开
// ch:保留，请写0
MTN_API Int16 __stdcall OEM_DevUartOnOff( HAND devHandle, Int16 onOff,Int16 ch );

// 读Uart端口
// onOff:0：关闭，1：打开
// pBuf:读数据接收缓存区
// readLen:需要读取的数据长度，byte,一次最多读256字节
// retLen:实际读到的数据长度，byte
// ch:保留，请写0
MTN_API Int16 __stdcall OEM_DevUartRead( HAND devHandle, void *pBuf,Int16 readLen,Int16 *retLen ,Int16 ch);

// 写Uart端口
// onOff:0：关闭，1：打开
// pBuf:写数据
// writeLen:写的数据长度，byte,一次最多写256字节
// writedLen:实际写出的数据长度，byte
// ch:保留，请写0
MTN_API Int16 __stdcall OEM_DevUartWrite( HAND devHandle, void *pBuf,Int16 writeLen,Int16 *writedLen ,Int16 ch);

// 清除接收缓存
MTN_API Int16 __stdcall OEM_DevUartClrRx( HAND devHandle,Int16 ch);

// 获取当前串口收到的数据长度
// pOnOff:打开状态
// pLen:缓存的数据长度
// ch:保留，请写0
MTN_API Int16 __stdcall OEM_DevUartGetRxLen( HAND devHandle,Int16 *pOnOff,Int32 *pLen,Int16 ch);

// 带减速度的单轴停止功能,
// dec:减速度,单位：pulse/ms^2
// 注意：1.仅对PTP及Jog运动有效，对于其他运动模式，等同于NMC_MtStop
//       2.如果指定的减速度太小，则自动按照合适的减速度减速为0
MTN_API Int16 __stdcall OEM_MtStopEx( HAND axisHandle,double dec);

// 周期同步
MTN_API Int16 __stdcall OEM_Sync( HAND devHandle);


typedef struct TRepeatCaptParamEx
{  
    Int16 axMask;        // 捕获的轴掩码，最多8轴
    Int16 captMode;        // 捕获模式，参考NMC_MtSetCaptSns的参数定义
    Int16 captIoSrc;    // 捕获源，参考NMC_MtSetCaptSns的参数定义
    Int16 captLev;        // 捕获电平，参考NMC_MtSetCaptSns的参数定义
    Int32 captMaxCnt;    // 最多捕获多少个数据
    Int16 reserved[2];
    
    #ifdef MTN_ST_INIT_EN
    TRepeatCaptParamEx(){
     axMask = 0;
     captMode = 0;
     captIoSrc = 0;
     captLev = 0;
     captMaxCnt = 0;
     reserved[0] = reserved[1] = 0;
    }
    #endif
}TRepeatCaptParamEx;

// 设置重复捕获Ex的参数
// pParam:重复捕获cans
// ch:通道号，保留，请填0
MTN_API Int16 __stdcall OEM_CaptRepeatSetParamEx( HAND devHandle,TRepeatCaptParamEx *pParam,Int16 ch);
MTN_API Int16 __stdcall OEM_CaptRepeatGetParamEx( HAND devHandle,TRepeatCaptParamEx *pParam,Int16 ch);

// 启动或关闭重复捕获
// onOff:1:开，0:关
// ch:通道号，保留，请填0
MTN_API Int16 __stdcall OEM_CaptRepeatOnOffEx( HAND devHandle,Int16 onOff,Int16 ch);

// 读取重复捕获计数
// pOnOff:onOff状态
// pLeftCount:剩余的捕获次数
// pSumCnt:累计捕获次数
// pGetCount:已经获取的次数
// ch:通道号，保留，请填0
MTN_API Int16  __stdcall OEM_CaptRepeatGetStatusEx(HAND devHandle,Int16 *pOnOff,Int32 *pLeftCount,Int32 *pGetCount,Int32 *pSumCnt,Int16 ch);


// 读取重复捕获位置值
// pPosArray:返回的位置值数组
// count:要读取的触发位置组数，取值范围[1,32]
//       注意：捕获每触发一次，会产生n个位置数据（多轴），比如同时捕获四个轴，则count=1表示拿回四个位置值
// pGetCount:实际返回的数目
// ch:通道号，保留，请填0
MTN_API Int16  __stdcall OEM_CaptRepeatGetPosEx(HAND devHandle,Int32 *pPosArray,Int16 count,Int16 *pGetCount,Int16 ch);


//------------------------------------------------------------------------------------------------------------
//
//    Modbus
//
//------------------------------------------------------------------------------------------------------------
typedef struct TModbusParam
{  
    Int16 mode;            // 模式 -1:扩展模块,0:RTU,1:ASCII,16:RTU_Master
    Int16 slaveAddr;    // 从站地址,仅在为从站时有效
    Int16 port;            // 硬件端口，仅2有效
    Int16 parity;        // 校验类型，0：无校验，1：奇校验，2：偶校验
    Int16 dataBit;        // 数据位
    Int16 stopBit;        // 停止位
    Int32 bautrate;        // 波特率
    Int16 masterTimeout;// 主站的最大响应时间,单位：毫秒
    Int16 reserved[7];    // 保留
    
    #ifdef MTN_ST_INIT_EN
    TModbusParam(){
     mode = 0;
     slaveAddr = 0;
     port = 0;
     parity = 0;
     dataBit = 0;
     stopBit = 0;
     bautrate = 0;
     masterTimeout = 0;
     memset(reserved,0,sizeof(Int16)*7);
    }
    #endif
}TModbusParam;

// Modbus初始化
// pParam:参数
MTN_API Int16  __stdcall OEM_ModbusInit(HAND devHandle,TModbusParam *pParam);

// Modbus寄存器参数读取
// regType:寄存器类型,0:din,bit;1:coil,bit;2:input word,4:holding,word
// pRegCnt:寄存器个数
// pStartAddr:寄存器起始地址
MTN_API Int16  __stdcall OEM_ModbusGetRegParam(HAND devHandle,Int16 regType,Int16 *pRegCnt,Int32 *pStartAddr);

// Modbus寄存器参数设置
// regType:寄存器类型,0:din,bit;1:coil,bit;2:input word,4:holding,word
// regCnt:寄存器个数
// startAddr:寄存器起始地址
MTN_API Int16  __stdcall OEM_ModbusSetRegParam(HAND devHandle,Int16 regType,Int16 regCnt,Int32 startAddr);

// Modbus参数读取
// pParam:参数
MTN_API Int16  __stdcall OEM_ModbusGetParam(HAND devHandle,TModbusParam *pParam);


// 获取当前的modbus参数
// pSts: 
    //0:unset
    //1:slave mode, unconnected
    //2:slave mode, connected
    //3:master mode, unconnected
    //4:master mode, connected
MTN_API Int16  __stdcall OEM_ModbusGetSts(HAND devHandle,Int16  *pSts);

// Modbus关闭
// flag:1表示切换回扩展模块模式，其他标志只关闭Modbus
MTN_API Int16  __stdcall OEM_ModbusClose(HAND devHandle,Int16 flag);

// Modebus:读取开关输入
// offset:地址偏移
// count:数据数量
// pBuff:返回的数据
// slaveAddr:对于控制器作为从站，该参数可选或无效，控制器作为主站，表示从站地址[1~127]
MTN_API Int16  __stdcall OEM_ModbusGetDin(HAND devHandle,Int16 offset,Int16 count,UInt8 *pBuff,Int16 slaveAddr);

// Modebus:读取线圈输入
// offset:地址偏移
// count:数据数量
// pBuff:返回的数据
// slaveAddr:对于控制器作为从站，该参数可选或无效，控制器作为主站，表示从站地址[1~127]
MTN_API Int16  __stdcall OEM_ModbusGetCoil(HAND devHandle,Int16 offset,Int16 count,UInt8 *pBuff,Int16 slaveAddr);

// Modebus:读取保持寄存器
// offset:地址偏移
// count:数据数量
// pBuff:返回的数据
// slaveAddr:对于控制器作为从站，该参数可选或无效，控制器作为主站，表示从站地址[1~127]
MTN_API Int16  __stdcall OEM_ModbusGetHolding(HAND devHandle,Int16 offset,Int16 count,UInt16 *pBuff,Int16 slaveAddr);

// Modebus:读取16位输入寄存器
// offset:地址偏移
// count:数据数量
// pBuff:返回的数据
// slaveAddr:对于控制器作为从站，该参数可选或无效，控制器作为主站，表示从站地址[1~127]
MTN_API Int16  __stdcall OEM_ModbusGetInput(HAND devHandle,Int16 offset,Int16 count,UInt16 *pBuff,Int16 slaveAddr);

// Modebus:写开关输入
// offset:地址偏移
// count:数据数量
// pBuff:数据
// slaveAddr:对于控制器作为从站，该参数可选或无效，控制器作为主站，表示从站地址[1~127]
MTN_API Int16  __stdcall OEM_ModbusSetDin(HAND devHandle,Int16 offset,Int16 count,UInt8 *pBuff,Int16 slaveAddr);

// Modebus:写线圈输入
// offset:地址偏移
// count:数据数量
// pBuff:数据
// slaveAddr:对于控制器作为从站，该参数可选或无效，控制器作为主站，表示从站地址[1~127]
MTN_API Int16  __stdcall OEM_ModbusSetCoil(HAND devHandle,Int16 offset,Int16 count,UInt8 *pBuff,Int16 slaveAddr);

// Modebus:写保持寄存器
// offset:地址偏移
// count:数据数量
// pBuff:数据
// slaveAddr:对于控制器作为从站，该参数可选或无效，控制器作为主站，表示从站地址[1~127]
MTN_API Int16  __stdcall OEM_ModbusSetHolding(HAND devHandle,Int16 offset,Int16 count,UInt16 *pBuff,Int16 slaveAddr);

// Modebus:写16位输入寄存器
// offset:地址偏移
// count:数据数量
// pBuff:数据
// slaveAddr:对于控制器作为从站，该参数可选或无效，控制器作为主站，表示从站地址[1~127]
MTN_API Int16  __stdcall OEM_ModbusSetInput(HAND devHandle,Int16 offset,Int16 count,UInt16 *pBuff,Int16 slaveAddr);




// 对称运动参数
// 描述：两个平行平面，次平面XY自动跟随主平面XY的运动，运动规律为基于O点对称
// 过程：1.设置参数
//         2.主轴从轴运动到对称点，然后启动跟随
//       3.主轴运动过程中，从轴自动跟随
//       4.关闭跟随，解除关联
typedef struct TCrdSymmParam
{  

    Int32 masterCent[2];            // 主平面的圆心坐标
    Int32 slaveCent[2];            // 次平面的圆心坐标
    Int32 masterStart[2];        // 主平面的起点坐标
    Int32 slaveStart[2];            // 次平面的起点坐标

    Int8 slvAxX;				// 从轴X，非坐标系内
    Int8 slvAxY;				// 从轴Y，非坐标系内
    short reserved[3];			// 保留参数

    
    #ifdef MTN_ST_INIT_EN
    TCrdSymmParam(){
        masterCent[0] = masterCent[1] = 0;
        slaveCent[0] = slaveCent[1] = 0;
        masterStart[0] = masterStart[1] = 0;
        slaveStart[0] = slaveStart[1] = 0;
        slvAxX = 0; slvAxX = 1;
        reserved[0] = reserved[1] = reserved[2] = 0;
    }
    #endif
}TCrdSymmParam;

// 设置对称运动参数
MTN_API Int16 __stdcall OEM_CrdSetSymmParam(  HAND crdHandle, TCrdSymmParam *pParam);

// 启动或关闭对称跟随运动
MTN_API Int16 __stdcall OEM_CrdBufSymmOnOff(  HAND crdHandle, Int32 segNo,Int16 onOff);


// 圆形限位
typedef struct TCircleLimitPara
{  
    Int16 axMask;        // 关联的轴掩码
    Int16 mode;            // 0:触发后停止关联轴运动，1：停止并置起急停标志位
    Int32 centPosX;        // 圆形限位的圆心X，单位：pulse
    Int32 centPosY;        // 圆形限位的圆心Y，单位：pulse
    Int32 radius;        // 半径，半径为0表示取消该通道的圆形区域限位检查，单位：pulse
    F32 yProp;        // 系数，Y方向的当量除以X方向的当量
    F32 reserved2;    // 保留
    
    #ifdef MTN_ST_INIT_EN
    TCircleLimitPara(){
     axMask = 0;
     mode = 0;
     centPosX = 0;
     centPosY = 0;
     radius = 0;
     yProp = 0;
     reserved2 = 0;
    }
    #endif
}TCircleLimitPara;

// 设置圆形限位区域 
// pPara:参数
// chn:通道号，可以设置多组
MTN_API Int16 __stdcall OEM_SetCircleLimit(HAND devHandle,TCircleLimitPara *pPara,Int16 chn);
MTN_API Int16 __stdcall OEM_GetCircleLimit(HAND devHandle,TCircleLimitPara *pPara,Int16 chn);


//------------------------------------------------------------------------------------------------------------
//
//    Scan
//
//------------------------------------------------------------------------------------------------------------
 
// 振镜通道数量
#define OEM_SCAN_MAX_CHN        1

// 振镜控制功能开启关闭
// 控制器默认振镜功能是关闭的。NMC_DevReset不会改变振镜的开关状态
MTN_API Int16 __stdcall OEM_ScanEn(HAND devHandle,Int16 onOff,Int16 chn);

// 振镜控制数据清除
MTN_API Int16 __stdcall OEM_ScanBufClr(HAND devHandle,Int16 chn);

// 振镜控制的启动及停止，0：停止，1:启动
MTN_API Int16 __stdcall OEM_ScanOnOff(HAND devHandle,Int16 onOff,Int16 chn);

// 所有数据压完
MTN_API Int16 __stdcall OEM_ScanEndList(HAND devHandle,Int16 chn);

// 设置振镜控制的位宽
// mode:0:16位宽，1:20位宽
MTN_API short __stdcall OEM_ScanSetBitMode(HAND devHandle, short mode, short chn);

// 振镜控制指令，运动指令,绝对运动
// pXPosArray:x方向的位置数据
// pYPosArray:y方向的位置数据
// cnt:数组包含的数据个数
MTN_API Int16 __stdcall OEM_ScanBufMoveAbs(HAND devHandle,Int16 *pXPosArray,Int16 *pYPosArray,Int16 cnt,Int16 chn);

// 振镜控制指令，运动指令,相对运动
// pXPosArray:x方向的位置数据
// pYPosArray:y方向的位置数据
// cnt:数组包含的数据个数
MTN_API Int16 __stdcall OEM_ScanBufMoveRel(HAND devHandle,Int16 *pXPosArray,Int16 *pYPosArray,Int16 cnt,Int16 chn);

// 振镜控制指令，运动指令,绝对运动
// pXPosArray:x方向的位置数据
// pYPosArray:y方向的位置数据
// pZPosArray:z方向的位置数据
// cnt:数组包含的数据个数
MTN_API Int16 __stdcall OEM_ScanBufMoveAbsEx(HAND devHandle,Int16 *pXPosArray,Int16 *pYPosArray,Int16 *pZPosArray,Int16 cnt,Int16 chn);

// 振镜控制指令，运动指令,相对运动
// pXPosArray:x方向的位置数据
// pYPosArray:y方向的位置数据
// pZPosArray:z方向的位置数据
// cnt:数组包含的数据个数
MTN_API Int16 __stdcall OEM_ScanBufMoveRelEx(HAND devHandle,Int16 *pXPosArray,Int16 *pYPosArray,Int16 *pZPosArray,Int16 cnt,Int16 chn);

// 振镜控制指令，运动指令,绝对运动,20bit
MTN_API short __stdcall OEM_ScanBufMoveAbs20Bit(HAND devHandle, Int32* pXPosArray, Int32* pYPosArray, short cnt, short chn);

// 振镜控制指令，设置位置模式
// posMode:位置模式，0：绝对，默认，1：相对
MTN_API Int16 __stdcall OEM_ScanBufSetPosMode(HAND devHandle,Int16 posMode,Int16 chn);

// 振镜控制指令，更新段号
// segNo:段号
MTN_API Int16 __stdcall OEM_ScanBufSetSegNo(HAND devHandle,Int32 segNo,Int16 chn);

// 振镜控制指令，延时指令
// delayUs:延时时间，单位us,取值范围[0,3000000]
MTN_API Int16 __stdcall OEM_ScanBufDelay(HAND devHandle,Int32 delayUs,Int16 chn);

// 振镜控制指令，激光开关指令
// laserOnOff:开关
MTN_API Int16 __stdcall OEM_ScanBufLaserOnOff(HAND devHandle,Int16 laserOnOff,Int16 chn);

// 振镜控制指令，激光开关光延时
// onDelay:开光延时，单位us,取值范围[0,65535]
// offDelay:关光延时，单位us,取值范围[0,65535]
MTN_API Int16 __stdcall OEM_ScanBufLaserSetOnOffDelay(HAND devHandle,double onDelay,double offDelay,Int16 chn);

// 振镜控制指令，激光能量PWM设置
// pulseWid:PWM宽度，单位us,取值范围[0.25,16000]
// onTime:on时间，单位us,,取值范围[0.25,16000]
MTN_API Int16 __stdcall OEM_ScanBufLaserSetPowerPwm(HAND devHandle,double pulseWid,double onTime,Int16 chn);

// 振镜控制指令，激光能量DAC设置
// dac:电压输出值
MTN_API Int16 __stdcall OEM_ScanBufLaserSetPowerDac(HAND devHandle,Int16 dac,Int16 chn);

// 振镜控制指令，激光能量DOut设置
// doOutPower:输出能量，取值范围[0,255]
// outCtrl:输出控制，0表示影响enable信号，1表示则表示不影响
MTN_API Int16 __stdcall OEM_ScanBufSetPowerDOut(HAND devHandle,UInt16 dOutPower,Int16 outCtrl,Int16 chn);

// 振镜控制指令，激光脉冲宽度设置
// pulseWid:脉冲宽度，单位us
MTN_API short __stdcall OEM_ScanBufSetMopaPulseWidth(HAND devHandle, UInt16 pulseWid, Int16 chn);

// 配置PWM的频率基频模式
// mode:基频模式，0:4MHz基频固定，1:基频自动切换,有效频率范围[1,6M]
// chn:保留
MTN_API Int16 __stdcall OEM_ScanSetPWMBaseMode(HAND devHandle,Int16 mode,Int16 chn);
MTN_API Int16 __stdcall OEM_ScanGetPWMBaseMode(HAND devHandle,Int16 *pMode,Int16 chn);

// 配置PWM的自由运行模式，该模式下，PWM不受LaserOnOff指令的控制
// onOff:开关，0:关闭自由运行模式，1:开启
// pwmChn:PWM通道号，保留
MTN_API Int16 __stdcall OEM_ScanSetPWMFreeRunMode(HAND devHandle,Int16 onOff,Int16 pwmChn);
MTN_API Int16 __stdcall OEM_ScanGetPWMFreeRunMode(HAND devHandle,Int16 *pOnOff,Int16 pwmChn);

//状态位定义
#define BIT_SCAN_EN                    (0x00000001)    // 使能标志位 
#define BIT_SCAN_RUN                (0x00000002)    // 运动:1 ,静止 0   
#define BIT_SCAN_END                (0x00000004)    // 是否End标志位
#define BIT_SCAN_BUF_FULL            (0x00000008)    // 数据满    
#define BIT_SCAN_BUF_EMPTY            (0x00000010)    // 数据空    
#define BIT_SCAN_ERR_PUSH            (0x00001000)    // 压数据错误    
#define BIT_SCAN_ERR_POP            (0x00002000)    // 取数据错误
#define BIT_SCAN_ERR_OTHER            (0x00004000)    // 其他错误，参考errCode
#define BIT_SCAN_FPGA_RUN	        (0x00008000)    // FPGA run
#define BIT_SCAN_POS_ERR	        (0x00010000)    // 闭环模式下位置超差
typedef struct TOemScanSts
{  
    Int32 sts;                // 运行状态，按位表示，如上
    Int32 userSeg;            // 用户段号
    Int32 leftSpace;            // 剩余空间
    Int32 usedSpace;            // 使用空间
    UInt32 cmdAllCnt;// 全部指令的计数
    Int16 xPos;                // x方向当前位置
    Int16 yPos;                // y方向当前位置
    Int16 errCode;            // 错误码
    Int16 reserved[3];        // 保留

    
    #ifdef MTN_ST_INIT_EN
    TOemScanSts(){
     sts = 0;
     userSeg = 0;
     leftSpace = 0;
     usedSpace = 0;
     cmdAllCnt = 0;
     xPos = 0;
     yPos = 0;
     errCode = 0;
     reserved[0] = reserved[1] = reserved[2] = 0;
    }
    #endif
}TOemScanSts;

typedef struct TOemScanStsEx
{
    Int32 sts;                  // 运行状态，按位表示，如上
    Int32 userSeg;              // 用户段号
    Int32 leftSpace;            // 剩余空间
    Int32 usedSpace;            // 使用空间
    UInt32 cmdAllCnt;           // 全部指令的计数
    Int32 xPos;                 // x方向当前位置
    Int32 yPos;                 // y方向当前位置
    Int16 errCode;              // 错误码
    Int16 reserved[16];         // 保留


#ifdef MTN_ST_INIT_EN
    TOemScanStsEx() {
        sts = 0;
        userSeg = 0;
        leftSpace = 0;
        usedSpace = 0;
        cmdAllCnt = 0;
        xPos = 0;
        yPos = 0;
        errCode = 0;
        reserved[0] = reserved[1] = reserved[2] = 0;
    }
#endif
}TOemScanStsEx;

// 获取振镜的运行状态
MTN_API Int16 __stdcall OEM_ScanGetSts(HAND devHandle, TOemScanSts* pSts, Int16 chn);
MTN_API Int16 __stdcall OEM_ScanGetStsEx2(HAND devHandle, TOemScanStsEx* pSts, Int16 chn);

typedef struct TOemScanStsEx3
{
    Int32 sts;                  // 运行状态，按位表示，如上
    Int32 userSeg;              // 用户段号
    Int32 leftSpace;            // 剩余空间
    Int32 usedSpace;            // 使用空间
    UInt32 cmdAllCnt;           // 全部指令的计数
    Int32 xPos;                 // x方向当前位置
    Int32 yPos;                 // y方向当前位置
    Int32 zPos;                 // y方向当前位置
    Int32 xPosEnc;              // 振镜反馈位置X
    Int32 yPosEnc;              // 振镜反馈位置Y
    Int32 zPosEnc;              // 振镜反馈位置Z
    Int32 scanCommSts;          // 振镜的通讯状态
    Int32 pwm0Power;            // pwm0功率
    Int32 pwm1Power;            // pwm1功率
    Int16 errCode;              // 错误码
    Int16 mopaCurPower;         // mopa当前输出功率
    Int16 reserved[14];         // 保留
 
}TOemScanStsEx3;
MTN_API Int16 __stdcall OEM_ScanGetStsEx3(HAND devHandle, TOemScanStsEx3* pSts, Int16 chn);

// 设置振镜运动状态触发停止的掩码
// stsStopMask:状态掩码,对应位为1表示该状态触发会停止振镜运动
MTN_API Int16 __stdcall OEM_ScanSetStsStopMask(HAND devHandle, Int32 stsStopMask, Int16 chn);
MTN_API Int16 __stdcall OEM_ScanGetStsStopMask(HAND devHandle, Int32 *pStsStopMask, Int16 chn);

// 获取激光开关状态
// pLaserOnOff:开关状态 1表示开
// chn:激光通道号
// bufFlag:0:实际的开关输出状态，1:在当前缓冲区的开关状态
MTN_API Int16 __stdcall OEM_ScanGetLaserOnOffSts(HAND devHandle, Int16* pLaserOnOff, Int16 chn, Int16 bufFlag);

// 获取振镜缓冲区剩余空间
// pSts:状态 pLeftSpace:剩余空间
MTN_API Int16 __stdcall OEM_ScanGetStsEx(HAND devHandle,Int32 *pSts,Int32 *pLeftSpace,Int16 chn);

// 手动：运动到指定点
MTN_API Int16 __stdcall OEM_ScanMoveAbs(HAND devHandle,Int16 x,Int16 y,Int16 chn);

// 手动：运动到指定点,带Z轴
MTN_API Int16 __stdcall OEM_ScanMoveAbsEx(HAND devHandle,Int16 x,Int16 y,Int16 z,Int16 chn);

// 手动：运动到指定点,20Bit
MTN_API short __stdcall OEM_ScanMoveAbs20Bit(HAND devHandle, Int32 x, Int32 y, short chn);

// 手动：开光
MTN_API Int16 __stdcall OEM_ScanLaserOnOff(HAND devHandle,Int16 onOff,Int16 chn);

// 手动：输出PWM
// pulseWid:PWM宽度，单位us,取值范围[0.5,16000]
// onTime:on时间，单位us
MTN_API Int16 __stdcall OEM_ScanLaserPowerPwm(HAND devHandle,double pulseWid,double onTime,Int16 chn);

// 手动：输出DAC
MTN_API Int16 __stdcall OEM_ScanLaserPowerDac(HAND devHandle,Int16 dac,Int16 chn);

// 手动：输出能量DO
// doOutPower:输出能量，取值范围[0,255]
// outCtrl:输出控制，0表示影响enable信号，1表示则表示不影响
MTN_API Int16 __stdcall OEM_ScanLaserPowerDOut(HAND devHandle,Int16 doOutPower,Int16 outCtrl,Int16 chn);

// 振镜控制指令：按位来输出
// gpoIdx:gpo的序号，取值范围[0,31]
// outSns:输出电平 0;低电平 1:高电平
MTN_API Int16 __stdcall OEM_ScanBufSetDOBit(HAND devHandle,Int16 gpoIdx,Int16 outSns,Int16 chn);

// 振镜控制指令：同时操作所有GPO
// gpoValue:gpo输出值
MTN_API Int16 __stdcall OEM_ScanBufSetDO(HAND devHandle,Int32 gpoValue,Int16 chn);

// 振镜控制指令：缓存区等待DI
// diType:保留，请输入DI_TYPE_GPI
// diGroup:保留，请输入0
// diIdxMask:输入序号的掩码
// diValueMask:等待的电平
// timeOutMs:超时时间，单位:ms,输入0表示无限等待
MTN_API Int16 __stdcall OEM_ScanBufWaitDI(HAND devHandle,Int16 diType,Int16 diGroup,Int16 diIdxMask,Int16 diValueMask,UInt16 timeOutMs,Int16 chn);

// 振镜缓冲区指令:跳转
// x,y:目标位置
// vel:调整速度
MTN_API Int16 __stdcall OEM_ScanBufJump(HAND devHandle,Int16 x,Int16 y,Int16 vel,Int16 chn);

// 振镜立即指令:跳转
// x,y:目标位置
// vel:调整速度
MTN_API Int16 __stdcall OEM_ScanJump(HAND devHandle,Int16 x,Int16 y,Int16 vel,Int16 chn);

// 设置Mopa激光器脉宽
// pulseWidth:脉宽,单位us
MTN_API Int16 __stdcall OEM_ScanLaserSetMopaPulseWidth(HAND devHandle, Int32 pulseWidth, Int16 chn);

// 设置Mopa激光器的Lock信号脉宽
MTN_API Int16 __stdcall OEM_ScanLaserSetMopaLockWidth(HAND devHandle, Int32 pulseWidth, Int32 sns, Int16 chn);
MTN_API Int16 __stdcall OEM_ScanLaserGetMopaLockWidth(HAND devHandle, Int32 *pPulseWidth, Int32* pSns, Int16 chn);

// 设置振镜运动,运动数据自动检查模式开关
// autoChkEn：0: 关闭,默认值, 1: 开启
// 说明：振镜运动数据自动检查，开启后，用户在调用振镜缓冲区指令（运动或立即指令）时，如果返回1934，则表示缓冲区空间不足，指令压入不成功，需要重新压入
MTN_API Int16 __stdcall OEM_ScanSetSpaceAutoCheck(HAND devHandle, Int16 autoChkEn, Int16 chn);
// 振镜运动,运动数据自动检查模式下，可用空间
// pSpace：可用空间
// 注意：1.本指令仅适用于自动检查模式，请勿在非自动检查模式下调用本指令
//      2.本指令执行速度非常快
MTN_API Int16 __stdcall OEM_ScanAutoCheckGetSpace(HAND devHandle, Int32 *pSpace, Int16 chn);

// 振镜运动,设置最大激光开光的持续输出时间
// maxOnTimeMs:最大激光持续输出时间，单位ms
// handleMode:超时处理方法，0:输出信息，1:输出信息，并停止振镜加工
MTN_API short __stdcall OEM_ScanSetMaxLaserOnTime(HAND devHandle, Int32 maxOnTimeMs, Int32 handleMode, short chn);

// 振镜运动,设置闭环超差检查，持续超差则
// maxPosErr:最大位置误差,设为0则不检查
// overTime:超差持续时间，单位:us
// posErrHandle:错误处理方法，0:仅仅置起对应的错误标志位；1:置起错误标记，并停止振镜加工
MTN_API short __stdcall OEM_ScanSetPosErrLmt(HAND devHandle, Int32 maxPosErr, Int32 overTime, Int32 posErrHandle, short chn);
MTN_API short __stdcall OEM_ScanGetPosErrLmt(HAND devHandle, Int32* pMaxPosErr, Int32* pOverTime, Int32* pPosErrHandle, short chn);

// 振镜运动,设置快速传输功能开关
// onOff:0: 关闭,SDK会自动根据固件判断是否支持高速传输，支持则会自动启用，所以这里只能强制关闭
// 注意:要求在振镜启用,即OEM_ScanEn指令之后调用
MTN_API Int16 __stdcall OEM_ScanSetFastTransferOnOff(HAND devHandle, Int16 onOff, Int16 chn);
MTN_API Int16 __stdcall OEM_ScanGetFastTransferOnOff(HAND devHandle, Int16 *pOnOff, Int16 chn);

// 直线插补
MTN_API Int16 __stdcall OEM_ScanBufLineTo(HAND devHandle, Int32 x, Int32 y, Int32 z, double vel, Int16 chn);
// 椭圆弧（圆）插补
// 输入参数：
// leftTopX,leftTopY:左上角坐标
// rightBottomX,rightBottomY:右下角坐标
// arcStartAng:圆弧的起始角度
// arcEndAng:圆弧的结束角度
// rotAng:整体的旋转角度
// vel:速度
MTN_API Int16 __stdcall OEM_ScanBufEllipseArc(HAND devHandle, Int32 leftTopX, Int32 leftTopY, Int32 rightBottomX, Int32 rightBottomY, double arcStartAng, double arcEndAng, double rotAng,double vel, Int16 chn);
// 加载校准文件
MTN_API Int16 __stdcall OEM_ScanLoadCalibFile(HAND devHandle, char *pFileName, Int16 chn);

// 飞行加工参数，待完善
typedef struct TScanOnFlyPara
{
    Int16 followEn;             // 跟随功能是否激活
    Int16 followAxMode;         // 跟随方向：X/Y/XY
    Int16 xDirEncChn;           // x方向编码器通道
    Int16 yDirEncChn;           // y方向编码器通道

    double xDirEncCoef;         // x方向编码器传动比,pulse->mm
    double yDirEncCoef;         // y方向编码器传动比
    double xDirScanCoef;         // x方向振镜的传动比,bit->mm
    double yDirScanCoef;         // y方向振镜的传动比
    double mechAng;             // 机械角度,单位:rad
    Int16 reserved[14];         // 保留

}TScanOnFlyPara;
MTN_API Int16 __stdcall OEM_ScanOnFlySetPara(HAND devHandle, TScanOnFlyPara*pPara, Int16 chn);


//------------------------------------------------------------------------------------------------------------
//
//         事件
//
//------------------------------------------------------------------------------------------------------------
#define EVENT_MAX_CHN        8

// event src
#define EVENT_SRC_PRFPOS    0                // 规划位置
#define EVENT_SRC_ENCPOS    1                // 实际位置
#define EVENT_SRC_ADC       2                // ADC
#define EVENT_SRC_TICK_US   3                // 定时事件，compVal1表示触发的间隔，单位us
#define EVENT_SRC_DI        4                // DI变化，eventIdx表示DI序号，


// event dir
#define EVENT_DIR_BIGGER        0            // 大于
#define EVENT_DIR_SMALLER       1            // 小于
#define EVENT_DIR_EQUAL         2            // 等于
#define EVENT_DIR_NOT_BIGGER    3            // 不大于
#define EVENT_DIR_NOT_SMALLER   4            // 不小于
#define EVENT_DIR_NOT_EQUAL     5            // 不等于
#define EVENT_DIR_POS_PASS		6			// 正向穿越
#define EVENT_DIR_NEG_PASS		7			// 负向穿越

// action ID
#define EVENT_ACTION_NONE           0        // 不执行任何的动作
#define EVENT_ACTION_SETDO          1        // 设置DO（idx:组号，param1:输出位掩码，param2:输出值掩码
#define EVENT_ACTION_PTP_VEL        2        // 更新PTP的速度（idx:轴号，param1:速度，param2:保留
#define EVENT_ACTION_PTP_START      3        // 启动PTP的运动（idx:轴掩码，param1:保留，param2:保留
#define EVENT_ACTION_PTP_STARTEX    4        // 启动PTP的运动（idx:轴掩码，param1:0，param2:目标位置
#define EVENT_ACTION_CRDSTOP        5        // 停止Crd运动（idx:坐标系掩码，param1:0缓停1急停，param2:保留
#define EVENT_ACTION_AXSTOP         6        // 停止轴运动（idx:轴掩码，param1:0缓停1急停，param2:保留
#define EVENT_ACTION_SET_DAC        7        // 设置模拟量输出（idx:通道号，param1:模拟量输出数值[-32768,32767]，param2:保留
#define EVENT_ACTION_DI_RAW_CHG     8        // DI原始信号被改变（上升沿或下降沿）eventPara1:di类型，eventPara2：组号，eventPara3：序号
#define EVENT_ACTION_DI_CHG         9        // DI信号被改变（上升沿或下降沿）eventPara1:di类型，eventPara2：组号，eventPara3：序号
#define EVENT_ACTION_DO_CHG         10        // DO信号被改变，eventPara1:do类型，eventPara2：组号，eventPara3：序号
#define EVENT_ACTION_POS_CHG        11        // 轴位置改变，eventPara1:轴号，eventPara2：模式


typedef struct  TEventConfig
{
    Int16 eventSrc;                            // 事件的源，如EVENT_SRC_PRFPOS
    Int16 eventIdx;                            // 事件的序号，比如当源为规划位置时，这里指哪个轴
    Int16 dir;                                // 方向,如EVENT_DIR_BIGGER等
    Int16 errZone;                            // 误差
    Int32 trigCnt;                            // 触发次数，最多触发的次数，设为0，表示一直会触发
    Int32 eventReserved[3];                    // 保留，请设为0
    double compVal1;                            // 比较值
    
    Int16 actionType;                        // 事件触发后的动作类型
    Int16 actionIdx;                        // 动作序号
    F32 actionParam1;                        // 动作参数
    F32 actionParam2;                        // 动作参数2
    Int16 actionReserved[6];                // 保留
    
    #ifdef MTN_ST_INIT_EN
     TEventConfig(){
     eventSrc = 0;
     eventIdx = 0;
     dir = 0;
     errZone = 0;
     trigCnt = 0;
     eventReserved[0] = eventReserved[1] = eventReserved[2] = 0;
     compVal1 = 0;
     actionType = 0;
     actionIdx = 0;
     actionParam1 = actionParam2 = 0;
     actionReserved[0] = actionReserved[1] = actionReserved[2] = actionReserved[3] = actionReserved[4] = actionReserved[5] = 0;
    }
    #endif
} TEventConfig;

// 事件配置
// pEventCfg:配置参数，参见结构体定义
// chn:通道号，取值范围[0,EVENT_MAX_CHN)
MTN_API Int16  __stdcall OEM_DevEventSetConfig(HAND devHandle, TEventConfig *pEventCfg,Int16 chn);

// 获取事件配置
// pEventCfg:配置参数，参见结构体定义
// chn:通道号，取值范围[0,EVENT_MAX_CHN)
MTN_API Int16  __stdcall OEM_DevEventGetConfig(HAND devHandle,TEventConfig *pEventCfg,Int16 chn);

// 获取事件开关
// onOff:开关，0:关 1:开
// chn:通道号，取值范围[0,EVENT_MAX_CHN)
MTN_API Int16  __stdcall OEM_DevEventSetOnOff(HAND devHandle,Int16 onOff,Int16 chn);

// 获取状态
// pOnOff:开关状态，0:关 1:开
// pTrigCnt:触发计数
// chn:通道号，取值范围[0,EVENT_MAX_CHN)
MTN_API Int16  __stdcall OEM_DevEventGetSts(HAND devHandle,Int16 *pTrigCnt,Int16 *pOnOff,Int16 chn);

// 缓冲区配置事件及开关
// pEventCfg:配置信息
// onOff:是否立即开启关闭
// chn:通道号，取值范围[0,EVENT_MAX_CHN)
MTN_API Int16  __stdcall OEM_CrdBufEventSetConfig(HAND crdHandle,Int32 segNo,TEventConfig *pEventCfg,Int16 onOff,Int16 chn);

// 缓冲区事件开关
// onOff:是否立即开启关闭
// chn:通道号，取值范围[0,EVENT_MAX_CHN)
MTN_API Int16  __stdcall OEM_CrdBufEventSetOnOff(HAND crdHandle,Int32 segNo,Int16 onOff,Int16 chn);

// 缓冲区等待事件触发
// trigCnt:触发的事件计数
// timeOut:超时 单位:ms
// chn:通道号，取值范围[0,EVENT_MAX_CHN)
MTN_API Int16  __stdcall OEM_CrdBufEventWait(HAND crdHandle,Int32 segNo,Int16 trigCnt,Int32 timeOut,Int16 chn);

// 机构示教开始
// startPos:起始位置，单位:脉冲
// interval:间隔，单位:脉冲
// sectCount:示教的段数
// pFileNameToSaveTechData:示教数据的存储文件
MTN_API Int16  __stdcall OEM_MtLeadScrewTechRun(HAND axisHandle,Int32 startPos,Int32 interval,Int32 sectCount,char *pFileNameToSaveTechData);

// 机构示教过程状态查询
// pRun:运行状态，0：停止中，1：正在运行，其他：错误代码
// pPercent:运行的进度百分比
MTN_API Int16  __stdcall OEM_MtLeadScrewTechSts(HAND axisHandle,Int16 *pRun,Int16 *pPercent);

// 机构示教强制终止
MTN_API Int16  __stdcall OEM_MtLeadScrewTechBreak(HAND axisHandle);

// 加载机构示教数据
// pFileNameTechData:数据文件名
MTN_API Int16  __stdcall OEM_MtLeadScrewTechLoad(HAND axisHandle,char *pFileNameTechData);



// 单轴编码器的配置
typedef struct TEncoderCfg
{
    Int16 encoderIdx;           // 编码器编号，取值范围[0,n],256表示辅助编码器,-1表示无编码器,即规划
    Int16 encoderMode;          // 编码器模式，请参考NMC_SetEncMode说明,-1表示不对编码器模式进行配置
    Int16 reserved[6];          // 保留
    
    #ifdef MTN_ST_INIT_EN
    TEncoderCfg(){
     encoderIdx = 0;
     encoderMode = 0;
     reserved[0] = reserved[1] = reserved[2] = reserved[3] = reserved[4] = reserved[5] = 0;
    }
    #endif
}TEncoderCfg;

//设置单轴编码器的配置
MTN_API Int16  __stdcall OEM_MtSetEncCfg (HAND axisHandle,TEncoderCfg *pPara);

//获取单轴编码器的配置
MTN_API Int16  __stdcall OEM_MtGetEncCfg (HAND axisHandle,TEncoderCfg *pPara);


// 两段速PTP运动
// pPrfTime:对于规划位置触发，返回整个规划需要的时间
MTN_API Int16  __stdcall OEM_MtMovePtpAbsTwoStageEx(HAND axisHandle,TPtpTwoStagePrm *pPrm,double *pPrfTime);

// 功能：2维位置比较自动连续输出
// onOff： 0 停止,1输出 注意：NMC_Comp2DimensOnoff关闭也可以实现关闭连续输出
// group:组号,0 或者1
// outInteval:输出间隔，单位us
// outCnt:输出次数
// chn:保留,设为0
MTN_API Int16 __stdcall OEM_Comp2DimensOutPulse(HAND devHandle,Int16 group,Int16 onOff,Int32 outInteval,Int32 outCnt,Int16 chn);

// 功能：2维位置比较自动连续输出,缓冲区指令
// onOff： 0 停止,1输出 注意：NMC_Comp2DimensOnoff关闭也可以实现关闭连续输出
// group:组号,0 或者1
// outInteval:输出间隔，单位us
// outCnt:输出次数
// chn:保留,设为0
MTN_API Int16 __stdcall OEM_CrdBufComp2DimensOutPulse(HAND crdHandle,Int32 segNo,Int16 group,Int16 onOff,Int32 outInteval,Int32 outCnt,Int16 chn);

// 缓冲区2维位置比较开关
MTN_API short __stdcall OEM_CrdBufComp2DimensOnOff(HAND crdHandle, Int32 segNo, short group, short  onOff, short  chn);

// DO输出PWM功能
typedef struct TDoOutPWMParam
{
    Int16 doType;           // 输出通道的类型，参考DO_TYPE
    Int16 doGroup;          // 输出通道的组号
    Int16 doIdx;            // 输出通道的序号
    Int16 reserved;         // 保留
    Int32 pwmPeriod;        // PWM的周期，单位:us
    Int32 pwmWidth;         // PWM的脉宽，单位:us
    Int32 reserved2[2];     // 保留

#ifdef MTN_ST_INIT_EN
    TDoOutPWMParam() {
        doType = 4; doGroup = 0; doIdx = 0;
        reserved2[0] = reserved2[1] = reserved = 0;
        pwmPeriod = 2000; pwmWidth = 1000;  
    }
#endif
}TDoOutPWMParam;

// DO输出PWM：设置参数
// pParam:参数
// group:组号，取值范围[0,n)
MTN_API Int16 __stdcall NMC_DoOutPWMSetParam(HAND devHandle, TDoOutPWMParam* pParam, Int16 group);
MTN_API Int16 __stdcall NMC_DoOutPWMGetParam(HAND devHandle, TDoOutPWMParam *pParam, Int16 group);

// DO输出PWM：开关输出
// group:组号，取值范围[0,n)
// outCnt：输出计数
// onOff:是否开始输出,0:关闭输出  1:开始输出
MTN_API Int16 __stdcall NMC_DoOutPWMOnOff(HAND devHandle, Int16 onOff, Int32 outCnt,Int16 group);

// DO输出PWM：获取状态
// group:组号，取值范围[0,n)
// pOnOff:开关状态
// pOutCnt:当前的输出计数
MTN_API Int16 __stdcall NMC_DoOutPWMGetSts(HAND devHandle, Int16 *pOnOff, Int32 *pOutCnt,Int16 group);


// PT及PVT OEM
// 查询PT数据剩余空间大小
// pSpace:返回的剩余空间大小
// pUsed: 已使用的空间段数
// fifo:在数据贮存模式下，使用的FIFO编号，取值范围[0,1]
MTN_API Int16  __stdcall OEM_MtPtGetSpaceEx(HAND axisHandle,Int16 *pSpace,Int16 *pUsed,Int16 fifo);

// 向Pt运动缓存区中压运动数据段
// count:压入的数据段数
// pPosArray:段运行距离
// pTimeArray:段运行时间
// pTypeArray:段类型,见宏定义
// fifo:在数据贮存模式下，使用的FIFO编号，取值范围[0,1]
MTN_API Int16  __stdcall OEM_MtPtPushEx(HAND axisHandle,Int16 count,double *pPosArray,Int32 *pTimeArray,Int16 *pTypeArray,Int16 fifo);

// 清空PT数据
// fifo:在数据贮存模式下，使用的FIFO编号，取值范围[0,1]
MTN_API Int16  __stdcall OEM_MtPtBufClrEx(HAND axisHandle,Int16 fifo);

// 启动Pt运动
// otherSynAxCnts： 不包括axisHandle 的其他同步启动轴数量
// pOtherSynAxArray: 其他同步启动轴的序号：0~N    
// fifo:在数据贮存模式下，使用的FIFO编号，取值范围[0,1]
MTN_API Int16  __stdcall OEM_MtPtStartMtnEx(HAND axisHandle,Int16 otherSynAxCnts,Int16 *pOtherSynAxArray,Int16 fifo);

// 向PVT运动缓存区中压运动数据段
// count:压入的数据段数：1~32
// pPosArray:段运行距离
// pTimeArray:段运行时间
// pVelArray:段运行速度
// fifo:在数据贮存模式下，使用的FIFO编号，取值范围[0,1]
MTN_API Int16  __stdcall OEM_MtPvtDataEx(HAND axisHandle,Int16 count,double *pPosArray,double *pTimeArray,double *pVelArray,Int16 fifo);

// 查询PVT数据剩余空间大小
// pFreeSpace:返回的剩余空间大小
// pUsedSpace: 已使用的空间段数
// fifo:在数据贮存模式下，使用的FIFO编号，取值范围[0,1]
MTN_API Int16  __stdcall OEM_MtPvtBufGetSpaceEx(HAND axisHandle,Int16 *pFreeSpace,Int16 *pUsedSpace,Int16 fifo);

// 清空PVT数据
// fifo:在数据贮存模式下，使用的FIFO编号，取值范围[0,1]
MTN_API Int16  __stdcall OEM_MtPvtBufClrEx(HAND axisHandle,Int16 fifo);

// 启动Pvt运动
// otherSynAxCnts： 不包括axisHandle 的其他同步启动轴数量
// pOtherSynAxArray: 其他同步启动轴的序号：0~N    
// fifo:在数据贮存模式下，使用的FIFO编号，取值范围[0,1]
// 注：同步的轴必须属于同一个控制器
MTN_API Int16  __stdcall OEM_MtPvtStartMtnEx(HAND axisHandle,Int16 otherSynAxCnts,Int16 *pOtherSynAxArray,Int16 fifo);

// 获取编码器位置（补偿前）
// pEncPosEx:补偿前的编码器位置
MTN_API Int16  __stdcall OEM_MtGetEncPosEx(HAND axisHandle,Int32 *pEncPosEx);

// PTPBufMv
#define PTPBUFMV_MAX_GROUP        4        // 最大的组数
#define PTPBUFMV_MAX_AX            4        // 最大的参与轴数量
#define PTPBUFMV_MAX_SEC        4        // 最大的段数

// Ptp运动单元
typedef struct TPtpBufMvUnit
{
    F32 acc;
    F32 dec;
    F32 velS;
    F32 velE;
    F32 velMax;
    Int32 tgtPos;
    Int16 smooth;
    Int16 setDelay;
    Int16 reserved[4];
    
    #ifdef MTN_ST_INIT_EN
    TPtpBufMvUnit(){
        acc = 0.5;
        dec = 0.5;
        velS = 0;
        velE = 0;
        velMax = 1;
        tgtPos = 0;
        smooth = 0;
        setDelay = 0;
        reserved[0] = reserved[1] = reserved[2] = reserved[3] = 0;
    }
    #endif
}TPtpBufMvUnit;

//// Ptp运动单元
//typedef struct TPtpBufMvUnit
//{
//    F32 acc;
//    F32 dec;
//    F32 velS;
//    F32 velE;
//    F32 velMax;
//    Int32 tgtPos;
//    Int16 smooth;
//    Int16 setDelay;
//    F32 twoStageNewVel;        // 二段速的新速度，为0表示不启用二段速
//    Int32 twoStageChgPos;        // 二段速:更新速度的位置，为0表示不启用二段速
    
    //#ifdef MTN_ST_INIT_EN
    //TPtpBufMvUnit(){
    //    Int32 tgtPos = 0;
    //    Int16 smooth = 0;
    //    Int16 setDelay = 0;
    //    Int32 twoStageChgPos = 0;
    //}
    //#endif
//}TPtpBufMvUnit;

typedef struct TPtpBufMvSts
{
    Int16 run;                // 0:Stop,1:running;2:error
    Int16 errCode;            // 错误代码
    Int16 curUnitIdx;        // 当前执行的单元序号
    Int16 reserved[3];        // 其他
    
}TPtpBufMvSts;

// 压入Ptp多轴运动参数
// axisCnt:参与的轴数量，取值范围[1,4]
// pAxisList:参与的轴列表数组
// unitCnt:运动的段数量，取值范围[1,4]
// pMvUnitList:运动的段数组列表，数组长度为axisCnt*unitCnt
// group:组号，取值范围[0,1]
MTN_API Int16  __stdcall OEM_PtpBufMvPushData(HAND devHandle,Int16 axisCnt,Int16 *pAxisList,Int16 unitCnt,TPtpBufMvUnit *pMvUnitList,Int16 group);

// 设置PtpBuf指定轴及工作单元的目标位置
// axisIdx:参与的轴序号,取值:[0,axisCnt)
// unitIdx:单元序号，取值:[0,n]
// unitCnt:运动的段数量，取值范围[1,unitCnt)
// tgtPos:新的目标位置
// group:组号，取值范围[0,1]
MTN_API Int16  __stdcall OEM_PtpBufSetDataTgtPos(HAND devHandle,Int16 axisIdx,Int16 unitIdx,Int32 tgtPos,Int16 group);

// 获取PtpBuf某个工作单元数据
// pMvUnit:运动的段数据
MTN_API Int16  __stdcall OEM_PtpBufGetDataUnit(HAND devHandle,Int16 axisIdx,Int16 unitIdx,TPtpBufMvUnit *pMvUnit,Int16 group);

// 启动Ptp多轴运动
// group:组号，取值范围[0,1]
MTN_API Int16  __stdcall OEM_PtpBufMvStart(HAND devHandle,Int16 group);

// 启动Ptp多轴运动
// group:组号，取值范围[0,1]
// startDelay:启动前的延时
MTN_API Int16  __stdcall OEM_PtpBufMvStartEx(HAND devHandle,Int16 startDelay,Int16 group);

// 停止Ptp多轴运动
// group:组号，取值范围[0,1]
MTN_API Int16  __stdcall OEM_PtpBufMvStop(HAND devHandle,Int16 group);

// 运行状态
#define PTPBUFMV_STS_STOP		0		// 停止，未运行或者被停止
#define PTPBUFMV_STS_RUN		1		// 运行
#define PTPBUFMV_STS_DONE		2		// 运行完成
#define PTPBUFMV_STS_ERR		3		// 错误，错误代码可查看

// 查询Ptp多轴运动状态
// group:组号，取值范围[0,1]
// pSts:状态
MTN_API Int16  __stdcall OEM_PtpBufMvSts(HAND devHandle,TPtpBufMvSts *pSts,Int16 group);

//-------------------------------------------------------------------------------
//2.多维位置比较
//-------------------------------------------------------------------------------
#define COMPXDIMENSEX_MAX_AX    6

typedef struct  TCompXDimensExParam
{
    Int16 axCnt;                // 参与的轴数量，取值[1,6]
    Int16 axList[COMPXDIMENSEX_MAX_AX];            // 参与的轴列表
    Int16 outType;                // 输出方式0：脉冲1：电平
    Int16 outChnType;            // 通道类型：0 GPO, 1  GATE通道
    Int16 outChnIdx;            // 比较输出信号的通道号，取值[0,n]
    Int16 posSrc;                // 轴位置类型 ：0规划1：编码器
    Int16 stLevel;                // 电平模式下的起始电平（0或1）
    Int32 gateTime;                // 脉冲方式脉冲时间,单位us
    Int32 errZone;                // 进入比较点容差半径范围（pulse）
    Int32 directOutZone;            // 近距离直接触发范围
    Int32 reserved[7];            // 保留，默认值 0（不使用）
    
    #ifdef MTN_ST_INIT_EN
     TCompXDimensExParam(){
     axCnt = 0;
     memset(axList,0,sizeof(Int16)*COMPXDIMENSEX_MAX_AX);
     memset(reserved,0,sizeof(Int32)*7);
     outType = 0;
     outChnType = 0;
     outChnIdx = 0;
     posSrc = 0;
     stLevel = 0;
     gateTime = 0;
     errZone = 0;
     directOutZone = 0;
    }
    #endif
} TCompXDimensExParam;

// 设置多维位置比较
// pParam:参数  group:组号，取值[0,n]
MTN_API Int16 __stdcall OEM_CompXDimensExSetParam(HAND devHandle,TCompXDimensExParam *pParam,Int16 group);
MTN_API Int16 __stdcall OEM_CompXDimensExGetParam(HAND devHandle,TCompXDimensExParam *pParam,Int16 group);

// 功能：设置多维位置比较数据
// pArrayPos:比较数据位置值
// count:位置点数,count=0表示清除已经缓存的数据。一次性最多压入128组数据
// group:组号,0 或者1
MTN_API Int16 __stdcall OEM_CompXDimensExSetData(HAND devHandle,Int32 *pArrayPos,Int16 count,Int16 group);

// 功能：清除多维位置比较数据
MTN_API Int16 __stdcall OEM_CompXDimensExClrData(HAND devHandle,Int16 group);

// 功能：多维位置比较使能
// onOff： 0 停止,1输出  
MTN_API Int16 __stdcall OEM_CompXDimensExOnoff(HAND devHandle,Int16 onOff,Int16 group);

// 功能：多维位置比较手动输出
MTN_API Int16 __stdcall OEM_CompXDimensExManual(HAND devHandle,Int16 outCnt,Int16 group);

typedef struct  TCompXDimensExSts
{
    Int16 sts;                // 运行状态，0 空闲 1 忙
    Int16 reserved1;        // 保留
    Int32 freeSpace;            // 控制器剩余空间
    Int32 usedSpace;            // 剩余位置比较点
    Int32 outCount;            // 已经输出的个数
    Int32 reserved2[4];        // 保留
} TCompXDimensExSts;

// 功能：多维位置比较的输出状态
// pStatus: 状态结构体
// group:组号,0 或者1
MTN_API Int16 __stdcall OEM_CompXDimensExGetSts(HAND devHandle,TCompXDimensExSts *pStatus,Int16 group);

// 按照continues的方式计算PVT各个数据点，并将计算结果返回
// count:数据点个数
// pPos:输入的位置数组
// pVel:输入的速度数组
// pPercent:输入的数据点百分比数组，[0,100]
// pVelMax:输入的最大速度数组
// pAcc:输入的加速度数组
// pDec:输入的减速度数组
// pResultDataCnt:计算得到的数据点个数
// pResultPvtPArray:计算得到的位置数组
// pResultPvtVArray:计算得到的速度数组
// pResultPvtTArray:计算得到的时间数组
MTN_API short  __stdcall OEM_PvtContinuousCalc(Int32 count, double* pPos, double* pVel, double* pPercent, double* pVelMax, double* pAcc, double* pDec,
    Int16* pResultDataCnt, double* pResultPvtPArray, double* pResultPvtVArray, double* pResultPvtTArray);

// 按照continues的方式计算PVT各个数据点，并将计算结果压入PVT缓冲区
// pPos: 相对当前位置的移动位置，单位:pulse
MTN_API short  __stdcall OEM_PvtContinuousData(HAND axisHandle, Int32 count, double* pPos, double* pVel, double* pPercent,
                            double* pVelMax, double* pAcc, double* pDec);

// 按照continues的方式计算PVT各个数据点，并将计算结果压入PVT缓冲区,单点模式
MTN_API short  __stdcall OEM_PvtContinuousDataPt(HAND axisHandle, double relPos, double velMax, double acc, double dec, double percent);



typedef struct  TCrdStopExParam
{
    Int16 stopSrcType;        // 检查的信号类型，0:激光开关，1:GPO
    Int16 stopSrcChn;        // 检查的信号通道号，取值范围[0,n]
    Int16 stopOnSns;        // 停止位置的开关状态,对于激光，0表示激光关闭；对于GPO，0表示低电平
    Int16 reserved[5];        // 保留
    
    #ifdef MTN_ST_INIT_EN
     TCrdStopExParam(){
     stopSrcType = 0;
     stopSrcChn = 0;
     stopOnSns = 0;
     reserved[0] = reserved[1] = reserved[2] = reserved[3] = reserved[4] = 0;
    }
    #endif
} TCrdStopExParam;

// 坐标系停止，停止在特定位置
// pParam:参数，参考结构体定义
MTN_API Int16  __stdcall OEM_CrdStopMtnEx(HAND crdHandle, TCrdStopExParam *pParam);


typedef struct  TPtpMoveCmpPara
{
    F32 acc;        // 运动参数:加速度
    F32 dec;        // 运动参数:减加速度
    F32 maxVel;    // 运动参数:最大速度
    F32 sVel;        // 运动参数:起点速度
    F32 eVel;        // 运动参数:终止速度
    Int32  smooth;    // 运动参数:平滑系数
    Int32  tgtPos;    // 运动参数:目标位置
    
    Int16 outMode;                 // 比较输出:输出模式:0:匀速段等间距输出 1:指定位置输出
    Int16 posSrc;                 // 比较输出:比较轴位置类型 ：0:规划  1：编码器
    Int16 cmpInterval;            // 比较输出:输出模式outMode=0下的比较间隔，单位:脉冲
    Int16 outChnType;              // 比较输出:输出信号的通道类型：0 GPO, 1  GATE通道
    Int16 outChnIdx ;            // 比较输出:输出信号的通道号，取值[0,n]
    Int16 reserved1;            // 比较输出:保留1，默认值 0（不使用）
    Int32 gateTime;                 // 比较输出:脉冲方式脉冲时间,单位us
    Int32 reserved[7];            // 比较输出:保留，默认值 0（不使用）

    
    #ifdef MTN_ST_INIT_EN
     TPtpMoveCmpPara(){
        acc = 0.5;
        dec = 0.5;
        maxVel = 1;
        sVel = 0;
        eVel = 0;
        smooth = 0;
        tgtPos = 0;
        outMode = 0;
        posSrc = 0;
        cmpInterval = 0;
        outChnType = 0;
        outChnIdx  = 0;
        reserved1 = 0;
        gateTime = 0;
        reserved[0] = reserved[1] = reserved[2] = reserved[3] = reserved[4] = reserved[5] = reserved[6] = 0;
    }
    #endif
} TPtpMoveCmpPara;

// 单轴运动位置比较输出
// axisHandle:运动轴号
// pParam:单轴运动位置比较输出参数
// outMode1PosCnt:位置比较点数量，仅当outMode=1时有效
// pPosArray:位置比较点的位置数组，仅当outMode=1时有效
// pActlOutCnt:返回实际的输出计数
// chn:位置比较通道号，取值范围[0,1]
MTN_API Int16  __stdcall OEM_MtMovePtpCmpOut(HAND axisHandle, TPtpMoveCmpPara *pParam,Int32 outMode1PosCnt,Int32 *pPosArray,Int32 *pActlOutCnt,Int16 chn);


// 单轴点位运动时间计算,仅计算规划时间，不启动任何运动
// acc:加速度,dec：减速度,startVel:起跳速度,endVel:终止速度,smoothCoef:平滑系数
// maxVel：最大速度
// pos:相对运动位置,单位：脉冲
// isAbsPos:0:表示pos为相对位置，1:表示pos为绝对位置
// pPrfTimeMs:运动消耗的时间，单位:毫秒
MTN_API Int16  __stdcall OEM_MtGetPtpRelTime(HAND axisHandle,double acc,double dec,double velS,double velE,
    double velMax,Int16 smoothCoef,Int32 pos,Int16 isAbsPos,double *pPrfTimeMs);

// 设置DO的上电默认输出值
// doType:do类型，只支持GPO，设为DO_TYPE_GPDO
// group:组号，只支持GPO0
// doInitValue:do的上电默认输出值
MTN_API Int16 __stdcall OEM_SetDOInitState(HAND devHandle,Int16 doType,Int16 group,Int32 doInitValue);
// 获取DO的上电默认输出值
MTN_API Int16 __stdcall OEM_GetDOInitState(HAND devHandle,Int16 doType,Int16 group,Int32 *pDoInitValue);

// 点位平滑
// acc:加速度
// dec:减加速度
// velS,velE,velMax:起跳速度,终止速度,最大速度,单位:pulse/ms
// tgtPos:目标位置
// smoothPercentAcc:加速段的S曲线段在整个加速阶段的百分比,取值范围[0,100]
// smoothPercentDec:减速段的S曲线段在整个减速阶段的百分比,取值范围[0,100]
MTN_API Int16  __stdcall OEM_MtPtpSmoothPercent(HAND axisHandle,F32 acc,F32 dec,F32 velS,F32 velE,F32 velMax,Int32 tgtPos,F32 smoothPercentAcc,F32 smoothPercentDec);


typedef struct TCrdSPrfPara
{
    F32 maxJerk;              // 设定的最大加加速度
    F32 ratio;                // S平滑段在整个加减速过程所占的比例,取值范围[0,1],0表示没有S段，1表示全部为S段（无匀加速段）
    F32 minCrvLen;            // 启用平滑的最小的曲线长度，大于该设定值，则使用S曲线规划，单位:脉冲
    Int16 usePtpTimeFlag;       // 是否保持传统的梯形规划的时间，1：保持，则最大加速度可能会大于设定的合成加速度；0:不保持
    Int16 combineFlag;            // 是否激活自动合并
    F32 reserved[2];          // 保留

#ifdef MTN_ST_INIT_EN
    TCrdSPrfPara() {
        maxJerk = 0.3f;
        ratio = 0.6f;
        minCrvLen = 20;
        usePtpTimeFlag = 1;
        combineFlag = 1;
        reserved[0] = reserved[1] = 0;
    }
#endif
}TCrdSPrfPara;

// 设置坐标系S曲线规划参数
// onOff:是否打开功能，0:取消 1:打开
MTN_API Int16  __stdcall OEM_CrdSetSPrfPara(HAND crdHandle, TCrdSPrfPara *pParam,Int16 onOff);
MTN_API Int16  __stdcall OEM_CrdGetSPrfPara(HAND crdHandle, TCrdSPrfPara *pParam,Int16 *pOnOff);



// 获取当前的编码器位置，64位
// encId:编码器序号，取值范围[0,n]
// pEncPos:编码器位置，64位整形,单位:脉冲
MTN_API Int16 __stdcall OEM_GetEncPos64(HAND devHandle,Int16 encId,Int64 *pEncPos);

// 读捕获位置，64位整数
// pCaptPos : 捕获位置,单位:脉冲
MTN_API Int16  __stdcall OEM_MtGetCaptPos64  ( HAND axisHandle, Int64 *pCaptPos );

////////////////////////////////////////////////////////////////////////////////////////////////
#define PTP_SECTION_MAX_CNT        10                // 最大的分段数
 
typedef struct TPtpSectionVelLmt
{
    Int16 sectionCnt;                            // 速度分段数量
    Int16 revserved1;                            // 保留
    Int32 sectionStartPos;                        // 起始位置
    Int32 sectionPos[PTP_SECTION_MAX_CNT];        // 各段相对起点的位置
    F32 sectionMaxVel[PTP_SECTION_MAX_CNT];    // 各段最大速度
    Int32 reserved[8];                            // 保留
    
    #ifdef MTN_ST_INIT_EN
    TPtpSectionVelLmt(){
     sectionCnt = 0;
     revserved1 = 0;
     sectionStartPos = 0;
     memset(sectionPos,0,sizeof(Int32)*PTP_SECTION_MAX_CNT);
     memset(sectionMaxVel,0,sizeof(float)*PTP_SECTION_MAX_CNT);
     memset(reserved,0,sizeof(Int32)*8);
    }
    #endif
}TPtpSectionVelLmt;
// 设置点位分段速度限定参数
// pParam : 参数
MTN_API Int16  __stdcall OEM_MtPtpSectionSetParam  ( HAND axisHandle,TPtpSectionVelLmt *pParam );
MTN_API Int16  __stdcall OEM_MtPtpSectionGetParam  ( HAND axisHandle,TPtpSectionVelLmt *pParam );

// 启动运动
// acc,dec,startVel,endVel,maxVel,smoothCoef,tgtPos: 运动参数
MTN_API Int16  __stdcall OEM_MtPtpSectionMoveAbs(HAND axisHandle,double acc,double dec,double startVel,
    double endVel,double maxVel,Int16 smoothCoef,Int32 tgtPos);

// 获取指定位置的螺距补偿数据
// prfPos:计算的规划位置
// pPosCompPos:正向补偿位置
// pNegCompPos:负向补偿位置
MTN_API Int16  __stdcall OEM_MtGetLeadScrewCompPos(HAND axisHandle,Int32 prfPos,Int32 *pPosCompPos,Int32 *pNegCompPos);

// 坐标系增加叠加补偿
// pCompDistList:各轴的补偿值，单位pulse
// axMask:补偿的轴掩码
// syncAcc,syncDec:加速度及减速度2
// syncVel:最大合成速度
// eventChnToOff:执行成功后关闭事件通道号
MTN_API Int16  __stdcall OEM_CrdMvCompensate(HAND crdHandle,Int32 *pCompDistList,Int16 axMask,F32 syncAcc,F32 syncDec,F32 syncVel,Int16 eventChnToOff);

// 设置辅助轴的传动比系数
// axIdx:轴号，取值范围[0,n]
// axProp:轴的传动比系数，默认为1
MTN_API Int16  __stdcall OEM_CrdSetBufMvAxProp(HAND crdHandle,Int16 axIdx,double axProp);

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

// 功能:缓冲区设置位置
// posType:位置类型,bit0:编码器  bit1:轴编码器  bit2:规划位置，要求停止状态
// posIdx:位置序号，取值[0,n]
// setValue:设定值
// flag:标志位，保留
MTN_API Int16  __stdcall OEM_CrdBufSetPos(HAND crdHandle,Int32 segNo,Int16 posType,Int16 posIdx,Int32 setValue,Int32 flag);

// 功能:缓冲区保存变量到内部变量
// varType:需要保存的变量类型，0:编码器位置
// varIdx:需要保存的变量通道号
// saveToVarIdx:保存到内部变量的编号,如VAR_INNNER_VAR1
MTN_API Int16  __stdcall OEM_CrdBufSaveVar(HAND crdHandle,Int32 segNo,Int16 varType,Int16 varIdx,Int16 saveToVarIdx);

// 功能：位置比较进入位置范围则自动压入新数据，并启动比较
// group:组号,0 或者1
// encPosMin,encPosMax:位置比较X轴的编码器范围的最大值和最小值
// cmpPosCnt:压入的比较位置点数，取值范围[0,32]
// cmpPosArray:比较位置二维数组,如x0,y0,x1,y1...
// runFlag:0:停止工作，1:开始工作，2：立即压入数据并启动比较及工作
MTN_API Int16 __stdcall OEM_Comp2DimensAutoOn(HAND devHandle,Int16 group,Int32 encPosMin,Int32 encPosMax,Int16 cmpPosCnt,Int32 *cmpPosArray,Int16 flag);

// 功能：获取状态
// pRunSts:工作状态 1正在工作 0没有工作
// pErrCode:错误代码
// pSetCnt:工作计数
MTN_API Int16 __stdcall OEM_Comp2DimensGetAutoOnSts(HAND devHandle,Int16 group,Int16 *pRunSts,Int16 *pErrCode,Int32 *pSetCnt);


#define SHIOAHEAD_CHN_MAX    4
typedef struct  TSHIOAheadParam
{
    Int16 outputChn;                            // 比较输出的通道号，取值[0,n]
    Int16 outputType;                             // 输出方式0：脉冲1：电平
    Int16 chnType;                              // 通道类型：0 GPO, 1  GATE通道
    Int16 dir1No;                                 // 方向1 的位置源轴号（0~11）
    Int16 dir2No;                                 // 方向2 的位置源轴号（0~11）
    Int16 posSrc;                                 // 轴位置类型 ：0规划1：编码器
    Int16 stLevel;                                // 电平模式下的起始电平（0或1）
    Int16 errZone;                                 // 进入比较点容差半径范围（pulse）
    Int16  directOutZone;                        // 近距离直接触发范围
    Int16  vibrateRange;                        // 抖动滤波范围    
    Int32 gateTime;                                 // 脉冲方式脉冲时间,单位us
    Int32 minIntervalTime;                        // 最小触发时间间隔,单位us
    Int32 aheadTime;                                // 提前时间，单位us
    Int32 reserved[8];                            // 保留
    
    #ifdef MTN_ST_INIT_EN
     TSHIOAheadParam(){
        outputChn = 0;
        outputType = 0;
        chnType = 0;
        dir1No = 0;
        dir2No = 0;
        posSrc = 0;
        stLevel = 0;
        errZone = 0;
        directOutZone = 0;
        vibrateRange = 0;
        gateTime = 0;
        minIntervalTime = 0;
        aheadTime = 0;
        reserved[0] = reserved[1] = reserved[2] = reserved[3] = reserved[4] = reserved[5] = reserved[6] = reserved[7] = 0;
    }
    #endif
} TSHIOAheadParam;

// 设置提前输出参数
// aheadTime：提前输出信号的时间，单位us,小于等于0表示不启用
// chn:位置比较通道
MTN_API Int16 __stdcall OEM_CrdSHIOAheadSetParam( HAND crdHandle,TSHIOAheadParam *pParam,Int16 chn);

// 下载输出点位置
// pPosX:X方向的位置
// pPosY:Y方向的位置
// dataCnt:下载的数据点长度，取值范围[0,128]
MTN_API Int16 __stdcall OEM_CrdBufSHIOAheadSetData( HAND crdHandle, Int32 segNo, Int32 *pPosX,Int32 *pPosY,Int32 dataCnt,Int16 chn);

// 下载输出点位置
// pPosX:X方向的位置
// pPosY:Y方向的位置
// pPower:比较点能量
// dataCnt:下载的数据点长度，取值范围[0,128]
MTN_API short __stdcall OEM_CrdBufSHIOAheadSetDataEx(HAND crdHandle, Int32 segNo, Int32* pPosX, Int32* pPosY, Int16* pPower, Int32 dataCnt, short chn);

//------------------------------------------------------------------------------------------------------------
//    矩形区域限位
//------------------------------------------------------------------------------------------------------------

// 矩形区域限位参数
typedef struct TRectLimitPara
{  
    Int16 axX;            // X轴序号，取值范围[-1,n),-1表示不包含X轴，默认值
    Int16 axY;            // Y轴序号，取值范围[-1,n),-1表示不包含Y轴，默认值
    Int16 diType;        // di输入的类型，参考DI_TYPE
    Int16 diIdx;        // di的序号，取值范围[0,n)
    Int16 diSns;        // di触发的电平，0-低电平 1-高电平
    Int16 reserved1;    // 保留
    Int32 xMinPos;        // X方向的位置最小值
    Int32 xMaxPos;        // X方向的位置最大值
    Int32 yMinPos;        // Y方向的位置最小值
    Int32 yMaxPos;        // Y方向的位置最大值
    Int32 reserved[3];    // 保留 
    
    
    #ifdef MTN_ST_INIT_EN
    TRectLimitPara(){
        axX = 0;
        axY = 0;
        diType = 0;
        diIdx = 0;
        diSns = 0;
        reserved1 = 0;
        xMinPos = 0;
        xMaxPos = 0;
        yMinPos = 0;
        yMaxPos = 0;
        reserved[0] = reserved[1] = reserved[2] = 0;
    }
    #endif
}TRectLimitPara;

// 支持的最大组数
#define RECTLIMIT_MAX_GROUP 2

// 设置矩形限位区域 
// pPara:参数
// chn:通道号，可以设置多组，取值范围[0,MAX)
MTN_API Int16 __stdcall OEM_RectLimitSetPara(HAND devHandle,TRectLimitPara *pPara,Int16 chn);
MTN_API Int16 __stdcall OEM_RectLimitGetPara(HAND devHandle,TRectLimitPara *pPara,Int16 chn);

// 触发状态
#define RECT_LMT_STS_WAIT    0           // 状态:等待di触发或者手动开启
#define RECT_LMT_STS_CHECK   1           // 状态:进入检查状态
#define RECT_LMT_STS_TRIG    2           // 状态:限位触发

// 获取矩形限位区域的状态
// pOnOff:是否被激活 1-激活
// pTrigSts:触发状态
// chn:通道号，可以设置多组，取值范围[0,MAX)
MTN_API Int16 __stdcall OEM_RectLimitGetSts(HAND devHandle,Int16 *pOnOff,Int16 *pTrigSts,Int16 chn);

// 手动开启或关闭矩形限位区域
// onOff:激活或关闭
// 说明：只有手动开启的，才能被手动关闭
MTN_API Int16 __stdcall OEM_RectLimitSetOnOff(HAND devHandle,Int16 onOff,Int16 chn);

//------------------------------------------------------------------------------------------------------------
//    2D平面修正补偿
//------------------------------------------------------------------------------------------------------------
#define COMPEX2D_MAX_COMP_CHN_NUM    8
typedef struct T2DCompExPara
{  
    Int16 axSrcIdx;                                    // 参考轴序号，取值范围[0,n)
    Int16 posSrc;                                    // 参考位置类型，0表示规划，1表示编码器
    Int16 maxCompVel;                                // 每毫秒叠加的最大补偿值,单位pulse/ms,非正值自动设为32767
    Int16 compAxPosCnt;                                // 补偿轴有效通道数量
    Int32 compAxPos[COMPEX2D_MAX_COMP_CHN_NUM];        // 补偿轴各通道的对应位置值
    Int32 startPos;                                    // 补偿起始位置
    Int32 posInterval;                                // 补偿间隔，单位:pulse
    Int32 posNum;                                    // 补偿区间数量，取值范围[2,1024],注意补偿点数比补偿区数间大1
    Int16 reserved[4];                                // 保留 
    
    
    #ifdef MTN_ST_INIT_EN
    T2DCompExPara(){
        axSrcIdx = 0;
        posSrc = 0;
        maxCompVel = 0;
        compAxPosCnt = 0;
        memset(compAxPos,0,sizeof(Int32)*COMPEX2D_MAX_COMP_CHN_NUM);
        startPos = 0;
        posInterval = 0;
        posNum = 0;
        reserved[0] = reserved[1] = reserved[2] = reserved[3] = 0;
    }
    #endif
}T2DCompExPara;

// 设置2D平面修正补偿参数
MTN_API Int16  __stdcall  OEM_Mt2DCompExSetPara(HAND axisHandle,T2DCompExPara *pPara);
MTN_API Int16  __stdcall  OEM_Mt2DCompExGetPara(HAND axisHandle,T2DCompExPara *pPara);

// 设置2D平面修正补偿 补偿数据
// pData:补偿数据数组
// startIdx:补偿数据的起始序号
// dataCnt:设置的补偿数据的数量，取值范围[1,512]
MTN_API Int16  __stdcall  OEM_Mt2DCompExSetData(HAND axisHandle,Int16 *pData,Int16 startIdx,Int16 dataCnt,Int16 compChn);
MTN_API Int16  __stdcall  OEM_Mt2DCompExGetData(HAND axisHandle,Int16 *pData,Int16 startIdx,Int16 dataCnt,Int16 compChn);

// 设置2D平面修正补偿 开启或者关闭补偿
MTN_API Int16  __stdcall  OEM_Mt2DCompExSetOnOff(HAND axisHandle,Int16 onOff);

// 获取 2D平面修正补偿 状态
// pCompPos:当前的补偿值
MTN_API Int16  __stdcall  OEM_Mt2DCompExGetSts(HAND axisHandle,Int16 *pOnOff,Int32 *pCompPos);

//------------------------------------------------------------------------------------------------------------
//    用户直接补偿
//------------------------------------------------------------------------------------------------------------
// 设置直接补偿，补偿值直接叠加到对应轴上
// compValue:补偿值
// maxCompVel:每毫秒叠加的最大补偿值,单位pulse/ms,非正值自动设为32767
MTN_API Int16  __stdcall  OEM_MtSetUserCompValue(HAND axisHandle,Int16 compValue,Int16 maxCompVel);
// 设置直接补偿开关
// onOff:开关直接补偿
MTN_API Int16  __stdcall  OEM_MtSetUserCompOnOff(HAND axisHandle,Int16 onOff);

// 获取直接补偿设定值及状态
// pCompValue:补偿设定值
// pMaxCompVel:设定的最大补偿速度
// pOnOff:onOff状态
// pCurCompValue:当前的补偿值
MTN_API Int16  __stdcall  OEM_MtGetUserCompSts(HAND axisHandle,Int16 *pCompValue,Int16 *pMaxCompVel,Int16 *pOnOff,Int16 *pCurCompValue);


// 缓冲区设置用户补偿
// axIdx:轴号，取值范围[0,n)
// onOff:0:关闭  1:开启 2:开启后自动消除
MTN_API Int16  __stdcall  OEM_CrdBufSetUserCompValue(HAND crdHandle, Int32 segNo,Int16 axIdx,Int16 compValue, Int16 maxCompVel,Int16 onOff);



//------------------------------------------------------------------------------------------------------------
//    停止DI
//------------------------------------------------------------------------------------------------------------
#define STOP_DI_CHN_MAX     4       // 最大通道数量

// 停止类型
#define AX_STOP_TYPE_SOOMTH  0      // 停止类型：缓慢停止
#define AX_STOP_TYPE_ABRUPT  1      // 停止类型：急停，不会置起急停标志位
#define AX_STOP_TYPE_EMG     2      // 停止类型：急停，置起急停标志位


// 设置轴的停止DI
// diType:DI类型，参考DI type宏定义.负值表示关闭该通道
// diGroup:DI组号
// diIndex:DI组内的序号，取值范围[0,n)
// diSense:DI的电平，0：低电平 1：高电平
// stopType:停止类型，0:平滑停止，1:急停，2:急停并置急停标志位
// chn:通道，取值范围[0,4).通道之间同时作用，不同停止类型以数值大的为准
MTN_API Int16 __stdcall NMC_MtSetStopDIEx( HAND axisHandle, Int16 diType,Int16 diGroup,Int16 diIndex,Int16 diSense,Int16 stopType,Int16 chn);
MTN_API Int16 __stdcall NMC_MtGetStopDIEx( HAND axisHandle, Int16 *diType,Int16 *diGroup,Int16 *diIndex,Int16 *diSense,Int16 *stopType,Int16 chn);
// 获取停止DI的状态
// pActive:当前是否已经触发,-1:未激活，0：未触发，1:已经触发
// trigCnt:字设置后的触发计数
MTN_API Int16 __stdcall NMC_MtGetStopDIExSts( HAND axisHandle, Int16 *pActive, Int16 *trigCnt,Int16 chn);


//------------------------------------------------------------------------------------------------------------
//    编码器滤波
//------------------------------------------------------------------------------------------------------------
// 设置编码器的滤波参数,目前仅作为参考,可以通过NMC_GetEncVel读取
// encFilt:滤波系数，取值范围[0,64]
// filtMode:滤波模式，保留
// encIdx:编码器通道，取值范围[0,n)
MTN_API Int16 __stdcall NMC_SetEncFilt( HAND devHandle, Int16 encFilt,Int16 filtMode,Int16 encIdx);
MTN_API Int16 __stdcall NMC_GetEncFilt( HAND devHandle, Int16 *pEncFilt,Int16 *pFiltMode,Int16 encIdx);


//------------------------------------------------------------------------
//                                                     
//  分频                                              
//------------------------------------------------------------------------
typedef struct
{
    Int16 axMask;            // 选比较的轴号,按bit选择:不能超过2个bit同时为1     
    Int16 src;                // 比较源：1:编码器位置  0：规划位置
    Int16 startAxMsk;        // 启动位置对应的轴掩码，只支持一维
    Int16 startPosErrZone;    // 启动位置触发的误差带，单位：脉冲
    Int16 endAxMsk;            // 保留
    Int16 dirEn;            // 比较方向使能，0：双向，1：启用
    Int16 dir[2];            // 比较方向，1：正向，2：负向
    Int32  startPos[2];        // 启动位置，只支持一维
    Int32  endPos[2];        // 保留
    Int32 gateDistance;        // 位置间隔
    Int32 gateTime;            // 输出的脉冲宽度，单位us
    F32 reserved[4];        // 保留
    
    //#ifdef MTN_ST_INIT_EN
    //TLinearCmpDivPara(){
    //  startPos[2] = 0;
    //  endPos[2] = 0;
    // gateDistance = 0;
    // gateTime = 0;
    //}
    //#endif
}TLinearCmpDivPara;

// 功能：设置精确位置比较的参数，并清除线性位置比较位置数据
// pLinearCmpPara:位置比较参数
// ch：输出通道 目前只支持0
MTN_API Int16 __stdcall OEM_LinearCompSetConfig(HAND devHandle,TLinearCmpDivPara *pLinearCmpPara,Int16 ch);

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

// 功能：比较的输出状态
// pStatus: 0 未启动比较 1 比较输出中
// ch：输出通道 目前只支持0
MTN_API Int16 __stdcall OEM_LinearCompStatus(HAND devHandle,Int32 *pStatus,Int32 *pOutCnt,Int16 ch);


// 设置缓冲区激光能量跟随--扩展方法
// powerFilter:能量输出滤波系数，取值范围[0,32]，0：不开启（默认）
// followAdvMode:能量输出计算方法，3-频率数据脉宽可调模式
// overRide:跟随倍率,为0表示取消激光能量跟随
// param1,param2,param4:能量计算方法下的参数
//                对于模式3，param1为最大脉宽,单位us，param2计算时用到的加工速度，单位pulse/ms,param3计算时用到的设置能量值，输出频率，单位HZ
// ch:激光通道号,取值范围[0,n]
MTN_API Int16 __stdcall OEM_LaserSetFollowParamEx(HAND devHandle,Int16 powerFilter,
    Int16 followAdvMode,double overRide,double param1,double param2,double param3,Int16 ch);

// 高速版本的MoveAbs，需要特定固件支持
MTN_API Int16  __stdcall OEM_MtMovePtpAbsEx(HAND axisHandle,double acc,double dec,
	double startVel,double endVel,double maxVel,Int16 smoothCoef,Int32 tgtPos);

// 获取驱动版本
MTN_API Int16  __stdcall NMC_GetDriverVer(HAND devHandle,Int16 *pVerMain,Int16 *pVerSlv );

// 坐标系缓冲运动重新启动
MTN_API Int16 __stdcall OEM_CrdReStartMtn   ( HAND crdHandle );

typedef struct TOemPidCalcPara
{
    Int16 dacChn;        // 模拟量输出的通道号,轴模拟量取值[0,n),扩展模拟量从256开始
    Int16 encChn;        // 编码器通道的通道号,轴编码器通道取值[0,n),扩展模拟量从256开始
    Int16 ctrlMode;     // 控制模式
    Int16 reseved0;    // 保留
    
    
    //前馈刚度k    阻尼c
    double ratio;       // 传动比
    double targetVe;
    double k;
    double c;
    
    // pid
    double kp;            // kp
    double ki;            // ki
    double kd;            // kd

    //ADRC参数
    double b0;
    double Wc;
    double Wo;
    double h;
    double u ;
    double u0 ;
    double t ;

    double Z1;
    double Z2;
    double Z3;
 

    //TD相关
    double fh;
    double r;
    double v1;
    double v2;
    
    
    #ifdef MTN_ST_INIT_EN
    TOemPidCalcPara(){
     dacChn = 0;
     encChn = 0;
     ctrlMode = 0;
     reseved0 = 0;
     ratio = 0;
     targetVe = 0;
     k = 0;
     c = 0;
     kp = 0;
     ki = 0;
     kd = 0;
     b0 = 0;
     Wc = 0;
     Wo = 0;
     h = 0;
     u  = 0;
     u0  = 0;
     t  = 0;
     Z1 = 0;
     Z2 = 0;
     Z3 = 0;
     fh = 0;
     r = 0;
     v1 = 0;
     v2 = 0;
    }
    #endif
}TOemPidCalcPara;

// OEM PID计算：启动或关闭闭环控制
// onOff:启动或者关闭闭环控制
// tgtPos:目标位置，单位:mm
// chn:控制通道号，取值范围[0,n)
// pPidPara:参数
MTN_API Int16 __stdcall OEM_PIDCalc   ( HAND devHandle, double tgtPos,TOemPidCalcPara *pPidPara,Int16 onOff ,Int16 chn);

typedef struct TOemPosMapToDac
{
    Int16 dacChn;        // 模拟量输出的通道号,轴模拟量取值[0,n),扩展模拟量从256开始
    Int16 axIdx;        // 轴号,轴通道取值[0,n)
    Int16 posType;      // 轴位置类型 ：0:规划1：编码器
    Int16 reseved0;        // 保留，写0
    Int32 posMin;        // 位置最大值
    Int32 posMax;        // 位置最小值
    Int32 dacMaxVal;    // dac输出的最大值,取值范围[-32768,32767]
    Int32 dacMinVal;    // dac输出的最小值,取值范围[-32768,32767]
    Int32 reseved1[4];    // 保留，写0
 
    
    #ifdef MTN_ST_INIT_EN
    TOemPosMapToDac(){
     dacChn = 0;
     axIdx = 0;
     posType = 0;
     reseved0 = 0;
     posMin = 0;
     posMax = 0;
     dacMaxVal = 0;
     dacMinVal = 0;
     reseved1[0] = reseved1[1] = reseved1[2] = reseved1[3] = 0;
    }
    #endif
}TOemPosMapToDac;

// OEM 轴位置关联模拟量输出：指定的轴位置范围对应指定范围的模拟量输出
// pPara:参数 如上
// onOff:是否开启关联，1：开启 0：关闭
// chn:控制通道号，取值范围[0,n)
MTN_API Int16 __stdcall OEM_AxisPosMapToDac   ( HAND devHandle, TOemPosMapToDac *pPara,Int16 onOff ,Int16 chn);


MTN_API Int16  __stdcall NMC_IntStsGetSts(HAND devHandle,Int16 *pSts,UInt32 *pClk);
MTN_API Int16  __stdcall NMC_IntStsSetCfg(HAND devHandle,Int16 onOff,Int16 varCnt,Int16 *pVarTypeList,Int16 *pVarIdxList);

// 旋转转换合成速度计算
// dx，dy:阀与旋转中心的偏差,单位:pulse
// pathRadius:刀尖轨迹的圆弧半径
// followSide:跟随侧，0:外侧 1:内侧
// pathVel:刀尖的工作速度，单位:pulse/ms
// pSyncVel:计算返回的旋转中心的工作速度，单位:pulse/ms
// pIsBlock:是否应该用阻塞的单轴指令（中心轨迹太短)
MTN_API Int16 __stdcall OEM_RotateTransfCalcSyncVel(HAND crdHandle, double dx,double dy,double pathRadius,Int16 followSide,double ptVel,double *pSyncVel,Int16 *pIsBlock);

//------------------------------------------------------------------------------------------------------------
//    变量锁存功能
//------------------------------------------------------------------------------------------------------------
// 最多锁存的变量数
#define VAR_CAPT_NUM_MAX 12

// 触发变量定义
#define MC_VAR_CAPT_EVENT_DO (7)// DO 信号被改变，eventPara1:do 类型，eventPara2：组号，eventPara3：序号
#define MC_VAR_CAPT_EVENT_DI_RAW (8) // DI 原始信号被改变（上升沿或下降沿）eventPara1:di类型，eventPara2：组号，eventPara3：序号
#define MC_VAR_CAPT_EVENT_DI (9) // DI 信号被改变（上升沿或下降沿）eventPara1:di 类型，eventPara2：组号，eventPara3：序号

// 锁存变量定义，暂时支持下面几种
//#define MC_VAR_MtPrfPos (2) // 轴规划位置，32bit
//#define MC_VAR_EncPos (11) // 实际位置，32bit，varIdx 表示通道号
//#define MC_VAR_EncVel (12) // 实际速度，32bit 单精度浮点，varIdx 表示通道号

// 参数结构体
typedef struct TVarCaptPara
{
    Int16 eventType;        // 触发锁存的类型， 如MC_VAR_CAPT_EVENT_DO等
    Int16 eventPara1;        // 事件的参数1
    Int16 eventPara2;        // 事件的参数2
    Int16 eventPara3;        // 事件的参数3
    Int16 eventDir;         //  比较方向，大于等,参考EVENT_DIR_EQUAL等定义
    Int16 reserved1[3];     //  保留
    double compVal1;        // 比较值1
    double compVal2;        // 比较值2

    Int16 captVarCnt;      // 锁存的变量数量
    Int16 reserved2[7];    // 保留
    Int16 captVarList[VAR_CAPT_NUM_MAX];        // 变量列表，参考MC_VAR_EncPos定义 
    Int16 captVarIdxList[VAR_CAPT_NUM_MAX];     // 变量通道号定义
    
    #ifdef MTN_ST_INIT_EN
    TVarCaptPara(){
     eventType = 0;
     eventPara1 = 0;
     eventPara2 = 0;
     eventPara3 = 0;
     eventDir = 0;
     compVal1 = 0;
     compVal2 = 0;
     reserved1[0] = reserved1[1] = reserved1[2] = 0;
     memset(reserved2,0,sizeof(Int16)*7);
    }
    #endif
}TVarCaptPara;

// 变量锁存参数设置
// pPara:参数 如上
// chn:控制通道号，取值范围[0,n)
MTN_API Int16 __stdcall OEM_VarCaptSetPara   ( HAND devHandle, TVarCaptPara *pPara,Int16 chn);

// 变量锁存开关
MTN_API Int16 __stdcall OEM_VarCaptSetOnOff   ( HAND devHandle, Int16 onOff,Int16 chn);

// 变量锁存获取状态
// pOnOff:开光状态，0：关闭，1：打开 其他：错误代码
// pTrigCnt:触发计数
// pUsedSpaceByte:使用的空间大小
// pLeftSpaceByte:剩余空间大小
MTN_API Int16 __stdcall OEM_VarCaptGetSts   ( HAND devHandle, Int16 *pOnOff, Int32*pTrigCnt,Int32 *pUsedSpaceByte,Int32 *pLeftSpaceByte,Int16 chn);

// 变量锁存获取锁存数据
// pData:返回的数据，数据的组织根据变量类型排列
// toGetByte:期望读取的数据长度，单位:Byte,长度为数据单元的整数倍
// pGetByte:返回的实际数据的长度,单位:Byte,长度为数据单元的整数倍
MTN_API Int16 __stdcall OEM_VarCaptGetData   ( HAND devHandle, Int32 *pData,Int16 toGetByte,Int16 *pGetByte,Int16 chn);


typedef struct TMioConfig
{
    Int8 mioType;           // 映射的IO类型
    Int8 mioGroup;
    Int8 mioIdx;
    Int8 reverse;
    Int8 reserved[4];
    #ifdef MTN_ST_INIT_EN
    TMioConfig(){
     mioType = DI_TYPE_GPI;
     mioGroup = 0;
     mioIdx = 0;
     reverse = 0;
     reserved[0] = reserved[1] = reserved[2] = reserved[3] = 0;
    }
    #endif
} TMioConfig;
 
// 设置MotionIO的映射
// mioInOut:0:输入类型的mio  1:输出类型的mio
// mioType:设置的mio的类型，宏定义DI_TYPE等
// pDiCfg:配置的参数
MTN_API Int16  __stdcall NMC_MtSetMioConfig(HAND axisHandle,Int16 mioInOut,Int16 mioType,TMioConfig *pDiCfg);
MTN_API Int16  __stdcall NMC_MtGetMioConfig(HAND axisHandle,Int16 mioInOut,Int16 mioType,TMioConfig *pDiCfg);

// 设置坐标系运动限制，仅上位机前瞻下工作
typedef struct TCrdAxMvLimit
{
    double axMaxVel[CRD_MAX_DIMENSION]; // 单轴最大分解速度,为0则表示不进行限制
    double reserved[8];                 // 保留
 
    #ifdef MTN_ST_INIT_EN
    TCrdAxMvLimit(){
     axMaxVel[0] = axMaxVel[1] = axMaxVel[2] = axMaxVel[3] = 0;
     reserved[0] = reserved[1] = reserved[2] = reserved[3] = 0;
     reserved[4] = reserved[5] = reserved[6] = reserved[7] = 0;
    }
    #endif
} TCrdAxMvLimit;
MTN_API Int16  __stdcall OEM_CrdSetAxMvLimit(HAND crdHandle,TCrdAxMvLimit *pMvLmt);
MTN_API Int16  __stdcall OEM_CrdGetAxMvLimit(HAND crdHandle,TCrdAxMvLimit *pMvLmt);

//typedef struct TExtIOMapping
//{
//    Int8 ioType;                // 映射的IO类型: di/do/dac/adc
//    Int16 userChn;              // 用户访问通道号 如NMC_IODacSet指定的通道号
//    Int16 mdlSlv;               // IO所在的从站号，取值范围[0,n]
//    Int8 mdlIdx;                // IO所在从站的模块号，取值范围[0,n]
//    Int8 mdlChn;                // IO所在的通道号，取值范围[0,n]
//    Int8 bitOffset;             // 通道的bitOffset
//    Int8 bitLen;                // 通道的bit长度
//#ifdef MTN_ST_INIT_EN
//    TMioConfig() {
//        mioType = DI_TYPE_GPI;
//        mioGroup = 0;
//        mioIdx = 0;
//        reverse = 0;
//        reserved[0] = reserved[1] = reserved[2] = reserved[3] = 0;
//    }
//#endif
//} TExtIOMapping;


//------------------------------------------------------------------------------------------------------------
//    高度跟随功能
//    步骤：1.设置高度跟随参数
//          2.运动到轨迹起点，开启采样，通过坐标系运动，走完轨迹，到达终点后，结束采样
//          3.运动到轨迹起点，开启补偿，加工完成轨迹运动，关闭补偿
//------------------------------------------------------------------------------------------------------------
typedef struct THeightAdjusterPara
{
	Int16 mode;    //调高模式 0:采样adc,先采集后应用数据 1:采样设置的DAC值（通道号为adcChn指定）,先采集后应用数据
	Int16 axis;    //调高运动的轴号
	Int16 adcChn;  //调高使用的adc通道号 
	Int16 minVal;   //调高的最小电压 0~32767 对应 0~10V
	Int16 maxVal;   //调高的最大电压 0~32767 对应 0~10V
	Int16 limitVal; //调高允许的最大变化量 0~32767 对应 0~10V
	Int16 dir1No;  //X轴轴号
	Int16 dir2No;  //Y轴轴号
	double voltageToPulse;  //1V电压对应的脉冲个数
	double vel;  //调高速度 脉冲/ms
	double acc;  //调高加速度 脉冲/ms
	Int16 dirReverse;  //调高方向取反 0 正常  1取反
	Int16 posSrc;  //采集位置源 0 规划 1 编码器
	Int32 reversed2[7];
    #ifdef MTN_ST_INIT_EN
    THeightAdjusterPara(){
        mode = 0;axis=2;adcChn = 256;minVal = 0;maxVal = 32767;limitVal=1000;
        dir1No = 0;dir2No = 0;voltageToPulse=10;vel=1;acc=0.5;
        dirReverse = 0;posSrc = 0;
        reversed2[0] = reversed2[1] = reversed2[2] = reversed2[3] = 0;
        reversed2[4] = reversed2[5] = reversed2[6] = 0;
    }
    #endif
}THeightAdjusterPara;

// 设置调高功能参数
// ch: 调高通道号 目前支持0
// THeightAdjusterPara:调高功能参数结构体
// group:组号，取值范围[0,32)，暂时共用一组参数
MTN_API Int16 __stdcall OEM_SetHeightAdjusterPara(HAND devHandle,Int16 ch,THeightAdjusterPara *para,Int16 group);

// 读取调高功能参数
// ch: 调高通道号 目前支持0
// THeightAdjusterPara:调高功能参数结构体
// group:组号，取值范围[0,32)，暂时共用一组参数
MTN_API Int16 __stdcall OEM_GetHeightAdjusterPara(HAND devHandle,Int16 ch,THeightAdjusterPara *para,Int16 group);

// 启动调高采样参数
// ch: 调高通道号 目前支持0
// onOff: 0 采样关闭 1采样开始
// sampleInterval: 采样位置间隔 单位 脉冲
// sampleCount: 采样个数 当前设0
// group:组号，取值范围[0,32)
MTN_API Int16 __stdcall OEM_SetHeightAdjusterSamplingOnOff(HAND devHandle,Int16 ch,Int16 onOff,Int32 sampleInterval,Int32 sampleCount,Int16 group);

// 读取调高采样参数
// ch: 调高通道号 目前支持0
// onOff: 0 采样关闭 1采样开始
// sampleInterval: 采样位置间隔 单位 脉冲
// sampleCount: 采样个数 当前设0.
// group:组号，取值范围[0,32)
MTN_API Int16 __stdcall OEM_GetHeightAdjusterSamplingOnOff(HAND devHandle,Int16 ch,Int16 *onOff,Int32 *sampleInterval,Int32 *sampleCount,Int16 group);

// 读取调高采样状态
// ch: 调高通道号 目前支持0
// dataCount: 已采样数据个数
// group:组号，取值范围[0,32)
MTN_API Int16 __stdcall OEM_HeightAdjusterGetSamplingSts(HAND devHandle,Int16 ch,Int32 *dataCount,Int16 group);

// 设置调高启动参数
// ch: 调高通道号 目前支持0
// onOff: 0 调高关闭 1调高开始
// offset: 调高轨迹和采样轨迹的偏移 offset[0]为X方向偏移 offset[1]为Y方向偏移 
// group:组号，取值范围[0,32)
MTN_API Int16 __stdcall OEM_SetHeightAdjusterOnOff(HAND devHandle,Int16 ch,Int16 onOff,double *offset,Int16 group);

// 读取调高启动参数
// ch: 调高通道号 目前支持0
// onOff: 0 调高关闭 1调高开始
// offset: 调高轨迹和采样轨迹的偏移 offset[0]为X方向偏移 offset[1]为Y方向偏移 
// group:组号，取值范围[0,32)
MTN_API Int16 __stdcall OEM_GetHeightAdjusterOnOff(HAND devHandle,Int16 ch,Int16 *onOff,double *offset,Int16 group);

// 读取调高采样数据,未实现
// ch: 调高通道号 目前支持0
// data: 采样数据 数组3个数据为一组，顺序为 X Y ADC
MTN_API Int16 __stdcall OEM_GetHeightAdjusterSamplingData(HAND devHandle,Int16 ch,double *data,Int16 group);


#define MT_PRF_MAP_CNT_MAX  2       // 最大映射的轴数量
// 设置规划映射
// prfMapCnt: 规划映射的轴数量
// pPrfIdxList:规划映射的序号列表
// pPrfCoe:规划映射的Coe系数，取值范围[-8,8]
MTN_API Int16 __stdcall OEM_MtSetPrfMap(HAND axisHandle, Int16 prfMapCnt,Int16 *pPrfIdxList,double *pPrfCoe);
MTN_API Int16 __stdcall OEM_MtGetPrfMap(HAND axisHandle, Int16* pPrfMapCnt, Int16* pPrfIdxList, double* pPrfCoe);

// 缓冲区设置最大速度
// maxSyncVel:最大的合成速度，0:表示取消约束
MTN_API Int16 __stdcall NMC_CrdBufSetMaxVel(HAND crdHandle, Int32 segNo, double maxSyncVel);

// 缓冲区设置位置比较的触发速度限制
// trigInterval:位置比较的触发间隔，单位:pulse
// trigTimeUs:位置比较的最小触发时间间隔，单位:us
// velLmtProp:速度限制比例，数值越大则降速越明显，取值范围[1.0,n),
//				例如比较间距100pulse，开关阀时间为5ms，则该系数为1时，最大速度不超过20pulse/ms，该系数为2时最大速度不超过10pulse/ms
MTN_API Int16 __stdcall NMC_CrdBufComp2DimensSetTrigVelLimt(HAND crdHandle, Int32 segNo, Int32 trigInterval, double trigTimeUs, double velLmtProp);

//------------------------------------------------------------------------------------------------------------
//    前瞻结果查询
//------------------------------------------------------------------------------------------------------------
typedef struct TPrfParam
{
    double sVel;            // 起跳速度
    double mVel;            // 最大速度
    double eVel;            // 终止速度
    double acc;             // 加速度
    double dec;             // 减速度
    double jerk;            // 最大加加速度,该值为0则表示为梯形加减速规划，否则为S型规划
    double ratio;           // S平滑段在整个加减速过程所占的比例,取值范围[0,1],0表示没有S段，1表示全部为S段（无匀加速段）
    double dist;            // 移动距离
    double reserved[4];     // 保留
#ifdef MTN_ST_INIT_EN
    TPrfParam() {
        sVel = 0; mVel = 10; eVel = 0; acc = 0.5; dec = 0.5; jerk = 0;
        ratio = 0; dist = 100;
        reserved[0] = reserved[1] = reserved[2] = reserved[3] = 0;
    }
#endif
}TPrfParam;

// 计算加速段距离
// pParam:输入参数
MTN_API Int16 __stdcall NMC_CalcPrfAccDist(HAND devHandle, TPrfParam *pParam, double* pAccDist);

// 前瞻计算开关，注意，只支持第一张卡的第一个坐标系
// onOff:开关  1：打开计算功能，则数据不会下发到控制器中，并会自动保存前瞻计算的结果；0：关闭该功能
// bufCmdCnt: 最大缓存指令计算结果的数量
MTN_API Int16 __stdcall NMC_CrdSetLkhCalcOnOff(HAND crdHandle, Int16 onOff, Int32 bufCmdCnt);

// 读取缓存的计算结果
// resultType: 获取的数据类型，0:指令的段号，1：指令的执行时间
// resultOffset: 获取数据的偏移，
// maxGetCnt: 获取的数据最大数量，即从第resultOffset个开始读取maxGetCnt个数据
// pBuff: 数据接受缓存区
// pGetCnt: 实际读取的数据个数
// pTotalCnt: 当前总共的计算结果
MTN_API Int16 __stdcall NMC_CrdGetLkhCalcResult(HAND crdHandle, Int32 resultType, Int32 resultOffset, Int32 maxGetCnt, F32* pBuff, Int32* pGetCnt, Int32* pTotalCnt);

// 前瞻回调
typedef struct TLkhCmd
{
    Int32 cmdType;          // 命令类型：0--line 1--arc 2....
    Int32 segNo;            // 指令段号
    double mVel;            // 最大速度
    double eVel;            // 终止速度
    double acc;             // 加速度
    double tgtPos[4];       // 目标速度
    double reserved[4];       // 保留
 
}TLkhCmd;

//中断回调函数指针定义
typedef void (*OEM_LkhPushCmdCallback)(TLkhCmd *pCmd);

// 设置前瞻计算结果回调函数，将前瞻计算结果推送到外部程序中
// pCallback: 指令回调函数
// onOff  : 操作标志位，0:关闭 1:打开 
MTN_API Int16 __stdcall OEM_CrdSetLkhPushCmdCallBack(HAND crdHandle, Int16 onOff, OEM_LkhPushCmdCallback pCallback);

//------------------------------------------------------------------------------------------------------------
//    控制器到期时间
//------------------------------------------------------------------------------------------------------------
// 设置控制器到期时间
typedef struct TDevDeadLineUnit
{
    TNMCTime deadLine;              // 限期时间,到达限期时间后，则轴进入报错状态，无法运动
    char  unlockPassword[16];       // 当前限期时间的解除密码
  
}TDevDeadLineUnit;

typedef struct TDevDeadLine
{
    char password[32];              // 设置密码,如果当前已经设置了限期时间，则会检查密码是否匹配
                                    // 务必记住密码，密码忘记则需要返厂复位控制器
    char  unlockAllPassword[16];    // 整体限期时间的解除密码
    TDevDeadLineUnit deadLines[10]; // 限期时间组，最多10组，对应时间year大于2000则表示激活
     
}TDevDeadLine;

// 设置控制器的限期时间
// 注意：该功能依赖控制器时钟功能，启动该功能后，如果控制器时钟功能异常，则控制器将立即进入报错状态
MTN_API Int16 __stdcall OEM_DeadLineConfig(HAND devHandle,TDevDeadLine*pDeadLine);

// 设置控制器当前限期时间解锁密码
MTN_API Int16 __stdcall OEM_DeadLineSetUnLock(HAND devHandle, char* pUnlockPassword);

// 获取当前限期时间状态
// pSts:当前的状态，0:未激活 1:激活，2:超时
MTN_API Int16 __stdcall OEM_DeadLineGetSts(HAND devHandle, Int16 *pSts, TNMCTime *pCurDeadLine);

//------------------------------------------------------------------------------------------------------------
//    模拟量摇杆控制
//------------------------------------------------------------------------------------------------------------
// 摇杆控制
typedef struct TAdJoyStickChn
{
    Int16 axisIdx;              // 轴号
    Int16 adcChn;               // 模拟量通道号
    Int16 adcThresholdValue;    // 摇杆模拟量阈值
    Int16 adcMaxValue;          // 摇杆模拟量最大值
    Int16 adcMedianValue;       // 摇杆模拟量中间值
    Int16 adcMinValue;          // 摇杆模拟量最小值
    Int16 adcDirRevs;           // 是否模拟量控制速度方向取反
    Int16 reserved1;            // 保留
    double motionVelHigh;       // 高速
    double motionVelLow;        // 低速
    double motionAcc;           // 加速度： 
    double motionDec;           // 减速度： 
    double motionSmooth;        //平滑系数： 0——1
    Int32 reseved[4];           // 保留
#ifdef MTN_ST_INIT_EN
    TAdJoyStickChn() {
        axisIdx = 0;
        adcChn = 0;
        adcThresholdValue = 50;
        adcMaxValue = 16384;
        adcMedianValue = 8192;
        adcMinValue = 0;
        motionVelHigh = 100;
        motionVelLow = 0.2;
        motionAcc = 1;
        motionDec = 1;
        motionSmooth = 0;
        adcDirRevs = 0;
        reserved1 = 0;
        reseved[0] = reseved[1] = reseved[2] = reseved[3] = 0;
    }
#endif
}TAdJoyStickChn;

typedef struct TAdJoyStickCfg
{
    TAdJoyStickChn joyStickChn[3];
    Int16 speedCtrlDiIdx;           // 高低速切换的GPI序号
    Int16 estopDiIdx;               // 急停按钮GPI序号
    Int16 estopDiLevel;             // 急停按钮有效电平
    Int16 startDiIdx;               // 启动按钮GPI序号
    Int16 ZoomInDiIdx;              // 倍率放大按钮GPI序号
    Int16 ZoomOutDiIdx;             // 倍率缩小按钮GPI序号
    Int16 adcVelRatio;          // 速度倍率模拟量输入通道，-1表示无效
    Int16 adcVelRatioMin;       // 速度倍率模拟量输入最小值,对应速度倍率0% 
    Int16 adcVelRatioMax;       // 速度倍率模拟量输入最大值,对应速度倍率100%
    Int16 reserved1;            // 保留
    Int32 reserved[3];
#ifdef MTN_ST_INIT_EN
    TAdJoyStickCfg() {
        adcVelRatio = -1; adcVelRatioMin = 0; adcVelRatioMax = 16384;
        reserved1 = 0;
        reserved[0] = reserved[1] = reserved[2] = 0;
    }
#endif
}TAdJoyStickCfg;


MTN_API Int16 __stdcall OEM_SetAdJoyStickCfg(HAND devHandle, TAdJoyStickCfg* pCfg);
MTN_API Int16 __stdcall OEM_GetAdJoyStickCfg(HAND devHandle, TAdJoyStickCfg* pCfg);
MTN_API Int16 __stdcall OEM_SetAdJoyStickOnOff(HAND devHandle, Int16 onOff);

typedef struct TAdJoyStickSts
{
    Int16 onOff;            // 是否启动
    Int16 reserved[9];      // 保留
}TAdJoyStickSts;

MTN_API Int16 __stdcall OEM_GetAdJoyStickSts(HAND devHandle, TAdJoyStickSts* pSts);


//------------------------------------------------------------------------------------------------------------
//    用户自定义状态包
//------------------------------------------------------------------------------------------------------------
typedef struct TUserDefStsUnit
{
    Int16 stsVarType;       // 变量ID，参考MC_VAR_MtSts等定义
    Int16 stsVarIdx;        // 变量索引，取值范围[0,n]
    #ifdef MTN_ST_INIT_EN
    TUserDefStsUnit() {
        stsVarType = 0;
        stsVarIdx = 0;
    }
    #endif
}TUserDefStsUnit;

// 用户自定义状态包配置
// pUnitArray: 用户自定义状态变量数组
// unitCnt: 数组包含的数据个数，取值范围[1,1024],总的数据长度不能超过1280字节
// chn:用户自定义状态包的通道号，取值范围[0,1]
MTN_API Int16 __stdcall OEM_UserDefStsSetConfig(HAND devHandle, TUserDefStsUnit* pUnitArray, Int16 unitCnt, Int16 chn);
//MTN_API Int16 __stdcall OEM_UserDefStsGetConfig(HAND devHandle, TUserDefStsUnit* pUnitArray, Int16* pUnitCnt, Int16 chn);

// 获取用户自定义状态包，数据排列按照用户自定义状态变量数组的顺序
// pDataLen: 状态数据长度
// pStsBuf: 状态数据
// 注意：结构体接收请注意数据对齐
MTN_API Int16 __stdcall OEM_UserDefStsGet(HAND devHandle, void* pStsBuf, Int16 *pDataLen, Int16 chn);


//------------------------------------------------------------------------------------------------------------
//    远程回调功能
//------------------------------------------------------------------------------------------------------------
// 启动后的调用计数
typedef void (*GC_RemoteCallback)(Int32 callCnt,Int16 recDataLen,Int8 *pRecData);
typedef struct TRemoteCallConfig
{
    Int16 onOff;               // 是否激活
    Int16 mode;                 // 模式：网络或者硬件中断
    Int16 respanseMode;         // 接收到数据，是否应答,0:不应答，1:应答接收数据的拷贝
    Int16 reserved[29];         // 保留
    GC_RemoteCallback callback; // 回调函数

#ifdef MTN_ST_INIT_EN
    TRemoteCallConfig() {
        mode = respanseMode = 0;
        memset(reserved, 0, sizeof(Int16)*29);
    }
#endif
}TRemoteCallConfig;

MTN_API short  __stdcall NMC_DevRemoteCallConfig(HAND devHandle, TRemoteCallConfig* pCfg, Int16 chn);

typedef struct TRemoteCallSts
{
    Int16 onOff;                    // 是否激活
    Int16 errCode;                  // 错误码
    Int32 trigCnt;                  // 触发计数
    Int32 callCnt;                  // 调用计数
    Int32 reserved;                 // 保留
}TRemoteCallSts;
MTN_API short  __stdcall NMC_DevRemoteCallGetSts(HAND devHandle, TRemoteCallSts* pSts,Int16 chn);

MTN_API Int16 __stdcall OEM_CrdBufAxSynMoveRelEnd(HAND crdHandle, Int32 segNo, short axisCnt, short* pAxList, Int32* pRelPos);
MTN_API Int16 __stdcall OEM_CrdBufAxSynMoveRelBegin(HAND crdHandle, Int32 segNo);



// 设置光源亮度
// pLightList:44维数组,0~7为环形光光源 8为大电流底光 9为同轴光 10为小电流底光 11/12为大电流表光 42为激光笔 43保留
MTN_API Int16 __stdcall OEM_DevSetBrightness(HAND devHandle, Int32* pLightList);

typedef struct TProbeParam
{
    Int16 axCnt;                    // 参与轴数
    Int16 axList[4];                // 轴列表
    Int16 diType;                   // 探针绑定的DI类型
    Int16 diIndex;                  // 探针绑定的DI通道号
    Int16 diSns;                    // 探针触发的有效电平，0-低电平 1-高电平
    double comebackVel;             // 回退速度，单位:mm/s
    double comebackAcc;             // 回退加速度，单位:mm/s^2
    double comebackDist;            // 回退距离，单位:mm
    double reserved[8];             // 保留参数
}TProbeParam;

// 设置探针参数
MTN_API Int16 __stdcall OEM_DevProbeSetParam(HAND devHandle, TProbeParam *pParam, Int16 chn);

// 启用或禁用探针
// onOff: 0禁用，1启用
MTN_API Int16 __stdcall OEM_DevProbeSetOnOff(HAND devHandle, Int16 onOff, Int16 chn);

// 启动探针自动探测运动
// searchVel: 探针运动速度 单位:Pulse/ms
// probeVel: 探测速度 单位:Pulse/ms
// searchAcc: 探针运动加速度 单位:Pulse/ms*ms
// searchRadius:搜索半径 单位:Pulse
// pTgtPosArray:理论点位置
// pVectorPosArray:向量点位置
// 说明: 启动运动后，机构根据提供的向量，向目标点移动，到达目标点，如果探针没有触发，则继续移动searchRadius长的距离，如果还是没有触发，则停止运动，并置起自动搜索出错标记
//      在此过程中，探针触发则停止运动，并置起捕获标记
//      探针进入目标点searchRadius范围，自动切换为probeVel
MTN_API Int16 __stdcall OEM_DevProbeAutoMove(HAND devHandle, double searchVel, double probeVel, double searchAcc, double searchRadius, Int32* pTgtPosArray, Int32* pVectorPosArray, Int16 chn);

// 启动探针手动探测运动，通过JoyStick手动搜索
// comebackOnOff：探针触发后，是否自动回弹
// 说明: 1.用户手动移动机构，移动过程中，控制器自动采集移动向量（可以通过OEM_DevProbeGetTouchSts动态获取）
//      2.探针触发后，自动捕获位置，并置起捕获标记
//      3.探针触发后，comebackOnOff为1，则自动按照当前的向量回弹，回弹距离为设置的回弹距离
MTN_API Int16 __stdcall OEM_DevProbeManualMove(HAND devHandle, Int16 comebackOnOff, Int16 chn);

// 读取探针探测状态
// pCaptSts: 探针状态，低16位:bit0:0--未触发，1--已触发,捕获数据  bit1:探针当前是否激活 bit2:自动搜索出错  bit3:探针过程出错
//                   高16位:错误代码，错误代码在启动手动或者自动时，自动清除
// pCaptPosArray:探测锁存的位置数组，单位pulse
// pVectorPosArray:向量点位置数组，单位pulse，对于手动搜索，动态刷新，对于自动搜索，则为设置的向量
MTN_API Int16 __stdcall OEM_DevProbeGetTouchSts(HAND devHandle, Int32* pCaptSts, Int32* pCaptPosArray, Int32* pVectorPosArray, Int16 chn);

// 设置扩展PWM
// baseFrq: PWM频率，单位Hz
// duty：PWM占空比，取值范围[0,100]
MTN_API short __stdcall OEM_DevSetExtPWM(HAND devHandle, double baseFrq, double duty, Int16 chn);
// 读取扩展PWM
MTN_API short __stdcall OEM_DevGetExtPWM(HAND devHandle, double* pBaseFrq, double* pDuty, Int16 chn);


// 设置坐标系运动，在不同的插补段长下，对应加速度比例系数
// sectionNum:分段数量, 取值范围[0,16],0表示不需要分段处理
// pLenArray:分段长度数组
// pRatioArray:分段比例系数数组
// flag:保留
// 说明：比如sectionNum=2，pLenArray={1000,2000}，pRatioArray={0.1,0.5}，则段长(0,1000)对应Acc比例系数为0.1，段长[1000,2000)对应Acc比例系数为0.5,段长[2000,...)对应Acc比例系数为1
MTN_API short __stdcall OEM_CrdSetAccRatioForLength(HAND crdHandle, Int16 sectionNum, double* pLenArray, double* pRatioArray, Int32 flag);
MTN_API short __stdcall OEM_CrdGetAccRatioForLength(HAND crdHandle, Int16 *pSectionNum,double* pLenArray, double* pRatioArray,Int32 *pFlag);

// 控制器复位Ex
// flag: 复位选项
//       bit0:是否保持GPO输出状态，1:复位后GPO输出状态保持不变
MTN_API short __stdcall OEM_DevResetEx(HAND devHandle, Int64 flag);

#ifdef __cplusplus
}
#endif

#endif    // _H_MTN_LIB20_OEM_H_
