package lib;

import com.sun.jna.*;
import com.sun.jna.ptr.*;
import java.util.Arrays;
import java.util.List;
import lib.MtnLib_com.HAND;
import lib.MtnLib_com.PHAND;

public class MtnLib {
//         //==================== 无符号数转换工具 ====================
//    public static final int UNSIGNED_CHAR = 0xFF;
//    public static final int UNSIGNED_SHORT = 0xFFFF;
//    public static final long UNSIGNED_INT = 0xFFFFFFFFL;
//
//    public static byte toUnsignedByte(int value) {return (byte)(value & UNSIGNED_CHAR);}
//    public static short toUnsignedShort(int value) {return (short)(value & UNSIGNED_SHORT);}
//    public static int toUnsignedInt(long value) {return (int)(value & UNSIGNED_INT);}
    // 添加在类开头
    public static class NMCException extends RuntimeException {
        public NMCException(String message) {
            super(message);
        }
    }
    /**原生库接口*/
    private interface NativeLib extends Library {
        NativeLib INSTANCE = Native.load("nmc_lib20", NativeLib.class);

        short NMC_DevOpen(short devNo, PHAND pDevHandle);
        short NMC_MtSwLmtOnOff(HAND axisHandle, short swt);
        short NMC_MtSwLmtValue(HAND axisHandle, NativeLong posLmt, NativeLong negLmt);
        short NMC_MtSetStepMode(HAND axisHandle, short inv, short mode);
        short NMC_MtSetStepFilter(HAND axisHandle, short coe);
        short NMC_MtGetPrfPos(HAND axisHandle, NativeLongByReference pPos);
        short NMC_MtGetPrfVel(HAND axisHandle, DoubleByReference pVel);
        short NMC_MtGetEncPos(HAND axisHandle, NativeLongByReference pPos);
        short NMC_MtGetMotionIO(HAND axisHandle, IntByReference pIoValue);
        short NMC_MtGetMotionIOLogical(HAND axisHandle, IntByReference pIoValue);
        short NMC_MtClrError(HAND axisHandle);
        short NMC_MtGetStsPack(HAND axisFirstHandle, short count, TAxisStsPack pPackSts);
        short NMC_MtGetStsPack12Ex(HAND axisFirstHandle,TAxisStsPack12Ex pPackSts);
        short NMC_MtGetStsPackEx(HAND devHandle, TMcStsPackEx pPackSts);
        short NMC_MtGetStsPackEx2(HAND devHandle, TMcStsPackEx2 pPackSts);
        short NMC_CrdEndMtn(HAND crdHandle);
        short NMC_CrdBufGetFree(HAND crdHandle, NativeLongByReference pRes);
        short NMC_CrdBufGetUsed(HAND crdHandle, NativeLongByReference pLen);
        short NMC_CrdGetUserSegNo(HAND crdHandle, NativeLongByReference pSegNo);
        short NMC_CrdGetBufAllCmdCnt(HAND crdHandle, NativeLongByReference pCnt);
        short NMC_CrdSetLeftLenForLaserWaveOff(HAND crdHandle, double length, short group, short ch);
        short NMC_DevSearch(TSearchMode mode, short[] pDevNo, TDevInfo[] pInfoList);
        short NMC_DevClose(PHAND pDevHandle);
        short NMC_DevReset(HAND devHandle);
        short NMC_MtOpen(HAND devHandle, short itemNo, PHAND pAxisHandle);
        short NMC_MtClose(PHAND pAxisHandle);
        short NMC_CrdOpenEx(HAND devHandle, short itemNo, PHAND pCrdHandle);
        short NMC_CrdClose(PHAND pCrdHandle);
        short NMC_SetEncMode(HAND devHandle, short encId, short encMode);
        short NMC_MtSetSafePara(HAND axisHandle, TSafePara pPara);
        short NMC_MtSetAxisVelFilter(HAND axisHandle, short filterCoef);
        short NMC_MtSetLmtCfg(HAND axisHandle, short posLmtEnable, short negLmtEnable, short posLmtSns, short negLmtSns);
        short NMC_MtSetAlarmCfg(HAND axisHandle, short alarmEnable, short alarmSns);
        short NMC_MtSetPrfMode(HAND axisHandle, short mode);
        short NMC_MtSetPtpPara(HAND axisHandle, TPtpPara pAxPara);
        short NMC_MtGetTrapTime(HAND axisHandle, TTrapTime pTrapTime);
        short NMC_MtSetJogPara(HAND axisHandle, TJogPara pAxPara);
        short NMC_MtSetVel(HAND axisHandle, double vel);
        short NMC_MtSetPtpTgtPos(HAND axisHandle, NativeLong pos);
        short NMC_MtUpdate(HAND axisHandle);
        short NMC_MtStop(HAND axisHandle);
        short NMC_MtAbruptStop(HAND axisHandle);
        short NMC_MtZeroPos(HAND axisHandle);
        short NMC_MtSetSvClr(HAND axisHandle, short swt);
        short NMC_MtSetSvOn(HAND axisHandle);
        short NMC_MtSetSvOff(HAND axisHandle);
        short NMC_MtClrStsByBits(HAND axisHandle, short stsMask);
        short NMC_MtMovePtpAbs(HAND axisHandle, double acc, double dec, double startVel, double endVel, double maxVel, short smoothCoef, NativeLong tgtPos);
        short NMC_MtMoveJog(HAND axisHandle, double acc, double dec, double maxVel, short smoothCoef, short clrStsFlag);
        short NMC_MtMovePtpAbsPack8(HAND axisFirstHandle, TMovePtpPack8[] pPackData );
        short NMC_MtMovePtpRelPack8(HAND axisFirstHandle, TMovePtpPack8[] pPackData );
        short NMC_MtMovePtpRel(HAND axisHandle, double acc, double dec, double startVel, double endVel, double maxVel, short smoothCoef, NativeLong relPos);
        short NMC_MtMultiMoveAbs(HAND devHandle, short axisMask, double acc, double dec, double sVel, double eVel, double maxVel, short smooth, NativeLong[] pPosArray);
        short NMC_MtMovePtpAbsTwoStage(HAND axisHandle, TPtpTwoStagePrm pPrm);
        short NMC_MtGetPrfAcc(HAND axisHandle, double[] pAcc, short count);
        short NMC_MtGetStsEx(HAND axisHandle, ShortByReference pStsWord);
        short NMC_CrdGetStsEx2(HAND crdHandle, ShortByReference pStsWord);
        short NMC_DevSetStsExCmdEn(HAND devHandle, short enFlag);
        short NMC_GetEncVel(HAND devHandle, short encId, DoubleByReference pVel);
        short NMC_MtGetSts(HAND axisHandle, ShortByReference pStsWord);
        short NMC_SetDOGroup(HAND devHandle, NativeLong value, short groupID);
        short NMC_GetDIGroup(HAND devHandle, NativeLongByReference pInValue, short groupID);
        short NMC_GetDOGroup(HAND devHandle, NativeLongByReference pDoValue, short groupID);
        short NMC_SetDOBit(HAND devHandle, short bitIndex, short value);
        short NMC_GetDOBit(HAND devHandle, short bitIndex, ShortByReference bitValue);
        short NMC_GetDIBit(HAND devHandle, short bitIndex, ShortByReference pBitValue);
        short NMC_GetIOModuleSts(HAND devHandle, NativeLong sts);
        short NMC_SetIOModuleEn(HAND devHandle, byte chDevId);
        short NMC_IOModuleSetEn(HAND devHandle, byte chDevId, short chDevType);
        short NMC_IOModuleGetType(HAND devHandle, byte chDevId, ShortByReference pChDevType);
        short NMC_IOModuleWr8Bit(HAND devHandle, byte chDevId, byte offset, byte data);
        short NMC_IOModuleWr16Bit(HAND devHandle, byte chDevId, byte offset, byte data);
        short NMC_IOModuleWr32Bit(HAND devHandle, byte chDevId, byte offset, byte data);
        short NMC_IOModuleRd8Bit(HAND devHandle, byte chDevId, byte offset, ByteByReference pData);
        short NMC_IOModuleRd16Bit(HAND devHandle, byte chDevId, byte offset, ShortByReference pData);
        short NMC_IOModuleRd32Bit(HAND devHandle, byte chDevId, byte offset, NativeLongByReference pData);
        short NMC_IOModuleRdOut8Bit(HAND devHandle, byte chDevId, byte offset, ByteByReference pData);
        short NMC_IOModuleRdOut16Bit(HAND devHandle, byte chDevId, byte offset, ShortByReference pData);
        short NMC_IOModuleRdOut32Bit(HAND devHandle, byte chDevId, byte offset, NativeLongByReference pData);
        short NMC_CrdConfig(HAND crdHandle, TCrdConfig pConfig);
        short NMC_CrdSetSafePara(HAND crdHandle, TCrdSafePara pPara);
        short NMC_CrdSetOffset(HAND crdHandle, short count, NativeLong[] pOffsetArray);
        short NMC_CrdDelete(HAND crdHandle);
        short NMC_CrdStartMtn(HAND crdHandle);
        short NMC_CrdStopMtn(HAND crdHandle);
        short NMC_CrdEstopMtn(HAND crdHandle);
        short NMC_CrdGotoBreak(HAND crdHandle, double acc, double vel);
        short NMC_CrdGetSts(HAND crdHandle, ShortByReference pStsWord);
        short NMC_CrdGetStsPack4(HAND crdHandle, TPackedCrdSts4 pPackSts);
        short NMC_CrdClrError(HAND crdHandle);
        short NMC_CrdGetBufLeftLength(HAND crdHandle, DoubleByReference pLen);
        short NMC_CrdBufClr(HAND crdHandle);
        short NMC_CrdBufSetLeftLenForLaserWaveOff(HAND crdHandle, NativeLong segNo, double length, short group, short ch);
        short NMC_CrdStartExeTimeCalc();
        short NMC_CrdGetExeTime(DoubleByReference pTime);
        short NMC_CrdLineXYZA(HAND crdHandle, NativeLong segNo, short crdAxMask, NativeLong[] pTgPosArray, double endVel, double vel, double synAcc, short lookaheadDis);
        short NMC_CrdSetFourthAxisTolTurnVel(HAND crdHandle, double tolVel);
        short NMC_CrdLineXYZEx(HAND crdHandle, NativeLong segNo, short crdAxMask, NativeLong[] pTgPosArray, double endVel, double vel, double synAcc, short lookaheadDis);
        short NMC_CrdLineXYZD8(HAND crdHandle, NativeLong segNo, NativeLong crdAxmask, NativeLong extAxMask, NativeLong[] pTgPosArray, double endVel, double vel, double synAcc, short lookaheadDis);
        short NMC_CrdLineXYZD8Pack(HAND crdHandle, short count, TCrdLineXYZD8Unit[] pCmdArray);
        short NMC_CrdLineXYZD4Pack(HAND crdHandle, short count, TCrdLineXYZD4Unit[] pCmdArray);
        short NMC_CrdLineXYZPack(HAND crdHandle, short count, TCrdLineXYZUnit[] pCmdArray);
        short NMC_CrdArcRadius(HAND crdHandle, NativeLong segNo, NativeLong[] pTgPosArray, double radius, short circleDir, double endVel, double vel, double synAcc);
        short NMC_CrdArcRadiusYZ(HAND crdHandle, NativeLong segNo, NativeLong[] pTgPos, double radius, short circleDir, double velEnd, double vel, double synAcc);
        short NMC_CrdArcRadiusZX(HAND crdHandle, NativeLong segNo, NativeLong[] pTgPos, double radius, short circleDir, double velEnd, double vel, double synAcc);
        short NMC_CrdArcRadiusEx(HAND crdHandle, NativeLong segNo, NativeLong[] pTgPosArray, double radius, short circleDir, double endVel, double vel, double synAcc, short lookaheadDis);
        short NMC_CrdArcRadiusYZEx(HAND crdHandle, NativeLong segNo, NativeLong[] pTgPos, double radius, short circleDir, double velEnd, double vel, double synAcc, short lookaheadDis);
        short NMC_CrdArcRadiusZXEx(HAND crdHandle, NativeLong segNo, NativeLong[] pTgPos, double radius, short circleDir, double velEnd, double vel, double synAcc, short lookaheadDis);
        short NMC_CrdArcCenter(HAND crdHandle, NativeLong segNo, NativeLong[] pTgPosArray, NativeLong[] pCenterPosArray, short circleDir, double endVel, double vel, double synAcc);
        short NMC_CrdArcCenterYZ(HAND crdHandle, NativeLong segNo, NativeLong[] pTgPos, NativeLong[] pCenterPos, short circleDir, double velEnd, double vel, double synAcc);
        short NMC_CrdArcCenterZX(HAND crdHandle, NativeLong segNo, NativeLong[] pTgPos, NativeLong[] pCenterPos, short circleDir, double velEnd, double vel, double synAcc);
        short NMC_CrdArcCenterEx(HAND crdHandle, NativeLong segNo, NativeLong[] pTgPosArray, NativeLong[] pCenterPosArray, short circleDir, double endVel, double vel, double synAcc, short lookaheadDis);
        short NMC_CrdArcCenterYZEx(HAND crdHandle, NativeLong segNo, NativeLong[] pTgPos, NativeLong[] pCenterPos, short circleDir, double velEnd, double vel, double synAcc, short lookaheadDis);
        short NMC_CrdArcCenterZXEx(HAND crdHandle, NativeLong segNo, NativeLong[] pTgPos, NativeLong[] pCenterPos, short circleDir, double velEnd, double vel, double synAcc, short lookaheadDis);
        short NMC_CrdArcPPP(HAND crdHandle, NativeLong segNo, NativeLong[] pMidPosArray, NativeLong[] pTgPosArray, double endVel, double vel, double synAcc);
        short NMC_CrdCirclePPP(HAND crdHandle, NativeLong segNo, short planeIdx, NativeLong[] pStPos, NativeLong[] pMidPosArray, NativeLong[] pTgPosArray, double endVel, double vel, double synAcc, short lookaheadDis);
        short NMC_CrdArcPPPEx(HAND crdHandle, NativeLong segNo, NativeLong[] pMidPosArray, NativeLong[] pTgPosArray, double endVel, double vel, double synAcc, short lookaheadDis);
        short NMC_CrdEllipse(HAND crdHandle, NativeLong segNo, double abRatio, NativeLong[] pCenterPos, short ellipseDir, double vel, double synAcc);
        short NMC_CrdVortexCenter(HAND crdHandle, NativeLong segNo, NativeLong[] pCenterPos, NativeLong[] pTgtPos, short circleDir, double rounds, double endVel, double vel, double synAcc);
        short NMC_CrdHelixCenter(HAND crdHandle, NativeLong segNo, NativeLong[] pTgPosArray, NativeLong[] pCenterPosArray, short circleDir, double rounds, double endVel, double vel, double synAcc);
        short NMC_CrdHelixCenterEx(HAND crdHandle, NativeLong segNo, NativeLong[] pTgPosArray, NativeLong[] pCenterPosArray, short circleDir, double rounds, double endVel, double vel, double synAcc, short lookaheadDis);
        short NMC_CrdArc3D(HAND crdHandle, NativeLong segNo, NativeLong[] pMidPos, NativeLong[] pTgPos, double velEnd, double vel, double synAcc);
        short NMC_CrdArc3DEx(HAND crdHandle, NativeLong segNo, NativeLong[] pMidPos, NativeLong[] pTgPos, double velEnd, double vel, double synAcc, short lookaheadDis);
        short NMC_CrdCircle3DEx(HAND crdHandle, NativeLong segNo, NativeLong[] pMidPos, NativeLong[] pTgPos, double velEnd, double vel, double synAcc, short lookaheadDis);
        short NMC_CrdBufDo(HAND crdHandle, NativeLong segNo, short doType, NativeLong ch, NativeLong value);
        short NMC_CrdBufDoEx(HAND crdHandle, NativeLong segNo, short group, NativeLong doMask, NativeLong doValue);
        short NMC_CrdBufOut(HAND crdHandle, NativeLong segNo, short group, short ch, NativeLong value);
        short NMC_CrdBufWaitDI(HAND crdHandle, NativeLong segNo, short index, short diValue, NativeLong waitLastTime);
        short NMC_CrdBufWait(HAND crdHandle, NativeLong segNo, short waitType, short index, NativeLong waitValue, NativeLong waitTimeInMs);
        short NMC_CrdBufWaitEncInPosition(HAND crdHandle, NativeLong segNo, NativeLong axisMask, NativeLong overTime);
        short NMC_CrdBufWaitPos(HAND crdHandle, NativeLong segNo, short axisNo, short condition, NativeLong pos, short posSrc, NativeLong overTime);
        short NMC_CrdBufDelay(HAND crdHandle, NativeLong segNo, short scale, NativeLong count);
        short NMC_CrdBufAxMove(HAND crdHandle, NativeLong segNo, short axisMask, NativeLong[] pTgPos, short blockEn, short synEn);
        short NMC_CrdBufAxMoveEx(HAND crdHandle, NativeLong segNo, short axisMask, NativeLong[] pTgPos, double vel, double acc, short blockEn, short synEn);
        short NMC_CrdBufAxMoveRel(HAND crdHandle, NativeLong segNo, short axisMask, NativeLongByReference pRelPos, short blockEn, short synEn);
        short NMC_CrdBufSetPtpMovePara(HAND crdHandle, NativeLong segNo, short axisNo, double vel, double acc, short soomthCoef);
        short NMC_CrdBufValueFollow(HAND crdHandle, NativeLong segNo, short onOff);
        short NMC_CrdBufSetScaleLimit(HAND crdHandle,NativeLong segNo, short crdAxMask,NativeLong[] pXMax,NativeLong[] pYMax,NativeLong[] pZMax);
        short NMC_CrdBufBeforeAxSyncMove(HAND crdHandle, NativeLong segNo, short axis, NativeLong relDistance, double vel);
        short NMC_CrdSetOverRide(HAND crdHandle, double overRide);
        short NMC_MtSetHomePara(HAND axisHandle, THomeSetting pHomePara);
        short NMC_MtGetHomeSts(HAND axisHandle, ShortByReference pStsWord);
        short NMC_MtHome(HAND axisHandle);
        short NMC_MtTryHome(HAND axisHandle);
        short NMC_MtHomeStop(HAND axisHandle);
        short NMC_MtGetHomeError(HAND axisHandle, NativeLongByReference pErrPos);
        short NMC_MtGearSetDir(HAND axisHandle, short dir);
        short NMC_MtGearGetDir(HAND axisHandle, ShortByReference pDir);
        short NMC_MtGearSetMaster(HAND axisHandle, short masterNo, short masterType);
        short NMC_MtGearGetMaster(HAND axisHandle, ShortByReference pMasterNo, ShortByReference pMasterType);
        short NMC_MtGearSetRatio(HAND axisHandle, NativeLong masterEven, NativeLong slaveEven, NativeLong masterSlope);
        short NMC_MtGearGetRatio(HAND axisHandle, NativeLongByReference pMasterEven, NativeLongByReference pSlaveEven, NativeLongByReference pMasterSlope);
        short NMC_MtGearStartMtn(HAND axisHandle, short syncAxCnts, short[] pSyncAxArray);
        short NMC_MtFollowSetDir(HAND axisHandle, short dir);
        short NMC_MtFollowGetDir(HAND axisHandle, ShortByReference pDir);
        short NMC_MtFollowSetMaster(HAND axisHandle, short masterNo, short masterType);
        short NMC_MtFollowGetMaster(HAND axisHandle, ShortByReference pMasterNo, ShortByReference pMasterType);
        short NMC_MtFollowSetLoopCount(HAND axisHandle, NativeLong loopCnt);
        short NMC_MtFollowGetLoopCount(HAND axisHandle, NativeLongByReference pLoopCnt);
        short NMC_MtFollowSetEvent(HAND axisHandle, short eventType, short masterDir, NativeLong pos);
        short NMC_MtFollowGetEvent(HAND axisHandle, ShortByReference pEvent, ShortByReference pMasterDir, NativeLongByReference pPos);
        short NMC_MtFollowGetSpace(HAND axisHandle, ShortByReference pSpace, short fifoNo);
        short NMC_MtFollowPushData(HAND axisHandle, NativeLong masterPos, double slavePos, short type, short fifoNo);
        short NMC_MtFollowClear(HAND axisHandle, short fifoNo);
        short NMC_MtFollowStart(HAND axisHandle, short syncAxCnts, short[] pSyncAxArray);
        short NMC_MtFollowSwitch(HAND axisHandle, short syncAxCnts, short[] pSyncAxArray);
    }

    private static final NativeLib lib = NativeLib.INSTANCE;

    //1.控制器连接、关闭
    public enum TSearchMode implements NativeMapped {
        USB((byte)0),        // USB模式
        Ethernet((byte)1),   // Ethernet模式
        RS485((byte)2),      // RS485模式
        SPI((byte)3);        // SPI模式
        private final byte value;
        TSearchMode(byte value) {
            this.value = value;
        }
        @Override
        public Object fromNative(Object nativeValue, FromNativeContext context) {
            int value = (Integer)nativeValue;
            for (TSearchMode mode : values()) {
                if (mode.value == value) {
                    return mode;}}
            return null;
        }
        @Override
        public Object toNative() {
            return value;
        }
        @Override
        public Class<?> nativeType() {
            return Integer.class;
        }
    }
    /*TDevInfo 结构体*/
    public static class TDevInfo extends Structure {
        public short address;                       // 在上位机系统中的设备序号,
        public byte[] idStr = new byte[16];         // 识别字符串
        public byte[] description = new byte[64];   // 描述符
        public short ID;                            // 板上的ID(未用)
        @Override
        protected List<String> getFieldOrder() {
            return Arrays.asList("address", "idStr", "description", "ID" );}
    }
    // 板卡搜寻
    // 参数: mode:通讯模式
    // pDevNo : 返回设备的数目
    // pInfoList：返回设备信息
    public static short NMC_DevSearch(TSearchMode mode, short[] pDevNo, TDevInfo[] pInfoList) { return lib.NMC_DevSearch(mode, pDevNo, pInfoList);}
    // 板卡打开（根据序号）
    // devNo: 设备序号,取值范围[0,n]； pDevHandle: 返回设备操作句柄
    public static short NMC_DevOpen(short devNo, PHAND pDevHandle) {return lib.NMC_DevOpen(devNo, pDevHandle);}
    // 板卡关闭
    // pDevHandle : 设备句柄指针
    public static short NMC_DevClose(PHAND pDevHandle) {
        return lib.NMC_DevClose(pDevHandle);
    }
    // 板卡复位
    public static short NMC_DevReset(HAND devHandle) {
        return lib.NMC_DevReset(devHandle);
    }
    // 打开单轴
    // devHandle : 设备句柄
    // itemNo：轴号,取值范围[0,n]
    // pCrdHandle：坐标系组句柄
    public static short NMC_MtOpen(HAND devHandle, short itemNo, PHAND pAxisHandle) {return lib.NMC_MtOpen(devHandle, itemNo, pAxisHandle);}
    // 关闭单轴
    // devHandle : 设备句柄指针
    public static short NMC_MtClose(PHAND pAxisHandle) {
        return lib.NMC_MtClose(pAxisHandle);
    }
    // 打开坐标系组(支持多坐标系)
    // itemNo：坐标系号,取值范围[0,1]
    // pCrdHandle：返回坐标系组句柄
    public static short NMC_CrdOpenEx(HAND devHandle, short itemNo, PHAND pCrdHandle) {return lib.NMC_CrdOpenEx(devHandle, itemNo, pCrdHandle);}
    // 关闭坐标系组
    // pCrdHandle：坐标系组句柄
    public static short NMC_CrdClose(PHAND pCrdHandle) {
        return lib.NMC_CrdClose(pCrdHandle);
    }


    //2.单轴配置
    public static final short EXT_RES_START_INDEX = 256;
    // 编码器模式：定义信号源,信号类型,取反,,编码器分频等
    // Bit7:0 分频系数,数值为0~255。对应分频数值 1~256
    // Bit9:8 信号号源选择
    //   00：外部信号输入
    //   01: 轴脉冲输入
    //   10：自动产生信号（正脉冲）
    //   11：自动产生信号（负脉冲）
    // Bit11:10 信号类型（外部）
    //  00：AB相,90度差
    //  01：脉冲+方向
    //  10：正脉冲+负脉冲
    //  11：保留
    // Bit12 输入A、B交换（外部） 0：不交换,1：交换
    // Bit13 输入A取反（外部） 0：不取反,1：取反
    // Bit14 输入B取反（外部） 0：不取反,1：取反
    // Bti15 编码器饱和,0：最大最小值翻转,1：不翻转
    // 设置编码器模式
    // encId: 编码器ID,对于轴编码器通道,取值范围[0,n],对于扩展编码器通道,256表示第一个扩展编码器通道,257表示第二个,以此类推
    // encMode:编码器模式,参考宏定义
    public static short NMC_SetEncMode(HAND devHandle, short encId, short encMode) {return lib.NMC_SetEncMode(devHandle, encId, encMode);}
    // 设置软件限位是否停止运动
    // enable：软件限位触发允许设置,1为允许,0为禁止
    public static short NMC_MtSwLmtOnOff(HAND axisHandle, short swt) {
        return lib.NMC_MtSwLmtOnOff(axisHandle, swt);
    }
    // 设置软件限位数值
    // posLmt：正向软件限位设置值
    // negLmt：负向软件限位设置值。单位为脉冲数
    public static short NMC_MtSwLmtValue(HAND axisHandle, NativeLong posLmt, NativeLong negLmt) {return lib.NMC_MtSwLmtValue(axisHandle, posLmt, negLmt);}
    /*TSafePara 结构体*/
    //轴运动安全参数
    public static class TSafePara extends Structure {
        public double estpDec;
        public double maxVel;
        public double maxAcc;
        @Override
        protected List<String> getFieldOrder() {
            return Arrays.asList("estpDec", "maxVel", "maxAcc");
        }
    }
    // 设置轴安全参数
    // TSafePara：包含急停减速度、最大允许速度、最大允许加速度
    public static short NMC_MtSetSafePara(HAND axisHandle, TSafePara pPara) {return lib.NMC_MtSetSafePara(axisHandle, pPara);}
    // 设置脉冲输出模式
    // inv, 1：取反,0：不取反
    // mode 0：脉冲方向 1：正负脉冲
    public static short NMC_MtSetStepMode(HAND axisHandle, short inv, short mode) {return lib.NMC_MtSetStepMode(axisHandle, inv, mode);}
    // 设置轴速度滤波参数
    // 注：filterCoef系数在0~5之间,值越大,速度越平滑，默认值为0
    public static short NMC_MtSetAxisVelFilter(HAND axisHandle, short filterCoef) {return lib.NMC_MtSetAxisVelFilter(axisHandle, filterCoef);}
    // 硬件限位配置
    // posLmtEnable: 正向限位触发允许设置,1为允许,0为禁止
    // negLmtEnable: 负向限位触发允许设置,1为允许,0为禁止
    // posLmtSns: 正向限位触发电平,1为高电平触发,0为低电平触发
    // negLmtSns: 正向限位触发电平,1为高电平触发,0为低电平触发
    public static short NMC_MtSetLmtCfg(HAND axisHandle, short posLmtEnable, short negLmtEnable, short posLmtSns, short negLmtSns) {
        return lib.NMC_MtSetLmtCfg(axisHandle, posLmtEnable, negLmtEnable, posLmtSns, negLmtSns);}
    // 伺服报警配置
    // alarmEnable: 伺服报警触发允许设置,1为允许,0为禁止
    // alarmSns:     伺服报警触发电平,1为高电平触发,0为低电平触发
    public static short NMC_MtSetAlarmCfg(HAND axisHandle, short alarmEnable, short alarmSns) {
        return lib.NMC_MtSetAlarmCfg(axisHandle, alarmEnable, alarmSns);}
    // 设置脉冲输出滤波
    // coe系数： 范围0~65535,0不滤波,数值越大滤波效果越明显。
    public static short NMC_MtSetStepFilter(HAND axisHandle, short coe) {return lib.NMC_MtSetStepFilter(axisHandle, coe);}


    //3.单轴控制指令
    /* 各轴的规划模式 */
    public static final short MT_NONE_PRF_MODE = -1;  // 无效
    public static final short MT_PTP_PRF_MODE = 0;    // 梯形规划
    public static final short MT_JOG_PRF_MODE = 1;    // 连续速度模式
    public static final short MT_CRD_PRF_MODE = 3;    // 坐标系
    public static final short MT_GANTRY_MODE = 4;     // 龙门跟随模式
    public static final short MT_PT_PRF_MODE = 5;     // PT模式
    public static final short MT_MULTI_LINE_MODE = 6; // 多轴直线插补
    public static final short MT_GEAR_PRF_MODE = 7;   // 电子齿轮模式
    public static final short MT_FOLLOW_PRF_MODE = 8; // Follow跟随模式
    public static final short MT_PVT_PRF_MODE = 9;    // PVT模式
    // 设置单轴规划模式
    // mode：单轴运动模式,参考宏定义
    public static short NMC_MtSetPrfMode(HAND axisHandle, short mode) {return lib.NMC_MtSetPrfMode(axisHandle, mode);}
    /*TPtpPara 结构体*/
    // 单轴PTP运动参数结构
    public static class TPtpPara extends Structure {
        public double acc;                      // 加速度
        public double dec;                      // 减速度
        public double startVel;                 // 起跳速度
        public double endVel;                   // 终止速度
        public short smoothCoef;                // 平滑系数,取值范围[0,199]
        public short[] reserved = new short[3]; // 保留
        @Override
        protected List<String> getFieldOrder() {
            return Arrays.asList("acc", "dec", "startVel", "endVel", "smoothCoef", "reserved");}
    }
    // 设置多个参数, 并更新。
    // pAxPara：参数,参考结构定义。
    public static short NMC_MtSetPtpPara(HAND axisHandle, TPtpPara pAxPara) {return lib.NMC_MtSetPtpPara(axisHandle, pAxPara);}
    /*TTrapTime 结构体*/
    public static class TTrapTime extends Structure {
        public double totalTime;                // 当前点位运动的总时间，单位:ms
        public double leftTime;                 // 当前点位运动的剩余时间，单位:ms
        public double[] reseved = new double[2];// 保留
        @Override
        protected List<String> getFieldOrder() {
            return Arrays.asList("totalTime", "leftTime", "reseved");
        }
    }
    // 获取当前点位运动执行时间参数
    public static short NMC_MtGetTrapTime(HAND axisHandle, TTrapTime pTrapTime) {return lib.NMC_MtGetTrapTime(axisHandle, pTrapTime);}
    // 设置Jog运动参数
    // pAxPara：参数,参考结构定义。
    /*TJogPara 结构体*/
    public static class TJogPara extends Structure {
        public double acc;          // 加速度
        public double dec;          // 减速度
        public double smoothCoef;   // 平滑系数,取值范围[0,199],数值越大则速度变化越平滑
        @Override
        protected List<String> getFieldOrder() {
            return Arrays.asList("acc", "dec", "smoothCoef");
        }
    }
    public static short NMC_MtSetJogPara(HAND axisHandle, TJogPara pAxPara) {return lib.NMC_MtSetJogPara(axisHandle, pAxPara);}
    // 设置目标运动速度,只针对PTP和Jog：PTP模式下只接受正数,Jog模式下正负号标识运动方向
    // vel: 目标速度（最大速度）,单位是 脉冲/ms
    public static short NMC_MtSetVel(HAND axisHandle, double vel) {return lib.NMC_MtSetVel(axisHandle, vel);}
    // 设置目标运动位置,只针对PTP
    // pos: 目标位置,单位是 脉冲
    public static short NMC_MtSetPtpTgtPos(HAND axisHandle, NativeLong pos) {return lib.NMC_MtSetPtpTgtPos(axisHandle, pos);}
    // 参数更新, 只针对PTP和Jog
    public static short NMC_MtUpdate(HAND axisHandle) {
        return lib.NMC_MtUpdate(axisHandle);
    }
    // 单轴运动停止
    // 注：运动会按设定的减速度停止。
    public static short NMC_MtStop(HAND axisHandle) {
        return lib.NMC_MtStop(axisHandle);
    }
    // 单轴急停，不会置起急停标志位
    // 注：运动会按设定的急停加速度停止。如果没有设置,则会立即停止。
    public static short NMC_MtAbruptStop(HAND axisHandle) {
        return lib.NMC_MtAbruptStop(axisHandle);
    }
    // 单轴位置系统清零,规划以及编码器
    public static short NMC_MtZeroPos(HAND axisHandle) {
        return lib.NMC_MtZeroPos(axisHandle);
    }
    // 设置伺服报警清除输出的状态
    // swt: 设置开关有效状态。0, 有效（输出低电平）,1,无效（输出高电平）
    public static short NMC_MtSetSvClr(HAND axisHandle, short swt) {
        return lib.NMC_MtSetSvClr(axisHandle, swt);
    }
    // 设置伺服ON, 轴静止时执行,如果后面是update指令,需要延时一个周期
    public static short NMC_MtSetSvOn(HAND axisHandle) {
        return lib.NMC_MtSetSvOn(axisHandle);
    }
    // 设置伺服OFF, 轴静止时执行,如果后面是update指令,需要延时一个周期
    public static short NMC_MtSetSvOff(HAND axisHandle) {
        return lib.NMC_MtSetSvOff(axisHandle);
    }
    // 清除轴错误状态
    public static short NMC_MtClrError(HAND axisHandle) {
        return lib.NMC_MtClrError(axisHandle);
    }
    // 清除轴错误状态,按位清除
    // stsMask:对应位为1表明需要清除对应位的错误状态
    public static short NMC_MtClrStsByBits(HAND axisHandle, short stsMask) {return lib.NMC_MtClrStsByBits(axisHandle, stsMask);}
    // 单轴点位运动,包含NMC_MtSetPrfMode,NMC_MtSetPtpPara,NMC_MtSetVel,NMC_MtSetPtpTgtPos,NMC_MtUpdate
    // acc:加速度,dec：减速度,startVel:起跳速度,endVel:终止速度,smoothCoef:平滑系数
    // maxVel：最大速度
    // tgtPos:目标位置,单位：脉冲
    public static short NMC_MtMovePtpAbs(HAND axisHandle, double acc, double dec, double startVel, double endVel, double maxVel, short smoothCoef, NativeLong tgtPos) {
        return lib.NMC_MtMovePtpAbs(axisHandle, acc, dec, startVel, endVel, maxVel, smoothCoef, tgtPos);}
    // 单轴连续速度运动
    // acc:加速度,dec：减速度,smoothCoef:平滑系数
    // maxVel：最大速度
    // clrStsFlag:是否运动前先清除轴状态，0：不清除，1：清除
    public static short NMC_MtMoveJog(HAND axisHandle, double acc, double dec, double maxVel, short smoothCoef, short clrStsFlag) {
        return lib.NMC_MtMoveJog(axisHandle, acc, dec, maxVel, smoothCoef, clrStsFlag);}
    /*TMovePtpPack8 结构体*/
    public static class TMovePtpPack8 extends Structure {
        public short axisMask;                      // 轴掩码，对应bit为1表示该轴参与运动
        public short clrStsFlag;                    // 是否运动前先清除轴状态，0：不清除，1：清除
        public short[] reserved = new short[2];     // 保留
        public double[] acc = new double[8];        // 加速度
        public double[] dec = new double[8];        // 减加速度
        public double[] startVel = new double[8];   // 起跳速度
        public double[] endVel = new double[8];     // 终止速度
        public double[] maxVel = new double[8];     // 最大速度
        public short[] smoothCoef = new short[8];   // 平滑系数
        public NativeLong[] tgtPos = new NativeLong[8];           // 位置，单位:脉冲
        @Override
        protected List<String> getFieldOrder() {
            return Arrays.asList("axisMask", "clrStsFlag", "reserved", "acc", "dec", "startVel", "endVel", "maxVel", "smoothCoef", "tgtPos");}
    }
    // 单轴点位运动打包(绝对运动)
    // axisFirstHandle:数组的第一个轴句柄
    // pPackData:打包参数
    // 注意：1.如果某轴存在无法运动的错误状态，则所有轴不会启动运动
    public static short NMC_MtMovePtpAbsPack8(HAND axisFirstHandle, TMovePtpPack8[] pPackData) {
        return lib.NMC_MtMovePtpAbsPack8(axisFirstHandle, pPackData);}
    // 单轴点位运动打包(相对运动)
    // axisFirstHandle:数组的第一个轴句柄
    // pPackData:打包参数
    // 注意：1.如果某轴存在无法运动的错误状态，则所有轴不会启动运动
    public static short NMC_MtMovePtpRelPack8(HAND axisFirstHandle, TMovePtpPack8[] pPackData ) {
        return lib.NMC_MtMovePtpRelPack8(axisFirstHandle, pPackData);}
    // 单轴点位运动,相对运动
    // acc:加速度,dec：减速度,startVel:起跳速度,endVel:终止速度,smoothCoef:平滑系数
    // maxVel：最大速度
    // relPos:相对当前位置的移动量,单位：脉冲
    public static short NMC_MtMovePtpRel(HAND axisHandle, double acc, double dec, double startVel, double endVel, double maxVel, short smoothCoef, NativeLong relPos) {
        return lib.NMC_MtMovePtpRel(axisHandle, acc, dec, startVel, endVel, maxVel, smoothCoef, relPos);}
    // 多轴同步运动（通过PTP实现）
    // axisMask:参与轴的掩码
    // acc,dev:加速度,减速度
    // sVel,eVel，maxVel:启动速度,终点速度，最大速度
    // smooth:平滑系数
    // pPosArray:目标位置数组
    public static short NMC_MtMultiMoveAbs(HAND devHandle, short axisMask, double acc, double dec, double sVel, double eVel, double maxVel, short smooth, NativeLong[] pPosArray) {
        return lib.NMC_MtMultiMoveAbs(devHandle, axisMask, acc, dec, sVel, eVel, maxVel, smooth, pPosArray);}
    /*TPtpTwoStagePrm 结构体*/
    // PTP两段速运动参数
    public static class TPtpTwoStagePrm extends Structure {
        public double acc;          // 加速度
        public double dec;          // 减速度
        public double startVel;     // 启动速度
        public double endVel;       // 终点速度
        public double maxVel;       // 最大速度
        public NativeLong tgtPos;          // 目标位置
        public short reserved;      // 保留参数
        public short smoothCoef;    // 平滑系数
        public short inType;        // 输入类型：0：通用DI，1：Home信号;2:规划位置;3:编码器;4:外部输入
        public short inIdx;         // 输入信号通道号
        public short inTrigLevel;   // 触发电平，0：低电平，1：高电平
        public short action;        // 触发后的动作，0：不动作，1：更新目标速度;2:更新目标位置;3:更新目标位置（位置为相对触发点的相对位置）4:急停
        public double prm1;         // action=1时表示更新的目标速度
        public double prm2;         // action=2，3时表示更新的目标位置
        public double prm3;         // 保留
        public double prm4;         // 对于数值类型的输入，prm4代表比较数值
        @Override
        protected List<String> getFieldOrder() {
            return Arrays.asList("acc", "dec", "startVel", "endVel", "maxVel", "tgtPos", "reserved", "smoothCoef", "inType", "inIdx", "inTrigLevel", "action", "prm1", "prm2", "prm3", "prm4");}
    }
    // 两段速PTP运动
    public static short NMC_MtMovePtpAbsTwoStage(HAND axisHandle, TPtpTwoStagePrm pPrm) {
        return lib.NMC_MtMovePtpAbsTwoStage(axisHandle, pPrm);}


    // 4.单轴状态读取
    // 读取规划坐标系的位置
    // pPos : 返回位置,单位是 脉冲
    public static short NMC_MtGetPrfPos(HAND axisHandle, NativeLongByReference pPos) {return lib.NMC_MtGetPrfPos(axisHandle, pPos);}
    // 读当前轴规划速度
    // pVel: 返回速度,单位是 脉冲/ms
    public static short NMC_MtGetPrfVel(HAND axisHandle, DoubleByReference pVel) {return lib.NMC_MtGetPrfVel(axisHandle, pVel);}
    // 读当前轴规划加速度
    // count:数量，可以获取多个轴的规划加速度，axisHandle为第一个轴的句柄
    // pAcc: 返回加速度,单位是 脉冲/ms.ms
    public static short NMC_MtGetPrfAcc(HAND axisHandle, double[] pAcc, short count) {
        return lib.NMC_MtGetPrfAcc(axisHandle, pAcc, count);}
    // 读取打包轴状态（4轴）
    public static final int PACK_AXIS_NUM = 4;
    /*TAxisStsPack 结构体*/
    public static class TAxisStsPack extends Structure {
        public NativeLong[] prfPos = new NativeLong[PACK_AXIS_NUM];       // 规划位置
        public NativeLong[] encPos = new NativeLong[PACK_AXIS_NUM];       // 实际位置
        public float[] prfVel = new float[PACK_AXIS_NUM];   // 规划速度
        public NativeLong[] motionIO = new NativeLong[PACK_AXIS_NUM];     // 轴专用IO
        public short[] sts = new short[PACK_AXIS_NUM];      // 轴状态
        public NativeLong gpo;                                     // 通用输出
        public NativeLong gpi;                                     // 通用输入
        @Override
        protected List<String> getFieldOrder() {
            return Arrays.asList("prfPos[PACK_AXIS_NUM]", "encPos[PACK_AXIS_NUM]", "prfVel[PACK_AXIS_NUM]", "motionIO[PACK_AXIS_NUM]", "sts[PACK_AXIS_NUM]", "gpo", "gpi");}
    }
    // 打包读取多个轴的状态,从第一个轴开始读取后续四个轴的状态
    // axisFirstHandle : 第一个轴句柄
    // count:读取状态的轴数量,取值范围：[1,4]
    // pPackSts: 打包的状态数据,参考结构体定义
    public static short NMC_MtGetStsPack(HAND axisFirstHandle, short count, TAxisStsPack pPackSts) {
        return lib.NMC_MtGetStsPack(axisFirstHandle, count, pPackSts);}
    /*TAxisStsPack12Ex 结构体*/
    public static class TAxisStsPack12Ex extends Structure {
        public short[] mtSts = new short[12];       // 单轴状态，位定义参考NMC_MtGetSts
        public short[] mtMio = new short[12];       // 单轴专用IO,位定义参考NMC_MtGetMotionIO
        public short[] mtMioLog = new short[12];    // 单轴专用IO:逻辑电平,位定义参考NMC_MtGetMotionIOLogical
        public NativeLong[] mtPrfPos = new NativeLong[12];        // 单轴规划位置
        public NativeLong[] mtEncPos = new NativeLong[12];        // 单轴实际位置
        public float[] mtPrfVel = new float[12];    // 单轴规划速度
        public short[] crdSts = new short[2];       // 坐标系状态
        public float[] crdPrfVel = new float[2];    // 坐标系运动速度
        public NativeLong[] crdUserSeg = new NativeLong[2];       // 坐标系运行的缓冲区段号
        public NativeLong[] crdFreeSpace = new NativeLong[2];     // 坐标系缓冲区剩余空间
        public NativeLong[] crdUsedSpace = new NativeLong[2];     // 坐标系缓冲区使用空间
        public NativeLong gpi;                             // 通用输入
        public NativeLong gpo;                             // 通用输出
        public NativeLong[] crdLeftLen = new NativeLong[2];       // 坐标系缓冲区剩余段长，单位:脉冲
        public NativeLong[] crdAllCmdCnt = new NativeLong[2];     // 坐标系缓冲区总共压入的指令数目
        public NativeLong[] extDi = new NativeLong[6];            // 扩展模块输入，2号站~8号站
        public NativeLong[] extDo = new NativeLong[6];            // 扩展模块输出，2号站~8号站
        public short[] adc = new short[4];          // 模拟量输入值 0~4通道
        public short[] adcAux = new short[2];       // 扩展模拟量输入值 0~1通道
        public short[] dac = new short[4];          // 模拟量输出值 0~4通道
        public short[] dacAux = new short[2];       // 扩展模拟量输出值 0~1通道
        public NativeLong[] reserved = new NativeLong[10];        // 预留
        @Override
        protected List<String> getFieldOrder() {
            return Arrays.asList("mtSts", "mtMio", "mtMioLog", "mtPrfPos", "mtEncPos", "mtPrfVel", "crdSts", "crdPrfVel", "crdUserSeg", "crdFreeSpace", "crdUsedSpace", "gpi", "gpo", "crdLeftLen", "crdAllCmdCnt", "extDi", "extDo", "adc", "adcAux", "dac", "dacAux", "reserved");}
    }
    // 打包读取12个轴的状态
    // axisFirstHandle : 第一个轴句柄
    // pPackSts: 打包的状态数据,参考结构体定义
    public static short NMC_MtGetStsPack12Ex(HAND axisFirstHandle, TAxisStsPack12Ex pPackSts) {
        return lib.NMC_MtGetStsPack12Ex(axisFirstHandle, pPackSts);}
    /*TMcStsPackEx 结构体*/
    // 快速读取打包状态
    public static class TMcStsPackEx extends Structure {
        public short[] sts = new short[8];      // 轴状态
        public short[] crdSts = new short[2];   // 坐标系状态
        @Override
        protected List<String> getFieldOrder() {
            return Arrays.asList("sts", "crdSts");}
    }
    // 打包读取控制器状态
    // devHandle : 控制器句柄
    // pPackSts: 打包的状态数据,参考结构体定义
    public static short NMC_MtGetStsPackEx(HAND devHandle, TMcStsPackEx pPackSts) {
        return lib.NMC_MtGetStsPackEx(devHandle,pPackSts);}
    /*TMcStsPackEx2 结构体*/
    // 快速读取打包状态
    public static class TMcStsPackEx2 extends Structure {
        public short sts[] = new short[8];      // 轴状态
        public short crdSts[] = new short[2];   // 坐标系状态
        public short extSts[] = new short[3];   // 扩展高速状态
        @Override
        protected List<String> getFieldOrder() {
            return Arrays.asList("sts", "crdSts", "extSts");
        }
    }
    // 打包读取控制器状态
    // devHandle : 控制器句柄
    // pPackSts: 打包的状态数据,参考结构体定义
    public static short NMC_MtGetStsPackEx2(HAND devHandle, TMcStsPackEx2 pPackSts) {
        return lib.NMC_MtGetStsPackEx2(devHandle,pPackSts);}
    // 快速读取轴状态
    public static short NMC_MtGetStsEx(HAND axisHandle, ShortByReference pStsWord) {
        return lib.NMC_MtGetStsEx(axisHandle, pStsWord);}
    // 快速读取坐标系状态
    public static short NMC_CrdGetStsEx2(HAND crdHandle, ShortByReference pStsWord) {
        return lib.NMC_CrdGetStsEx2(crdHandle, pStsWord);}
    // 启用扩展的状态读取指令功能
    // enFlag:是否启用，1-启用，0-关闭，默认为关闭状态
    public static short NMC_DevSetStsExCmdEn(HAND devHandle, short enFlag) {
        return lib.NMC_DevSetStsExCmdEn(devHandle, enFlag);}
    // 读当前轴编码器通道
    // pPos:返回编码器数值
    public static short NMC_MtGetEncPos(HAND axisHandle, NativeLongByReference pPos) {return lib.NMC_MtGetEncPos(axisHandle, pPos);}
    // 读轴编码器速度(单位是：脉冲/ms)
    public static short NMC_GetEncVel(HAND devHandle, short encId, DoubleByReference pVel) {
        return lib.NMC_GetEncVel(devHandle, encId, pVel);}
    // 轴状态字位定义
    public static final short BIT_AXIS_BUSY = 0x00000001;         // bit 0 , 运动:1 ,静止 0
    public static final short BIT_AXIS_POSREC = 0x00000002;       // bit 1 , 伺服位置到达,步进模式时位置到达,伺服模式时实际位置到达误差限
    public static final short BIT_AXIS_MVERR = 0x00000004;        // bit 2 , 上次运动出错,或当前无法启动运动,需要调用NMC_MtClrError清除
    public static final short BIT_AXIS_SVON = 0x00000008;         // bit 3 , 伺服允许
    public static final short BIT_AXIS_CRD = 0x00000010;          // bit 4 , 坐标系模式
    public static final short BIT_AXIS_STEP = 0x00000020;         // bit 5 , 步进/伺服
    public static final short BIT_AXIS_LMTP = 0x00000040;         // bit 6 , 正向限位，反向离开会自动清除
    public static final short BIT_AXIS_LMTN = 0x00000080;         // bit 7 , 负面限位，反向离开会自动清除
    public static final short BIT_AXIS_SOFTPOSLMT = 0x00000100;   // bit 8 , 正向软限位触发
    public static final short BIT_AXIS_SOFTNEGLMT = 0x00000200;   // bit 9 , 负向软限位触发
    public static final short BIT_AXIS_ALM = 0x00000400;          // bit 10 , 伺服报警,需要调用NMC_MtClrError清除
    public static final short BIT_AXIS_POSERR = 0x00000800;       // bit 11 , 位置超限,需要调用NMC_MtClrError清除
    public static final short BIT_AXIS_ESTP = 0x00001000;         // bit 12 , 急停,需要调用NMC_MtClrError清除
    public static final short BIT_AXIS_HWERR = 0x00002000;        // bit 13 , 硬件错误
    public static final short BIT_AXIS_CAPTSET = 0x00004000;      // bit 14 , 捕获触发
    // 读当前轴状态
    // pStsWord: 返回轴状态字。参考位定义
    public static short NMC_MtGetSts(HAND axisHandle, ShortByReference pStsWord) {
        return lib.NMC_MtGetSts(axisHandle, pStsWord);}
    // 专用IO定义,arrive,alm : home : limit+ , limit- servoClr
    public static final int BIT_AXMTIO_LMTN =0x00000001;       // bit 0 ,负向限位
    public static final int BIT_AXMTIO_LMTP = 0x00000002;       // bit 1 ,正向限位
    public static final int BIT_AXMTIO_HOME = 0x00000004;       // bit 2 ,原点
    public static final int BIT_AXMTIO_ALARM = 0x00000008;      // bit 3 ,驱动报警
    public static final int BIT_AXMTIO_ARRIVE = 0x00000010;     // bit 4 ,电机到位
    public static final int BIT_AXMTIO_CAPT = 0x00000020;       // bit 5 ,捕获源信号
    public static final int BIT_AXMTIO_SVRCLR = 0x00000100;     // bit 8 ,伺服清除信号
    // 读运动控制专用IO
    // pIoValue : 返回专用IO的状态,原点,限位,报警，伺服清除输出等。参考位定义。对应位为0为低电平,1为高电平。
    public static short NMC_MtGetMotionIO(HAND axisHandle, IntByReference pIoValue) {
        return lib.NMC_MtGetMotionIO(axisHandle, pIoValue);}
    // 读运动控制专用IO,逻辑电平
    // pIoValue : 返回专用IO的状态,原点,限位,报警。参考位定义。对应位为0为低电平,1为高电平。
    public static short NMC_MtGetMotionIOLogical(HAND axisHandle, IntByReference pIoValue) {
        return lib.NMC_MtGetMotionIOLogical(axisHandle, pIoValue);}


    //5.IO控制及外部资源读写
    // 设置通用输出(按通道,支持超过32位),带默认group
    // value: 设置通用数字量输出。1, 输出高电平,0,输出低电平
    // groupID:DO组,取值范围[0,n],具体需要看控制器是否存在多组数字量输出
    public static short NMC_SetDOGroup(HAND devHandle, NativeLong value, short groupID) {
        return lib.NMC_SetDOGroup(devHandle, value, groupID);}
    // 读通用输入(按通道,支持超过32位) ,带默认group
    // pInValue: 通用数字量输入值。1, 高电平,0,低电平
    // groupID:DI组,取值范围[0,n],0: 本地DI31~DI0, 1: 本地DI63~DI32,其他指扩展IO模块
    public static short NMC_GetDIGroup(HAND devHandle, NativeLongByReference pInValue, short groupID) {
        return lib.NMC_GetDIGroup(devHandle, pInValue, groupID);}
    // 读取通用输出(按通道,支持超过32位),带默认group
    // pDoValue: 设置通用数字量输出。1, 高电平,0,低电平
    // groupID:DO组,取值范围[0,n],,0: 本地DO31~DO0, 1: 本地DO63~DO32,其他指扩展IO模块
    public static short NMC_GetDOGroup(HAND devHandle, NativeLongByReference pDoValue, short groupID) {
        return lib.NMC_GetDOGroup(devHandle, pDoValue, groupID);}
    // 按位设置通用输出
    // bitIndex:取值范围[0,n],位序号,前64位为本地的通用输出,大于64为扩展DO
    // value: 设置通用数字量输出。1, 输出高电平,0,输出低电平
    public static short NMC_SetDOBit(HAND devHandle, short bitIndex, short value) {
        return lib.NMC_SetDOBit(devHandle, bitIndex, value);}
    // 按位读输出
    public static short NMC_GetDOBit(HAND devHandle, short bitIndex, ShortByReference bitValue) {
        return lib.NMC_GetDOBit(devHandle, bitIndex, bitValue);}
    // 按位读通用输入
    // 读通用输入(按通道,支持超过32位)
    // bitIndex:取值范围[0,n],位序号
    // pBitValue: 通用数字量输入值。1, 高电平,0,低电平
    public static short NMC_GetDIBit(HAND devHandle, short bitIndex, ShortByReference pBitValue) {
        return lib.NMC_GetDIBit(devHandle, bitIndex, pBitValue);}
    // 读取扩展IO模块的状态
    // sts:io模块状态
    public static short NMC_GetIOModuleSts(HAND devHandle, NativeLong sts) {
        return lib.NMC_GetIOModuleSts(devHandle, sts);}
    // 设置扩展IO模块有效（默认为IO64模块）
    // chDevId:设备ID
    public static short NMC_SetIOModuleEn(HAND devHandle, byte chDevId) {
        return lib.NMC_SetIOModuleEn(devHandle,chDevId);}
    /* 扩展模块类型定义 */
    public static final short IOMODULE_TYPE_IO64 = 1; // 32DI32DO模块（包括16DI16DO模块）
    public static final short IOMODULE_TYPE_IO32_DA = 2; // 4AD4DA模块
    // 设置扩展IO模块有效(带模块类型)
    // chDevId:设备ID
    // chDevType:模块类型，见宏定义
    public static short NMC_IOModuleSetEn(HAND devHandle, byte chDevId, short chDevType) {
        return lib.NMC_IOModuleSetEn(devHandle, chDevId, chDevType);}
    // 读取扩展IO模块类型
    // chDevId:设备ID
    // pChDevType:返回的模块类型，见宏定义
    public static short NMC_IOModuleGetType(HAND devHandle, byte chDevId, ShortByReference pChDevType) {
        return lib.NMC_IOModuleGetType(devHandle, chDevId, pChDevType);}
    // 扩展IO模块通道写，8位长度
    // chDevId：设备站号
    // offset:数据偏移
    public static short NMC_IOModuleWr8Bit(HAND devHandle, byte chDevId, byte offset, byte data) {
        return lib.NMC_IOModuleWr8Bit(devHandle,chDevId,offset,data);}
    // 扩展IO模块通道写，16位长度
    public static short NMC_IOModuleWr16Bit(HAND devHandle, byte chDevId, byte offset, byte data) {
        return lib.NMC_IOModuleWr16Bit(devHandle,chDevId,offset,data);}
    // 扩展IO模块通道写，32位长度
    public static short NMC_IOModuleWr32Bit(HAND devHandle, byte chDevId, byte offset, byte data) {
        return lib.NMC_IOModuleWr32Bit(devHandle,chDevId,offset,data);}
    // 扩展IO模块通道读输出，8位长度
    // chDevId：设备站号
    // offset:数据偏移
    public static short NMC_IOModuleRdOut8Bit(HAND devHandle, byte chDevId, byte offset, ByteByReference pData) {
        return lib.NMC_IOModuleRdOut8Bit(devHandle, chDevId, offset, pData);}
    // 扩展IO模块通道读，16位长度
    public static short NMC_IOModuleRdOut16Bit(HAND devHandle, byte chDevId, byte offset, ShortByReference pData) {
        return lib.NMC_IOModuleRdOut16Bit(devHandle, chDevId, offset, pData);}
    // 扩展IO模块通道读，32位长度
    public static short NMC_IOModuleRdOut32Bit(HAND devHandle, byte chDevId, byte offset, NativeLongByReference pData) {
        return lib.NMC_IOModuleRdOut32Bit(devHandle, chDevId, offset, pData);}
    // 扩展IO模块通道读，8位长度
    // chDevId：设备站号
    // offset:数据偏移
    public static short NMC_IOModuleRd8Bit(HAND devHandle, byte chDevId, byte offset, ByteByReference pData){
        return lib.NMC_IOModuleRd8Bit(devHandle, chDevId, offset, pData);}
    // 扩展IO模块通道读输出，16位长度
    public static short NMC_IOModuleRd16Bit(HAND devHandle, byte chDevId, byte offset, ShortByReference pData) {
        return lib.NMC_IOModuleRd16Bit(devHandle, chDevId, offset, pData);}
    // 扩展IO模块通道读输出，32位长度
    public static short NMC_IOModuleRd32Bit(HAND devHandle, byte chDevId, byte offset, NativeLongByReference pData) {
        return lib.NMC_IOModuleRd32Bit(devHandle, chDevId, offset, pData);}


    //6.坐标系配置
    public static final int CRD_MAX_DIMENSION = 4;
    /*TCrdConfig 结构体*/
    // 坐标系配置
    public static class TCrdConfig extends Structure {
        public short axCnts;                    // 参与的轴数量
        public short[] reserved = new short[3]; // 保留
        public short[] pAxArray = new short[4]; // 坐标系轴映射表,轴序号取值范围[0,n]
        public short[] port = new short[4];     // 坐标系端口映射表,统一设为0
        @Override
        protected List<String> getFieldOrder() {
            return Arrays.asList("axCnts", "reserved", "pAxArray", "port");
        }
    }
    // 建立插补坐标系系统(必须)
    // pConfig:坐标系配置,参考结构体定义
    public static short NMC_CrdConfig(HAND crdHandle, TCrdConfig pConfig) {
        return lib.NMC_CrdConfig(crdHandle, pConfig);}
    //缓冲区运动安全参数
    /*TCrdSafePara 结构体*/
    public static class TCrdSafePara extends Structure {
        public double estpDec;  // 急停加速度
        public double maxVel;   // 最大速度
        public double maxAcc;   // 最大加速度
        @Override
        protected List<String> getFieldOrder() {
            return Arrays.asList("estpDec", "maxVel", "maxAcc");
        }}
    // 设置轴缓冲区运动安全参数
    // pPara：包含急停减速度、最大允许速度、最大允许加速度
    public static short NMC_CrdSetSafePara(HAND crdHandle, TCrdSafePara pPara) {
        return lib.NMC_CrdSetSafePara(crdHandle, pPara);}
    // 设置轴缓冲区运动偏移
    // count:设置偏移的轴数
    // pOffsetArray：缓冲区运动偏移,long数组
    // 注：会同时修改坐标系内相关轴的运动偏移！
    public static short NMC_CrdSetOffset(HAND crdHandle, short count, NativeLong[] pOffsetArray) {
        return lib.NMC_CrdSetOffset(crdHandle, count, pOffsetArray);}
    // 删除坐标系
    public static short NMC_CrdDelete(HAND crdHandle) {
        return lib.NMC_CrdDelete(crdHandle);}


    //7.坐标系运行控制
    // 坐标系缓冲运动启动
    public static short NMC_CrdStartMtn(HAND crdHandle) {
        return lib.NMC_CrdStartMtn(crdHandle);}
    // 立即平滑停止运动
    // 注：立即停止运动。并不清空指令缓冲区。需要再次启动才能继续运行缓冲区指令。
    public static short NMC_CrdStopMtn(HAND crdHandle) {
        return lib.NMC_CrdStopMtn(crdHandle);}
    // 急停
    // 并不清空指令缓冲区
    public static short NMC_CrdEstopMtn(HAND crdHandle) {
        return lib.NMC_CrdEstopMtn(crdHandle);}
    // 结束缓冲区运动（等待运动完后才结束区运动,并置空闲标志）
    // 注：缓冲区运动结束并不立即停止运动。把指令缓冲区全部执行完后,结束缓冲区运动状态。
    public static short NMC_CrdEndMtn(HAND crdHandle) {
        return lib.NMC_CrdEndMtn(crdHandle);}
    // 返回缓冲区运动的断点
    // vel:返回时使用的速度
    // acc:返回时使用的加速度
    public static short NMC_CrdGotoBreak(HAND crdHandle, double acc, double vel) {
        return lib.NMC_CrdGotoBreak(crdHandle, acc, vel);}


    //8.坐标系及运动缓冲区状态读取
    /* 坐标系状态字位定义 */
    public static final short BIT_CORD_BUSY = 0x00000001;           // bit 0, 运动:1, 静止 0,立即运动下运动停止,完成
    public static final short BIT_CORD_MVERR = 0x00000002;          // bit 1, 运动出错,或当前运动指令无法启动,需要软件复位
    public static final short BIT_CORD_EMPTY = 0x00000004;          // bit 2, 缓冲区空
    public static final short BIT_CORD_FULL = 0x00000008;           // bit 3, 缓冲区满
    public static final short BIT_CORD_NODATASTOP = 0x00000010;     // bit 4, 缓冲区空异常停止或者急停
    public static final short BIT_CORD_SDRAM_HWERR = 0x00000020;    // bit 5, 插补缓冲区硬件或者其他错误
    // 读取坐标系状态
    // pStsWord：返回状态字,参考宏定义
    public static short NMC_CrdGetSts(HAND crdHandle, ShortByReference pStsWord) {
        return lib.NMC_CrdGetSts(crdHandle, pStsWord);}
    /*TPackedCrdSts4 结构体*/
    public static class TPackedCrdSts4 extends Structure {
        public short crdSts;                    // 坐标系状态
        public short[] axSts = new short[4];    // 坐标系里各轴状态
        public NativeLong[] prfPos = new NativeLong[4];       // 用户坐标系下的规划位置
        public NativeLong[] axisPos = new NativeLong[4];      // 机械坐标系下的规划位置
        public NativeLong[] encPos = new NativeLong[4];       // 编码器位置
        public NativeLong userSeg;                     // 运行的缓冲区段号
        public double prfVel;                   // 运动速度
        public NativeLong gpDi;                        // 通用输入0~31
        public NativeLong gpDo;                        // 通用输出0~31
        public short[] motDi = new short[4];    // 限位、原点、报警。请参考专用IO位定义( 搜索 BIT_AXMTIO_LMTN )
        public short reserved;                  // 保留
        public NativeLong crdFreeSpace;                // 缓冲区剩余空间
        public NativeLong crdUsedSpace;
        @Override
        protected List<String> getFieldOrder() {
            return Arrays.asList("crdSts", "axSts", "prfPos", "axisPos", "encPos", "userSeg", "prfVel", "gpDi", "gpDo", "motDi", "reserved", "crdFreeSpace", "crdUsedSpace");}
    }
    // 坐标系运动模式下,打包读取控制器状态
    public static short NMC_CrdGetStsPack4(HAND crdHandle, TPackedCrdSts4 pPackSts) {
        return lib.NMC_CrdGetStsPack4(crdHandle, pPackSts);}
    // 清坐标系运动错误状态,同时清除所包含轴的错误状态
    public static short NMC_CrdClrError(HAND crdHandle){
        return lib.NMC_CrdClrError(crdHandle);}
    // 读取指令缓冲区空闲长度
    // pRes：返回空闲的长度
    public static short NMC_CrdBufGetFree(HAND crdHandle, NativeLongByReference pRes) {
        return lib.NMC_CrdBufGetFree(crdHandle, pRes);}
    // 读取指令缓冲区已用长度
    // pLen: 长度。缓冲区中还未执行的指令个数。
    public static short NMC_CrdBufGetUsed(HAND crdHandle, NativeLongByReference pLen) {
        return lib.NMC_CrdBufGetUsed(crdHandle, pLen);}
    // 获取插补缓冲区中尚未完成的总位移量
    // pLen: 长度
    public static short NMC_CrdGetBufLeftLength(HAND crdHandle, DoubleByReference pLen) {
        return lib.NMC_CrdGetBufLeftLength(crdHandle, pLen);}
    // 指令缓冲区清空
    public static short NMC_CrdBufClr(HAND crdHandle) {
        return lib.NMC_CrdBufClr(crdHandle);}
    // 设置坐标系剩余位移量，用于控制激光能量跟随后的关闭波形输出
    // group:波形数组组号
    // ch:激光通道号
    public static short NMC_CrdSetLeftLenForLaserWaveOff(HAND crdHandle, double length, short group, short ch) {
        return lib.NMC_CrdSetLeftLenForLaserWaveOff(crdHandle, length, group, ch);}
    // 缓冲设置坐标系剩余位移量，用于控制激光能量跟随后的关闭波形输出
    public static short NMC_CrdBufSetLeftLenForLaserWaveOff(HAND crdHandle, NativeLong segNo, double length, short group, short ch) {
        return lib.NMC_CrdBufSetLeftLenForLaserWaveOff(crdHandle, segNo, length, group, ch);}
    // 读段号
    // pSegNo：返回的当前段号
    public static short NMC_CrdGetUserSegNo(HAND crdHandle, NativeLongByReference pSegNo) {
        return lib.NMC_CrdGetUserSegNo(crdHandle, pSegNo);}
    // 读取总共压了多少条指令
    // pCnt:返回的指令数
    public static short NMC_CrdGetBufAllCmdCnt(HAND crdHandle, NativeLongByReference pCnt) {
        return lib.NMC_CrdGetBufAllCmdCnt(crdHandle, pCnt);}
    // 开始计算缓冲区执行时间
    // 注意:1.如果需要计算执行时间，需要使用上位机前瞻
    //     2.开始后，所有的缓冲区指令，都不会压入控制器
    public static short NMC_CrdStartExeTimeCalc() {
        return lib.NMC_CrdStartExeTimeCalc();}
    // 读取缓冲区指令的执行时间，并停止计算，单位:ms
    public static short NMC_CrdGetExeTime(DoubleByReference pTime) {
        return lib.NMC_CrdGetExeTime(pTime);}


    //9.缓冲区插补运动和IO控制
    // 四轴直线插补
    // segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
    // crdAxMask:参与的轴,按位表示
    // endVel,vel,synAcc:终点速度，最大速度，插补加速度
    // pTgPosArray：目标位置数组
    // lookaheadDis:是否使用前瞻,0：使用前瞻,则控制器自动计算终点速度,1：禁用前瞻,使用设定的终点速度（endVel）
    public static short NMC_CrdLineXYZA(HAND crdHandle, NativeLong segNo, short crdAxMask, NativeLong[] pTgPosArray, double endVel, double vel, double synAcc, short lookaheadDis) {
        return lib.NMC_CrdLineXYZA(crdHandle, segNo, crdAxMask, pTgPosArray, endVel, vel, synAcc, lookaheadDis);}
    // 设置4维插补下，A轴的最大容忍转弯速度，若大于该速度，则需要进行降速处理
    public static short NMC_CrdSetFourthAxisTolTurnVel(HAND crdHandle, double tolVel) {
        return lib.NMC_CrdSetFourthAxisTolTurnVel(crdHandle, tolVel);}
    // segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
    // crdAxMask:参与的轴,按位表示
    // pTgPosArray：目标位置数组,长度为3
    // lookaheadDis:是否使用前瞻,0：使用前瞻,则控制器自动计算终点速度,1：禁用前瞻,使用设定的终点速度（endVel）
    public static short NMC_CrdLineXYZEx(HAND crdHandle, NativeLong segNo, short crdAxMask, NativeLong[] pTgPosArray, double endVel, double vel, double synAcc, short lookaheadDis) {
        return lib.NMC_CrdLineXYZEx(crdHandle, segNo, crdAxMask, pTgPosArray, endVel, vel, synAcc, lookaheadDis);}
    // 多轴直线插补（最多支持8轴）
    // segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
    // crdAxmask:坐标系中参与的轴,按位表示
    // extAxMask:其他参与轴,按位表示,不能包括坐标系中
    // pTgPosArray：目标位置数组,长度为所有参与运动的轴的数量,
    //              索引小的是坐标系内的轴的坐标（按crdAxMask位排列）。索引大的是其它联动轴的坐标（按extAxMask位排列）
    // lookaheadDis:是否使用前瞻(仅仅适用与坐标系中的轴的运动),0：使用前瞻,则控制器自动计算终点速度,1：禁用前瞻,使用设定的终点速度（endVel）
    public static short NMC_CrdLineXYZD8(HAND crdHandle, NativeLong segNo, NativeLong crdAxmask, NativeLong extAxMask, NativeLong[] pTgPosArray, double endVel, double vel, double synAcc, short lookaheadDis) {
        return lib.NMC_CrdLineXYZD8(crdHandle, segNo, crdAxmask, extAxMask, pTgPosArray, endVel, vel, synAcc, lookaheadDis);}
    /*TCrdLineXYZD8Unit 结构体*/
    // 8轴插补打包单元结构体
    public static class TCrdLineXYZD8Unit extends Structure {
        public NativeLong segNo;               // 用户自定义段号
        public short crdAxMask;
        public short extAxMask;
        public NativeLong[] tgPos = new NativeLong[8];// 目标位置
        public float vel;               // 最大速度
        public float endVel;            // 终点速度
        public float acc;               // 插补加速度
        public short lookaheadDis;      // 是否使用前瞻
        public short reserved;          // 保留
        @Override
        protected List<String> getFieldOrder() {
            return Arrays.asList("segNo", "crdAxMask", "extAxMask", "tgPos", "vel", "endVel", "acc", "lookaheadDis", "reserved");}
    }
    // 打包的多轴直线插补
    // count:打包指令数,取值范围[1,18]
    // pCmdArray:指令列表
    public static short NMC_CrdLineXYZD8Pack(HAND crdHandle, short count, TCrdLineXYZD8Unit[] pCmdArray) {
        return lib.NMC_CrdLineXYZD8Pack(crdHandle, count, pCmdArray);}
    /*TCrdLineXYZD4Unit 结构体*/
    // 4轴插补打包单元结构体
    public static class TCrdLineXYZD4Unit extends Structure {
        public NativeLong segNo;                // 用户自定义段号
        public short crdAxMask;
        public short extAxMask;
        public NativeLong[] tgPos = new NativeLong[4]; // 目标位置
        public float vel;                // 最大速度
        public float endVel;             // 终点速度
        public float acc;                // 插补加速度
        public short lookaheadDis;       // 是否使用前瞻
        public short reserved;           // 保留
        @Override
        protected List<String> getFieldOrder() {
            return Arrays.asList("segNo", "crdAxMask", "extAxMask", "tgPos", "vel", "endVel", "acc", "lookaheadDis", "reserved");}
    }
    // 打包的4轴直线插补
    // count:打包指令数,取值范围[1,25]
    // pCmdArray:指令列表
    public static short NMC_CrdLineXYZD4Pack(HAND crdHandle, short count, TCrdLineXYZD4Unit[] pCmdArray) {
        return lib.NMC_CrdLineXYZD4Pack(crdHandle, count, pCmdArray);}
    /*TCrdLineXYZUnit 结构体*/
    public static class TCrdLineXYZUnit extends Structure {
        public NativeLong segNo;                // 用户自定义段号
        public NativeLong[] tgPos = new NativeLong[3]; // 目标位置
        public double endVel;            // 终点速度
        public double vel;               // 最大速度
        public double synAcc;            // 插补加速度
        public short mask;               // 参与的轴,按位表示
        public short lookaheadDis;       // 是否使用前瞻
        public short[] reserved = new short[2]; // 保留
        @Override
        protected List<String> getFieldOrder() {
            return Arrays.asList("segNo", "tgPos", "endVel", "vel", "synAcc", "mask", "lookaheadDis", "reserved");}
    }
    // 打包的直线插补
    // count:打包指令数,取值范围[1,20]
    // pCmdArray:指令列表
    public static short NMC_CrdLineXYZPack(HAND crdHandle, short count, TCrdLineXYZUnit[] pCmdArray) {
        return lib.NMC_CrdLineXYZPack(crdHandle, count, pCmdArray);}
    // XY平面圆弧插补：终点位置、半径、方向
    // segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
    // radius:圆弧半径,大于0表示劣弧,小于0表示优弧
    // pTgPosArray：目标位置数组（二维数组,分别表示XY的位置）
    // circleDir:圆弧方向,0表示顺时针方向,1表示逆时针方向
    public static short NMC_CrdArcRadius(HAND crdHandle, NativeLong segNo, NativeLong[] pTgPosArray, double radius, short circleDir, double endVel, double vel, double synAcc) {
        return lib.NMC_CrdArcRadius(crdHandle, segNo, pTgPosArray, radius, circleDir, endVel, vel, synAcc);}
    // YZ平面圆弧插补：终点位置、半径、方向
    // segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
    // radius:圆弧半径,大于0表示劣弧,小于0表示优弧
    // pTgPosArray：目标位置数组（二维数组,分别表示YZ的位置）
    // circleDir:圆弧方向,0表示顺时针方向,1表示逆时针方向
    public static short NMC_CrdArcRadiusYZ(HAND crdHandle, NativeLong segNo, NativeLong[] pTgPos, double radius, short circleDir, double velEnd, double vel, double synAcc) {
        return lib.NMC_CrdArcRadiusYZ(crdHandle, segNo, pTgPos, radius, circleDir, velEnd, vel, synAcc);}
    // ZX平面圆弧插补：终点位置、半径、方向
    // segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
    // radius:圆弧半径,大于0表示劣弧,小于0表示优弧
    // pTgPosArray：目标位置数组（二维数组,分别表示ZX的位置）
    // circleDir:圆弧方向,0表示顺时针方向,1表示逆时针方向
    public static short NMC_CrdArcRadiusZX(HAND crdHandle, NativeLong segNo, NativeLong[] pTgPos, double radius, short circleDir, double velEnd, double vel, double synAcc) {
        return lib.NMC_CrdArcRadiusZX(crdHandle, segNo, pTgPos, radius, circleDir, velEnd, vel, synAcc);}
    // XY平面圆弧插补：终点位置、半径、方向
    // segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
    // radius:圆弧半径,大于0表示劣弧,小于0表示优弧
    // pTgPosArray：目标位置数组（二维数组,分别表示XY的位置）
    // circleDir:圆弧方向,0表示顺时针方向,1表示逆时针方向
    // lookaheadDis:是否使用前瞻,0：使用前瞻,则控制器自动计算终点速度,1：禁用前瞻,使用设定的终点速度（endVel）
    public static short NMC_CrdArcRadiusEx(HAND crdHandle, NativeLong segNo, NativeLong[] pTgPosArray, double radius, short circleDir, double endVel, double vel, double synAcc, short lookaheadDis) {
        return lib.NMC_CrdArcRadiusEx(crdHandle, segNo, pTgPosArray, radius, circleDir, endVel, vel, synAcc, lookaheadDis);}
    // YZ平面圆弧插补：终点位置、半径、方向
    // segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
    // radius:圆弧半径,大于0表示劣弧,小于0表示优弧
    // pTgPosArray：目标位置数组（二维数组,分别表示YZ的位置）
    // circleDir:圆弧方向,0表示顺时针方向,1表示逆时针方向
    // lookaheadDis:是否使用前瞻,0：使用前瞻,则控制器自动计算终点速度,1：禁用前瞻,使用设定的终点速度（endVel）
    public static short NMC_CrdArcRadiusYZEx(HAND crdHandle, NativeLong segNo, NativeLong[] pTgPos, double radius, short circleDir, double velEnd, double vel, double synAcc, short lookaheadDis) {
        return lib.NMC_CrdArcRadiusYZEx(crdHandle, segNo, pTgPos, radius, circleDir, velEnd, vel, synAcc, lookaheadDis);}
    // ZX平面圆弧插补：终点位置、半径、方向
    // segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
    // radius:圆弧半径,大于0表示劣弧,小于0表示优弧
    // pTgPosArray：目标位置数组（二维数组,分别表示ZX的位置）
    // circleDir:圆弧方向,0表示顺时针方向,1表示逆时针方向
    // lookaheadDis:是否使用前瞻,0：使用前瞻,则控制器自动计算终点速度,1：禁用前瞻,使用设定的终点速度（endVel）
    public static short NMC_CrdArcRadiusZXEx(HAND crdHandle, NativeLong segNo, NativeLong[] pTgPos, double radius, short circleDir, double velEnd, double vel, double synAcc, short lookaheadDis) {
        return lib.NMC_CrdArcRadiusZXEx(crdHandle, segNo, pTgPos, radius, circleDir, velEnd, vel, synAcc, lookaheadDis);}
    // XY平面圆弧插补：终点位置、圆心、方向
    // segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
    // pCenterPosArray:圆心坐标（二维数组,分别表示XY轴相对于起点的圆心位置）,注意：圆心坐标为相对于起点的相对位置
    // pTgPosArray：目标位置（二维数组,分别表示XY轴的目标位置）
    // circleDir:圆弧方向,0表示顺时针方向,1表示逆时针方向
    public static short NMC_CrdArcCenter(HAND crdHandle, NativeLong segNo, NativeLong[] pTgPosArray, NativeLong[] pCenterPosArray, short circleDir, double endVel, double vel, double synAcc) {
        return lib.NMC_CrdArcCenter(crdHandle, segNo, pTgPosArray, pCenterPosArray, circleDir, endVel, vel, synAcc);}
    // YZ平面圆弧插补：终点位置、圆心、方向
    // segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
    // pCenterPosArray:圆心坐标（二维数组,分别表示YZ轴相对于起点的圆心位置）,注意：圆心坐标为相对于起点的相对位置
    // pTgPosArray：目标位置（二维数组,分别表示YZ轴的目标位置）
    // circleDir:圆弧方向,0表示顺时针方向,1表示逆时针方向
    public static short NMC_CrdArcCenterYZ(HAND crdHandle, NativeLong segNo, NativeLong[] pTgPos, NativeLong[] pCenterPos, short circleDir, double velEnd, double vel, double synAcc) {
        return lib.NMC_CrdArcCenterYZ(crdHandle, segNo, pTgPos, pCenterPos, circleDir, velEnd, vel, synAcc);}
    // ZX平面圆弧插补：终点位置、圆心、方向
    // segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
    // pCenterPosArray:圆心坐标（二维数组,分别表示ZX轴相对于起点的圆心位置）,注意：圆心坐标为相对于起点的相对位置
    // pTgPosArray：目标位置（二维数组,分别表示ZX轴的目标位置）
    // circleDir:圆弧方向,0表示顺时针方向,1表示逆时针方向
    public static short NMC_CrdArcCenterZX(HAND crdHandle, NativeLong segNo, NativeLong[] pTgPos, NativeLong[] pCenterPos, short circleDir, double velEnd, double vel, double synAcc) {
        return lib.NMC_CrdArcCenterZX(crdHandle, segNo, pTgPos, pCenterPos, circleDir, velEnd, vel, synAcc);}
    // XY平面圆弧插补：终点位置、圆心、方向
    // segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
    // pCenterPosArray:圆心坐标（二维数组,分别表示XY轴相对于起点的圆心位置）,注意：圆心坐标为相对于起点的相对位置
    // pTgPosArray：目标位置（二维数组,分别表示XY轴的目标位置）
    // circleDir:圆弧方向,0表示顺时针方向,1表示逆时针方向
    // lookaheadDis:是否使用前瞻,0：使用前瞻,则控制器自动计算终点速度,1：禁用前瞻,使用设定的终点速度（endVel）
    public static short NMC_CrdArcCenterEx(HAND crdHandle, NativeLong segNo, NativeLong[] pTgPosArray, NativeLong[] pCenterPosArray, short circleDir, double endVel, double vel, double synAcc, short lookaheadDis) {
        return lib.NMC_CrdArcCenterEx(crdHandle, segNo, pTgPosArray, pCenterPosArray, circleDir, endVel, vel, synAcc, lookaheadDis);}
    // YZ平面圆弧插补：终点位置、圆心、方向
    // segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
    // pCenterPosArray:圆心坐标（二维数组,分别表示ZX轴相对于起点的圆心位置）,注意：圆心坐标为相对于起点的相对位置
    // pTgPosArray：目标位置（二维数组,分别表示YZ轴的目标位置）
    // circleDir:圆弧方向,0表示顺时针方向,1表示逆时针方向
    // lookaheadDis:是否使用前瞻,0：使用前瞻,则控制器自动计算终点速度,1：禁用前瞻,使用设定的终点速度（endVel）
    public static short NMC_CrdArcCenterYZEx(HAND crdHandle, NativeLong segNo, NativeLong[] pTgPos, NativeLong[] pCenterPos, short circleDir, double velEnd, double vel, double synAcc, short lookaheadDis) {
        return lib.NMC_CrdArcCenterYZEx(crdHandle, segNo, pTgPos, pCenterPos, circleDir, velEnd, vel, synAcc, lookaheadDis);}
    // ZX平面圆弧插补：终点位置、圆心、方向
    // segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
    // pCenterPosArray:圆心坐标（二维数组,分别表示ZX轴相对于起点的圆心位置）,注意：圆心坐标为相对于起点的相对位置
    // pTgPosArray：目标位置（二维数组,分别表示ZX轴的目标位置）
    // circleDir:圆弧方向,0表示顺时针方向,1表示逆时针方向
    // lookaheadDis:是否使用前瞻,0：使用前瞻,则控制器自动计算终点速度,1：禁用前瞻,使用设定的终点速度（endVel）
    public static short NMC_CrdArcCenterZXEx(HAND crdHandle, NativeLong segNo, NativeLong[] pTgPos, NativeLong[] pCenterPos, short circleDir, double velEnd, double vel, double synAcc, short lookaheadDis) {
        return lib.NMC_CrdArcCenterZXEx(crdHandle, segNo, pTgPos, pCenterPos, circleDir, velEnd, vel, synAcc, lookaheadDis);}
    // XY平面圆弧插补：起点（当前点）、中点、终点
    // segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
    // pMidPosArray:中间位置点坐标（二维数组,分别表示中间点的XY轴的位置）
    // pTgPosArray：终点位置坐标（二维数组,分别表示终点的XY轴的位置）
    public static short NMC_CrdArcPPP(HAND crdHandle, NativeLong segNo, NativeLong[] pMidPosArray, NativeLong[] pTgPosArray, double endVel, double vel, double synAcc) {
        return lib.NMC_CrdArcPPP(crdHandle, segNo, pMidPosArray, pTgPosArray, endVel, vel, synAcc);}
    // XY平面整圆插补：起点（当前点）、中点、终点
    // segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
    // planeIdx:平面类型，0:XY 1:YZ,2:ZX,目前只支持XY平面
    // pStPos:起点位置点坐标（二维数组,分别表示起点的XY轴的位置）
    // pMidPosArray:中间位置点坐标（二维数组,分别表示中间点的XY轴的位置）
    // pTgPosArray：终点位置坐标（二维数组,分别表示终点的XY轴的位置）
    public static short NMC_CrdCirclePPP(HAND crdHandle, NativeLong segNo, short planeIdx, NativeLong[] pStPos, NativeLong[] pMidPosArray, NativeLong[] pTgPosArray, double endVel, double vel, double synAcc, short lookaheadDis) {
        return lib.NMC_CrdCirclePPP(crdHandle, segNo, planeIdx, pStPos, pMidPosArray, pTgPosArray, endVel, vel, synAcc, lookaheadDis);}
    // XY平面圆弧插补：起点（当前点）、中点、终点
    // segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
    // pMidPosArray:中间位置点坐标（二维数组,分别表示中间点的XY轴的位置）
    // pTgPosArray：终点位置坐标（二维数组,分别表示终点的XY轴的位置）
    // lookaheadDis:是否使用前瞻,0：使用前瞻,则控制器自动计算终点速度,1：禁用前瞻,使用设定的终点速度（endVel）
    public static short NMC_CrdArcPPPEx(HAND crdHandle, NativeLong segNo, NativeLong[] pMidPosArray, NativeLong[] pTgPosArray, double endVel, double vel, double synAcc, short lookaheadDis) {
        return lib.NMC_CrdArcPPPEx(crdHandle, segNo, pMidPosArray, pTgPosArray, endVel, vel, synAcc, lookaheadDis);}
    // 椭圆插补，默认不参与速度前瞻，起始和终止速度为0（注意！椭圆为整圆）
    // segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
    // pCenterPos：椭圆圆心点位置（二维数组,分别表示中点的XY轴的位置）。注意！起点位置到圆心位置为长轴的
    // abRatio:表示椭圆AB轴的长度比例值 值范围：[0.05,1]
    // ellipseDir:椭圆绘画方向,0表示顺时针方向,1表示逆时针方向
    public static short NMC_CrdEllipse(HAND crdHandle, NativeLong segNo, double abRatio, NativeLong[] pCenterPos, short ellipseDir, double vel, double synAcc) {
        return lib.NMC_CrdEllipse(crdHandle, segNo, abRatio, pCenterPos, ellipseDir, vel, synAcc);}
    // 涡旋线插补
    // pCenterPos:中心位置,XY二维位置
    // pTgtPos:目标位置，XYZ三维
    // rounds:圈数
    // circleDir:圆弧方向,0表示顺时针方向,1表示逆时针方向
    public static short NMC_CrdVortexCenter(HAND crdHandle, NativeLong segNo, NativeLong[] pCenterPos, NativeLong[] pTgtPos, short circleDir, double rounds, double endVel, double vel, double synAcc) {
        return lib.NMC_CrdVortexCenter(crdHandle, segNo, pCenterPos, pTgtPos, circleDir, rounds, endVel, vel, synAcc);}
    // 螺旋线插补
    // segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
    // pTgPosArray：目标位置（三维数组,分别表示终点的XYZ轴的位置）
    // pCenterPosArray:圆心位置（二维数组,分别表示XY轴相对于起点的圆心位置）,注意：圆心坐标为相对于起点的相对位置
    // rounds: Z方向圈数
    public static short NMC_CrdHelixCenter(HAND crdHandle, NativeLong segNo, NativeLong[] pTgPosArray, NativeLong[] pCenterPosArray, short circleDir, double rounds, double endVel, double vel, double synAcc) {
        return lib.NMC_CrdHelixCenter(crdHandle, segNo, pTgPosArray, pCenterPosArray, circleDir, rounds, endVel, vel, synAcc);}
    // 螺旋线插补
    // segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
    // pTgPosArray：目标位置（三维数组,分别表示终点的XYZ轴的位置）
    // pCenterPosArray:圆心位置（二维数组,分别表示XY轴相对于起点的圆心位置）,注意：圆心坐标为相对于起点的相对位置
    // rounds: Z方向圈数
    // lookaheadDis:是否使用前瞻,0：使用前瞻,则控制器自动计算终点速度,1：禁用前瞻,使用设定的终点速度（endVel）
    public static short NMC_CrdHelixCenterEx(HAND crdHandle, NativeLong segNo, NativeLong[] pTgPosArray, NativeLong[] pCenterPosArray, short circleDir, double rounds, double endVel, double vel, double synAcc, short lookaheadDis) {
        return lib.NMC_CrdHelixCenterEx(crdHandle, segNo, pTgPosArray, pCenterPosArray, circleDir, rounds, endVel, vel, synAcc, lookaheadDis);}
    // 3D圆弧插补
    // segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
    // pMidPos：中点位置（三维数组,分别表示中点的XYZ轴的位置）
    // pTgPos:终点位置（三维数组,分别表示终点的XYZ轴的位置）
    public static short NMC_CrdArc3D(HAND crdHandle, NativeLong segNo, NativeLong[] pMidPos, NativeLong[] pTgPos, double velEnd, double vel, double synAcc) {
        return lib.NMC_CrdArc3D(crdHandle, segNo, pMidPos, pTgPos, velEnd, vel, synAcc);}
    // 3D圆弧插补
    // segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
    // pMidPos：中点位置（三维数组,分别表示中点的XYZ轴的位置）
    // pTgPos:终点位置（三维数组,分别表示终点的XYZ轴的位置）
    // lookaheadDis:是否使用前瞻,0：使用前瞻,则控制器自动计算终点速度,1：禁用前瞻,使用设定的终点速度（endVel）
    public static short NMC_CrdArc3DEx(HAND crdHandle, NativeLong segNo, NativeLong[] pMidPos, NativeLong[] pTgPos, double velEnd, double vel, double synAcc, short lookaheadDis) {
        return lib.NMC_CrdArc3DEx(crdHandle, segNo, pMidPos, pTgPos, velEnd, vel, synAcc, lookaheadDis);}
    // 3D圆弧插补(整圆)
    // segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
    // pMidPos：中点位置（三维数组,分别表示中点的XYZ轴的位置）
    // pTgPos:终点位置（三维数组,分别表示终点的XYZ轴的位置）
    // lookaheadDis:是否使用前瞻,0：使用前瞻,则控制器自动计算终点速度,1：禁用前瞻,使用设定的终点速度（endVel）
    public static short NMC_CrdCircle3DEx(HAND crdHandle, NativeLong segNo, NativeLong[] pMidPos, NativeLong[] pTgPos, double velEnd, double vel, double synAcc, short lookaheadDis) {
        return lib.NMC_CrdCircle3DEx(crdHandle, segNo, pMidPos, pTgPos, velEnd, vel, synAcc, lookaheadDis);}
    /* 缓冲区输出DO组定义 */
    public static final short CRD_BUFF_DO_MOTOR_ENABLE = 1; // 电机使能
    public static final short CRD_BUFF_DO_MOTOR_CLEAR = 2;  // 电机报警清除
    public static final short CRD_BUFF_DO_GPDO1 = 3;        // 通用输出1
    public static final short CRD_BUFF_DO_GPDO2 = 4;        // 通用输出2
    public static final short CRD_BUFF_DO_EXTDO1 = 5;       // 扩展模块1
    public static final short CRD_BUFF_DO_EXTDO2 = 6;       // 扩展模块2
    public static final short CRD_BUFF_DO_EXTDO3 = 7;       // 扩展模块3
    public static final short CRD_BUFF_DO_EXTDO4 = 8;       // 扩展模块4
    public static final short CRD_BUFF_DO_EXTDO5 = 9;       // 扩展模块5
    public static final short CRD_BUFF_DO_EXTDO6 = 10;      // 扩展模块6
    // 缓冲区DO
    // segNo:段号
    // doType:Do类型,见宏定义
    // ch：位序号,取值范围[0,31]
    // value：输出值,取值范围[0,1]
    public static short NMC_CrdBufDo(HAND crdHandle, NativeLong segNo, short doType, NativeLong ch, NativeLong value) {
        return lib.NMC_CrdBufDo(crdHandle, segNo, doType, ch, value);}
    // 缓冲区DO
    // segNo:段号
    // gourp:Do组别,见宏定义
    // doMask：位掩码
    // doValue：输出值
    public static short NMC_CrdBufDoEx(HAND crdHandle, NativeLong segNo, short group, NativeLong doMask, NativeLong doValue) {
        return lib.NMC_CrdBufDoEx(crdHandle, segNo, group, doMask, doValue);}
    /* 通用输出宏类型 */
    public static final short BUF_OUT_GROUP_DA = 0;        // 模拟量输出
    public static final short BUF_OUT_GROUP_PWM = 1;       // PWM输出
    public static final short BUF_OUT_GROUP_INNER_VAR = 2; // 内部变量
    // 缓冲区输出
    // segNo:段号
    // gourp:组别,见宏定义
    // ch：通道号,取值范围[0,n]
    // value：输出值
    public static short NMC_CrdBufOut(HAND crdHandle, NativeLong segNo, short group, short ch, NativeLong value) {
        return lib.NMC_CrdBufOut(crdHandle, segNo, group, ch, value);}
    // 缓冲区DI等待
    // index:通道号,取值范围[0,127],前64通道代表通用DI，后64通道代表扩展IO
    // diValue：等待值
    // waitLastTime：超时,单位：毫秒
    public static short NMC_CrdBufWaitDI(HAND crdHandle, NativeLong segNo, short index, short diValue, NativeLong waitLastTime) {
        return lib.NMC_CrdBufWaitDI(crdHandle, segNo, index, diValue, waitLastTime);}
    // 缓冲区等待
    // waitType:等待类型，0：内部变量，1：DO状态
    // index:通道号，对于内部变量，取值范围[0,1],对于DO，取值范围[0,63]
    // waitValue：等待值
    // waitTimeInMs：超时,单位：毫秒
    public static short NMC_CrdBufWait(HAND crdHandle, NativeLong segNo, short waitType, short index, NativeLong waitValue, NativeLong waitTimeInMs) {
        return lib.NMC_CrdBufWait(crdHandle, segNo, waitType, index, waitValue, waitTimeInMs);}
    // 功能:缓冲区等待电机运动到位
    // segNo:段号
    // axisMask:需要等待到位的轴掩码（按位对应轴号,不能超出控制器的最大轴数）
    // overTime:等待到位超时的时间，单位：ms
    public static short NMC_CrdBufWaitEncInPosition(HAND crdHandle, NativeLong segNo, NativeLong axisMask, NativeLong overTime) {
        return lib.NMC_CrdBufWaitEncInPosition(crdHandle, segNo, axisMask, overTime);}
    // 功能:缓冲区等待特定位置，满足条件才执行下一条指令
    // segNo:段号
    // axisNo:需要等待到位的轴号
    // condition:到位条件，0：小于等于设定位置  1：大于等于设定位置
    // pos:设定位置
    // posSrc:等待规划还是编码器，0：规划 1:编码器
    // overTime:等待到位超时的时间，单位：ms
    public static short NMC_CrdBufWaitPos(HAND crdHandle, NativeLong segNo, short axisNo, short condition, NativeLong pos, short posSrc, NativeLong overTime) {
        return lib.NMC_CrdBufWaitPos(crdHandle, segNo, axisNo, condition, pos, posSrc, overTime);}
    /* 缓冲区延时单位 */
    public static final short CRD_BUFF_DELAY_SCALE_MS = 0;     // 毫秒
    public static final short CRD_BUFF_DELAY_SCALE_SECAND = 1; // 秒
    // 缓冲区延时
    // segNo:段号
    // scale:延时单位,0表示单位为毫秒,1表示单位为秒
    // count：延时时长
    public static short NMC_CrdBufDelay(HAND crdHandle, NativeLong segNo, short scale, NativeLong count) {
        return lib.NMC_CrdBufDelay(crdHandle, segNo, scale, count);}
    // 缓冲区单轴移动(绝对位移移动)
    // segNo:段号
    // axisMask:参与的轴
    // pTgPos：目标位置
    // blockEn:是否为阻塞模式
    // synEn：是否为同步模式,如果synEn和blockEn同时为1,则同步优先
    public static short NMC_CrdBufAxMove(HAND crdHandle, NativeLong segNo, short axisMask, NativeLong[] pTgPos, short blockEn, short synEn) {
        return lib.NMC_CrdBufAxMove(crdHandle, segNo, axisMask, pTgPos, blockEn, synEn);}
    // 缓冲区单轴移动(带参数)
    // segNo:段号
    // axisMask:参与的轴
    // pTgPos：目标位置
    // vel:速度
    // acc:加速度
    // blockEn:是否为阻塞模式
    // synEn：是否为同步模式,如果synEn和blockEn同时为1,则同步优先
    public static short NMC_CrdBufAxMoveEx(HAND crdHandle, NativeLong segNo, short axisMask, NativeLong[] pTgPos, double vel, double acc, short blockEn, short synEn) {
        return lib.NMC_CrdBufAxMoveEx(crdHandle, segNo, axisMask, pTgPos, vel, acc, blockEn, synEn);}
    //// 缓冲区单轴移动(带参数2)
    //// segNo:段号
    //// axisMask:参与的轴
    //// pTgPos：目标位置
    //// pVelS:各轴启动速度
    //// pVelE:各轴终点速度
    //// pVelMax:各轴最大速度
    //// pAcc:各轴加速度
    //// pDec:各轴减加速度
    //// pSmoothCoe:各轴平滑系数
    //// blockEn:是否为阻塞模式
    //// synEn：是否为同步模式,如果synEn和blockEn同时为1,则同步优先
    //MTN_API short  __stdcall NMC_CrdBufAxMoveEx(HAND crdHandle,long segNo,short axisMask,long *pTgPos,
    //	double *pVelMax,double *pVelS,double *pVelE,double *pAcc,double *pDec,short *pSmoothCoe,short blockEn ,short synEn);

        // 缓冲区单轴移动(相对位移移动)
    // segNo:段号
    // axisMask:参与的轴
    // pRelPos：相对移动位置
    // blockEn:是否为阻塞模式
    // synEn：是否为同步模式,如果synEn和blockEn同时为1,则同步优先
    public static short NMC_CrdBufAxMoveRel(HAND crdHandle, NativeLong segNo, short axisMask, NativeLongByReference pRelPos, short blockEn, short synEn) {
        return lib.NMC_CrdBufAxMoveRel(crdHandle, segNo, axisMask, pRelPos, blockEn, synEn);}
    // 缓冲区单轴移动参数设置
    // segNo:段号
    // axisNo：轴号,[0,n]
    // vel:运动速度
    // acc:运动加速度
    // smoothCoef:平滑系数
    public static short NMC_CrdBufSetPtpMovePara(HAND crdHandle, NativeLong segNo, short axisNo, double vel, double acc, short soomthCoef) {
        return lib.NMC_CrdBufSetPtpMovePara(crdHandle, segNo, axisNo, vel, acc, soomthCoef);}
    // 缓冲区跟随
    // segNo:段号
    // onOff:开关
    public static short NMC_CrdBufValueFollow(HAND crdHandle, NativeLong segNo, short onOff) {
        return lib.NMC_CrdBufValueFollow(crdHandle, segNo, onOff);}
    // 缓冲区设置加工幅面范围，超出范围则停止运动
    // crdAxMask:是否激活幅面限制	按位进行判断 ，bit0~2，分别对应XYZ轴 1：开启，0 关闭
    // pXMax: pXMax[0]为X的最小行程边界	pXMax[1]为X的最大行程边界  pXMax[2]为X发生干涉时等待的参考位置
    // pYMax和pZMax 同pXMax说明
    public static short NMC_CrdBufSetScaleLimit(HAND crdHandle,NativeLong segNo, short crdAxMask,NativeLong[] pXMax,NativeLong[] pYMax,NativeLong[] pZMax) {
        return lib.NMC_CrdBufSetScaleLimit(crdHandle, segNo, crdAxMask, pXMax, pYMax, pZMax);}
    // 设置跟随运动前的运动补偿量
    // axis:轴号  0~N
    //relDistance：相对补偿位移量
    //vel：补偿速度
    public static short NMC_CrdBufBeforeAxSyncMove(HAND crdHandle, NativeLong segNo, short axis, NativeLong relDistance, double vel) {
        return lib.NMC_CrdBufBeforeAxSyncMove(crdHandle, segNo, axis, relDistance, vel);}
    // 设置坐标系速度倍率
    // overRide：坐标系速度倍率,取值范围(0,10)
    public static short NMC_CrdSetOverRide(HAND crdHandle, double overRide) {
        return lib.NMC_CrdSetOverRide(crdHandle, overRide);}


    // 10.回零
    /*THomeMode 枚举*/
//    public enum THomeMode implements NativeMapped {
//        HM_MODE1((short) 0),    // 回零模式1：单原点
//        HM_MODE2((short) 1),    // 回零模式2：单限位
//        HM_MODE3((short) 2),    // 回零模式3：单Z相
//        HM_MODE4((short) 3),    // 回零模式4：原点+Z相
//        HM_MODE5((short) 4),    // 回零模式5：原点+ -Z相
//        HM_MODE6((short) 5);    // 回零模式6：限位+ -Z相
//        private final short value;
//        THomeMode(short value) {this.value = value;}
//        @Override
//        public Object fromNative(Object nativeValue, FromNativeContext context) {
//            int value = (Integer)nativeValue;
//            for (THomeMode mode : values()) {
//                if (mode.value == value) {return mode;}
//            }
//            return null;
//        }
//        @Override
//        public Object toNative() {return value;}
//        @Override
//        public Class<?> nativeType() {return Integer.class;}
//    }
    public interface THomeMode {
        short HM_MODE1 = 0;    // 回零模式1：单原点
        short HM_MODE2 = 1;    // 回零模式2：单限位
        short HM_MODE3 = 2;    // 回零模式3：单Z相
        short HM_MODE4 = 3;    // 回零模式4：原点+Z相
        short HM_MODE5 = 4;    // 回零模式5：原点+ -Z相
        short HM_MODE6 = 5;    // 回零模式6：限位+ -Z相
    }
    /*THomeSetting 结构体*/
    //回零参数设置
    public static class THomeSetting extends Structure {
        public short mode;          // 模式,HM_MODE1 ~     （必须）
        public short dir;           // 搜寻零点方向（必须）, 0:负向,1：正向,其它值无意义
        public NativeLong offset;          // 原点偏移（必须）
        public double scan1stVel;   // 基本搜寻速度（必须）
        public double scan2ndVel;   // 低速（两次搜寻时需要）
        // 当usePreSetPtpPara=0时,回零运动的减加速度默认等于acc,起跳速度、终点速度、平滑系数默认为0
        public double acc;          // 加速度
        public byte reScanEn;       // 是否两次搜寻零点（可选,不用时设为0）
        public byte homeEdge;       // 原点,触发沿（默认下降沿）
        public byte lmtEdge;        // 限位,触发沿（默认下降沿）
        public byte zEdge;          // 限位,触发沿（默认下降沿）
        public NativeLong iniRetPos;       // 起始反向运动距离（可选,不用时设为0）
        public NativeLong retSwOffset;     // 反向运动时离开开关距离（可选,不用时设为0）
        public NativeLong safeLen;         // 安全距离,回零时最远搜寻距离（可选,不用时设为0,不限制距离）
        public byte usePreSetPtpPara;   // 为1表示用户需要在启动回零前,自己设置回零运动（点到点）的参数
        public byte[] reserved = new byte[3];   // 保留
        public NativeLong reserved2;       // 保留
        @Override
        protected List<String> getFieldOrder() {
            return Arrays.asList("mode", "dir", "offset", "scan1stVel", "scan2ndVel", "acc", "reScanEn", "homeEdge", "lmtEdge", "zEdge", "iniRetPos", "retSwOffset", "safeLen", "usePreSetPtpPara", "reserved", "reserved2");}
    }
    // 设置回零参数
    // pHomePara: 回零参数结构,参考结构定义
    public static short NMC_MtSetHomePara(HAND axisHandle, THomeSetting pHomePara) {
        return lib.NMC_MtSetHomePara(axisHandle, pHomePara);}
    /* 回零状态字位定义 */
    public static final short BIT_AXHOME_BUSY = 0x00000001;    // bit 0, 忙
    public static final short BIT_AXHOME_OK = 0x00000002;      // bit 1, 成功
    public static final short BIT_AXHOME_FAIL = 0x00000004;    // bit 2, 失败
    public static final short BIT_AXHOME_ERR_MV = 0x00000008;  // bit 3, 错误：运动参数出错导致不动
    public static final short BIT_AXHOME_ERR_SWT = 0x00000010; // bit 4, 错误：搜寻过程中开关没触发
    // 读回零状态
    // pStsWord: 返回状态字。参数宏定义,高8位为错误代码
    public static short NMC_MtGetHomeSts(HAND axisHandle, ShortByReference pStsWord) {
        return lib.NMC_MtGetHomeSts(axisHandle, pStsWord);}
    // 启动回零
    public static short NMC_MtHome(HAND axisHandle) {
        return lib.NMC_MtHome(axisHandle);}
    // 尝试性回零（测试回零误差,不清位置）
    public static short NMC_MtTryHome(HAND axisHandle) {
        return lib.NMC_MtTryHome(axisHandle);}
    // 终止回零
    public static short NMC_MtHomeStop(HAND axisHandle) {
        return lib.NMC_MtHomeStop(axisHandle);}
    // 读新回零位置和历史回零位置的差值
    // pErrPos: 回零位置偏差
    // 注：回零成功时才有意义
    public static short NMC_MtGetHomeError(HAND axisHandle, NativeLongByReference pErrPos) {
        return lib.NMC_MtGetHomeError(axisHandle, pErrPos);}


    //11.电子齿轮
    // 设置Gear跟随方向
    // dir：  0:双向跟随，<0负向跟随， >0正向跟随
    public static short NMC_MtGearSetDir(HAND axisHandle, short dir) {
        return lib.NMC_MtGearSetDir(axisHandle, dir);}
    // 获取Gear跟随方向
    // pDir：  0:双向跟随，<0负向跟随， >0正向跟随
    public static short NMC_MtGearGetDir(HAND axisHandle, ShortByReference pDir) {
        return lib.NMC_MtGearGetDir(axisHandle, pDir);}
    // 设置Gear主轴参数
    // axisHandle：从轴跟随轴号
    // masterNo：  主轴序列号（0~N）
    // masterType：  主轴类型  1:AXIS规划值  2：AXIS反馈值 3：编码器值
    public static short NMC_MtGearSetMaster(HAND axisHandle, short masterNo, short masterType) {
        return lib.NMC_MtGearSetMaster(axisHandle, masterNo, masterType);}
    // 获取Gear主轴参数
    // pMasterNo：  主轴序列号（0~N）
    // pMasterType：  主轴类型
    public static short NMC_MtGearGetMaster(HAND axisHandle, ShortByReference pMasterNo, ShortByReference pMasterType) {
        return lib.NMC_MtGearGetMaster(axisHandle, pMasterNo, pMasterType);}
    // 设置Gear跟随倍率
    // axisHandle：从轴跟随轴号
    // masterEven： 传动比系数，主轴位移
    // slaveEven：  传动比系数，从轴位移
    // masterSlope：主轴离合区位移,必须大于0，同时不能等于1
    public static short NMC_MtGearSetRatio(HAND axisHandle, NativeLong masterEven, NativeLong slaveEven, NativeLong masterSlope) {
        return lib.NMC_MtGearSetRatio(axisHandle, masterEven, slaveEven, masterSlope);}
    // 获取Gear跟随倍率
    // axisHandle：从轴跟随轴号
    // pMasterEven： 传动比系数，主轴位移
    // pSlaveEven：  传动比系数，从轴位移
    // pMasterSlope：主轴离合区位移,必须大于0，同时不能等于1
    public static short NMC_MtGearGetRatio(HAND axisHandle, NativeLongByReference pMasterEven, NativeLongByReference pSlaveEven, NativeLongByReference pMasterSlope) {
        return lib.NMC_MtGearGetRatio(axisHandle, pMasterEven, pSlaveEven, pMasterSlope);}
    // 启动Gear运动
    // syncCount： 不包括axisHandle 的其他同步启动轴数量
    // pSyncAxisArray: 其他同步启动轴的序号：0~N
    // 注：同步的轴必须属于同一个控制器
    public static short NMC_MtGearStartMtn(HAND axisHandle, short syncAxCnts, short[] pSyncAxArray) {
        return lib.NMC_MtGearStartMtn(axisHandle, syncAxCnts, pSyncAxArray);}


    //12.电子凸轮
    // 设置FOLLOW跟随方向
    // dir：  0:双向跟随，<0负向跟随， >0正向跟随
    public static short NMC_MtFollowSetDir(HAND axisHandle, short dir) {
        return lib.NMC_MtFollowSetDir(axisHandle, dir);}
    // 获取FOLLOW跟随方向
    // pDir：  0:双向跟随，<0负向跟随， >0正向跟随
    public static short NMC_MtFollowGetDir(HAND axisHandle, ShortByReference pDir) {
        return lib.NMC_MtFollowGetDir(axisHandle, pDir);}
    /* FOLLOW跟随的主轴类型 */
    public static final short PROFILE_FOLLOW_MASTER_NONE = 0;     // 0:无效
    public static final short PROFILE_FOLLOW_MASTER_AXIS_PRF = 1; // 1:AXIS规划值
    public static final short PROFILE_FOLLOW_MASTER_AXIS_ENC = 2; // 2：AXIS反馈值
    public static final short PROFILE_FOLLOW_MASTER_ENC = 3;      // 3：编码器值
    // 设置FOLLOW主轴参数
    // axisHandle：从轴跟随轴号
    // masterNo：  主轴序列号（0~N）
    // masterType：  主轴类型  见上面宏定义
    public static short NMC_MtFollowSetMaster(HAND axisHandle, short masterNo, short masterType) {
        return lib.NMC_MtFollowSetMaster(axisHandle, masterNo, masterType);}
    // 获取FOLLOW主轴参数
    // axisHandle：从轴跟随轴号
    // pMasterNo：  主轴序列号（0~N）
    // pMasterType：  主轴类型  见上面宏定义
    public static short NMC_MtFollowGetMaster(HAND axisHandle, ShortByReference pMasterNo, ShortByReference pMasterType) {
        return lib.NMC_MtFollowGetMaster(axisHandle, pMasterNo, pMasterType);}
    // 设置FOLLOW的循环执行次数
    // loopCnt：循环
    public static short NMC_MtFollowSetLoopCount(HAND axisHandle, NativeLong loopCnt) {
        return lib.NMC_MtFollowSetLoopCount(axisHandle, loopCnt);}
    // 获取FOLLOW的循环执行次数
    // pLoopCnt：循环
    public static short NMC_MtFollowGetLoopCount(HAND axisHandle, NativeLongByReference pLoopCnt) {
        return lib.NMC_MtFollowGetLoopCount(axisHandle, pLoopCnt);}
    /* FOLLOW跟随事件 */
    public static final short PROFILE_FOLLOW_EVENT_START = 1; // 立即启动
    public static final short PROFILE_FOLLOW_EVENT_PASS = 2;  // 主轴穿越设定位置以后启动跟随
    // 设置FOLLOW的的启动事件
    // eventType：1 表示调用启动指令以后	立即启动，2表示	主轴穿越设定位置以后启动跟随
    // masterDir:穿越启动时，主轴的运动方向，1 主轴正向运动，-1 主轴负向运动
    // pos:穿越位置
    public static short NMC_MtFollowSetEvent(HAND axisHandle, short eventType, short masterDir, NativeLong pos) {
        return lib.NMC_MtFollowSetEvent(axisHandle, eventType, masterDir, pos);}
    // 获取FOLLOW的启动事件
    // pEvent：1 表示调用启动指令以后立即启动，2表示主轴穿越设定位置以后启动跟随
    // pMasterDir:穿越启动时，主轴的运动方向，1 主轴正向运动，-1 主轴负向运动
    // pPos:穿越位置
    public static short NMC_MtFollowGetEvent(HAND axisHandle, ShortByReference pEvent, ShortByReference pMasterDir, NativeLongByReference pPos) {
        return lib.NMC_MtFollowGetEvent(axisHandle, pEvent, pMasterDir, pPos);}
    // 获取FOLLOW的fifo剩余空间
    // pSpace：空间大小
    // fifoNo:fifo号，0或1
    public static short NMC_MtFollowGetSpace(HAND axisHandle, ShortByReference pSpace, short fifoNo) {
        return lib.NMC_MtFollowGetSpace(axisHandle, pSpace, fifoNo);}
    /* FOLLOW的段类型 */
    public static final short PROFILE_FOLLOW_SEGMENT_NORMAL = 0;    // 0普通段
    public static final short PROFILE_FOLLOW_SEGMENT_EVEN = 1;      // 1匀速段
    public static final short PROFILE_FOLLOW_SEGMENT_STOP = 2;      // 2停止段
    public static final short PROFILE_FOLLOW_SEGMENT_CONTINUE = 3;  // 3连续段
    // 设置FOLLOW的数据
    // masterPos：主轴位移
    // slavePos:从轴位移
    // type:数据段类型：0普通段，默认；1匀速段；2 减速到 0 段；3保持 FIFO 之间速度连续
    // fifoNo:fifo号，0或1
    public static short NMC_MtFollowPushData(HAND axisHandle, NativeLong masterPos, double slavePos, short type, short fifoNo) {
        return lib.NMC_MtFollowPushData(axisHandle, masterPos, slavePos, type, fifoNo);}
    // 清除FOLLOW对应fifo号的数据
    // fifoNo:fifo号，0或1
    public static short NMC_MtFollowClear(HAND axisHandle, short fifoNo) {
        return lib.NMC_MtFollowClear(axisHandle, fifoNo);}
    // 启动Follow运动
    // syncCount： 不包括axisHandle 的其他同步启动轴数量
    // pSyncAxisArray: 其他同步启动轴的序号：0~N
    public static short NMC_MtFollowStart(HAND axisHandle, short syncAxCnts, short[] pSyncAxArray) {
        return lib.NMC_MtFollowStart(axisHandle, syncAxCnts, pSyncAxArray);}
    // 切换Follow运动的fifo号
    // syncCount： 不包括axisHandle 的其他同步进行fifo切换的轴数量
    // pSyncAxisArray: 其他同步进行fifo切换的轴的序号：0~N
    public static short NMC_MtFollowSwitch(HAND axisHandle, short syncAxCnts, short[] pSyncAxArray) {
        return lib.NMC_MtFollowSwitch(axisHandle, syncAxCnts, pSyncAxArray);}
}
