from ctypes import *
from enum import IntEnum
import struct

libc = cdll.LoadLibrary('./nmc_lib20.dll')

PACK_AXIS_NUM = 4              # 打包轴状态: 读取轴数量
CRD_MAX_DIMENSION = 4          # 坐标系配置: 最大坐标系维度
MAX_ERR_TABLE_SECTION = 2      # 圆弧插补误差配置: 最大分段数量
COLLECT_LIST_MAX = 8           # 采集配置: 组最多采集8个数据
LASER_GROUP = 12               # 激光配置: 最大激光能量组数
LASER_POINT = 40               # 激光配置: 每组最大点数
CMP_OUTPUT_CHN_MAX = 3         # 二维位置比较配置：输出通道最大值
COMPEX2D_MAX_COMP_CHN_NUM = 8  # 2D平面修正补偿配置：最大比较通道数量

VAR_CAPT_NUM_MAX = 12          # 变量锁存配置：最多锁存的变量数
                               # 锁存变量定义
MC_VAR_EncPos = 11             # 实际位置，32bit，varIdx表示通道号
MC_VAR_EncVel = 12             # 实际速度，32bit单精度浮点，varIdx表示通道号

# DI type
DI_TYPE_LIMIT_POSITIVE = 0     # 正向限位
DI_TYPE_LIMIT_NEGATIVE = 1     # 负向限位
DI_TYPE_ALARM = 2              # 驱动报警
DI_TYPE_HOME = 3               # 原点
DI_TYPE_GPI = 4                # 通用输入

# 根据坐标系的速度，补偿激光输出的相关控制量
LASER_CRDVELCOMP_PT_MAX = 64   # 激光坐标速度补偿点的最大数量
LASER_CRDVELCOMP_GROUP_MAX = 4 # 激光坐标速度补偿表格的最大数量

COMPXDIMENSEX_MAX_AX = 6       # 多维位置比较配置：最大轴数
SHIOAHEAD_CHN_MAX = 4          # 高速输入输出通道的最大数量


MT_PRF_MAP_CNT_MAX  = 2        # 高度跟随功能：最大映射的轴数量

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

class pymtn:
    """
    --------------------------------------------------------------------------------------------------------------
    //
    //          1.控制器连接、关闭
    //
    --------------------------------------------------------------------------------------------------------------

    """

    RTN_CMD_SUCCESS = 0  # 指令成功执行
    RTN_CMD_TBD = 999  # TBD

    """通讯模式设置 """
    class TSearchMode(IntEnum):
        USB = 0
        Internet = 1
        RS485 = 2

        def from_param(obj):
            return obj

    """设备信息结构"""
    class cTDevInfo(Structure):
        _fields_ = [("address", c_ushort),
                    ("idStr", c_byte * 16),
                    ("description", c_byte * 64),
                    ("ID", c_ushort)]

    """板卡搜寻
    // 参数: mode:通讯模式
    // pDevNo : 返回设备的数目
    // pInfoList：返回设备信息
    """
    def NMC_DevSearch(mode):
        devNum_tmp = c_ushort()
        itemlist_tmp = (pymtn.cTDevInfo * 16)()
        libc.NMC_DevSearch.argtypes = [pymtn.TSearchMode, POINTER(c_ushort), POINTER(pymtn.cTDevInfo)]
        libc.NMC_DevSearch.restype = c_short
        ret = libc.NMC_DevSearch(mode, byref(devNum_tmp), itemlist_tmp)

        class TDevInfo:
            def __init__(self):
                self.address = 0
                self.idStr = ""
                self.description = ""
                self.ID = 0

        devinfolist = []
        if ret == 0:
            # devinfolist=[TDevInfo() for i in range(0, int(devNum.value))]
            for i in range(0, int(devNum_tmp.value)):
                dev = TDevInfo()
                dev.address = itemlist_tmp[i].address
                dev.idStr = bytes(itemlist_tmp[i].idStr).split(b'\x00')[0].decode('ascii')
                dev.description = bytes(itemlist_tmp[i].description).split(b'\x00')[0].decode('ascii')
                dev.ID = itemlist_tmp[i].ID
                devinfolist.append(dev)
            return (devNum_tmp.value, devinfolist, ret)
        else:
            return (0, [], ret)
        # #用户调用示例
        #    (devNo,DevList,rtn) = pymtn.NMC_DevSearch( 0 )
        #    if rtn == 0:
        #        print("the count of devices: (%s)"  %(devNo) )
        #          for i in range(0, devNo):
        #             print(DevList[i].address)
        #             print(DevList[i].idStr)
        #             print(DevList[i].description)
        #             print(DevList[i].ID)



    """ 
    // 板卡打开（根据序号）
    // devNo: 设备序号,取值范围[0,n]； pDevHandle: 返回设备操作句柄
    """
    def NMC_DevOpen(devNo):
        devHandle_tmp = c_ushort()
        libc.NMC_DevOpen.argtypes = [c_short, POINTER(c_ushort)]
        ret = libc.NMC_DevOpen(devNo, byref(devHandle_tmp))
        return devHandle_tmp, ret

    """ 
    // 板卡关闭
    // pDevHandle : 设备句柄指针
    """

    def NMC_DevClose(devHandle):
        libc.NMC_DevClose.argtypes = [POINTER(c_ushort)]
        return libc.NMC_DevClose(devHandle)

    """ 板卡复位
    """

    def NMC_DevReset(devHandle):
        libc.NMC_DevReset.argtypes = [c_ushort]
        return libc.NMC_DevReset(devHandle)

    """ 打开单轴
    // devHandle : 设备句柄
    // itemNo：轴号,取值范围[0,n]
    // pCrdHandle：坐标系组句柄
    """

    def NMC_MtOpen(devHandle, itemNo):
        axisHandle_tmp = c_ushort()
        libc.NMC_MtOpen.argtypes = [c_ushort, c_short, POINTER(c_ushort)]
        ret = libc.NMC_MtOpen(devHandle, itemNo, byref(axisHandle_tmp))
        return axisHandle_tmp, ret

    """ 关闭单轴
    // devHandle : 设备句柄指针
    """

    def NMC_MtClose(axisHandle):
        libc.NMC_MtClose.argtypes = [POINTER(c_ushort)]
        return libc.NMC_MtClose(axisHandle)

    """ 打开坐标系组(支持多坐标系)
    // itemNo：坐标系号,取值范围[0,1]
    // pCrdHandle：返回坐标系组句柄
    """

    def NMC_CrdOpenEx(devHandle, itemNo):
        crdHandle_tmp = c_ushort()
        libc.NMC_CrdOpenEx.argtypes = [c_ushort, c_short, POINTER(c_ushort)]
        ret = libc.NMC_CrdOpenEx(devHandle, itemNo, byref(crdHandle_tmp))
        return crdHandle_tmp, ret

    """关闭坐标系组"""

    def NMC_CrdClose(crdHandle):
        libc.NMC_CrdClose.argtypes = [POINTER(c_ushort)]
        return libc.NMC_CrdClose(crdHandle)

    """
    --------------------------------------------------------------------------------------------------------------
    //
    //          2.单轴配置
    //
    --------------------------------------------------------------------------------------------------------------
    """
    """ 系统扩展资源的起始ID,包括扩展编码器／模拟量输入输出"""
    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:编码器模式,参考宏定义
    """
    """
    # // 内部脉冲计数 ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **
    # encMode = 256：AB相90度差
    # encMode = 1280：脉冲 + 方向
    # encMode = 2304：正脉冲 + 负脉冲
    # encMode = 4352：AB相90度差(负逻辑)
    # encMode = 17664：脉冲 + 方向(负逻辑)
    # encMode = 6400：正脉冲 + 负脉冲(负逻辑)
    # // 外部编码器输入 ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** *
    # encMode = 0：AB相90度差
    # encMode = 1024：脉冲 + 方向
    # encMode = 2048：正脉冲 + 负脉冲
    # encMode = 4096：AB相90度差(负逻辑)
    # encMode = 17408：脉冲 + 方向(负逻辑)
    # encMode = 6144：正脉冲 + 负脉冲(负逻辑)
    """

    def NMC_SetEncMode(devHandle, encId, encMode):
        libc.NMC_SetEncMode.argtypes = [c_ushort, c_short, c_short]
        return libc.NMC_SetEncMode(devHandle, encId, encMode)

    """ 设置软件限位是否停止运动
    // enable：软件限位触发允许设置,1为允许,0为禁止
    """
    """ 
    // 读取编码器模式
    // encId: 编码器ID,对于轴编码器通道,取值范围[0,n]
    //				  对于扩展编码器通道,256表示第一个扩展编码器通道,257表示第二个,以此类推
    // encMode:返回编码器模式,参考宏定义
    """
    def NMC_GetEncMode(devHandle, encId):
        encMode_tmp = c_short()
        libc.NMC_GetEncMode.argtypes = [c_ushort, c_short, POINTER(c_short)]
        ret = libc.NMC_GetEncMode(devHandle, encId, byref(encMode_tmp))
        return encMode_tmp, ret

    def NMC_MtSwLmtOnOff(axisHandle, swt):
        libc.NMC_MtSwLmtOnOff.argtypes = [c_ushort, c_short]
        return libc.NMC_MtSwLmtOnOff(axisHandle, swt)

    """ 设置软件限位数值
    // posLmt：正向软件限位设置值
    // negLmt：负向软件限位设置值。单位为脉冲数
    """

    def NMC_MtSwLmtValue(axisHandle, posLmt, negLmt):
        libc.NMC_MtSwLmtValue.argtypes = [c_ushort, c_long, c_long]
        return libc.NMC_MtSwLmtValue(axisHandle, posLmt, negLmt)

    """轴运动安全参数"""

    class TSafePara(Structure):  # TsafePara(safePrm)
        _fields_ = [("estpDec", c_double),  # 急停加速度
                    ("maxVel", c_double),  # 最大速度
                    ("maxAcc", c_double)]  # 最大加速度

    """设置轴安全参数
    // TSafePara：包含急停减速度、最大允许速度、最大允许加速度
    """

    def NMC_MtSetSafePara(axisHandle, safePrm):
        libc.NMC_MtSetSafePara.argtypes = [c_ushort, POINTER(pymtn.TSafePara)]
        return libc.NMC_MtSetSafePara(axisHandle, byref(safePrm))

        # '''py结构体用户调用示例
        #   (devNo= 0  Hand devHandle  Hand axisHandle)
        #   safePrm = pymtn.TSafePara(500, 50, 100)
        #   rtn = pymtn.NMC_MtSetSafePara(axisHandle, safePrm )
        #   print(safePrm.maxAcc)
        # '''

    """ 设置脉冲输出模式
    // inv, 1：取反,0：不取反
    // mode 0：脉冲方向 1：正负脉冲
    """

    def NMC_MtSetStepMode(axisHandle, inv, mode):
        libc.NMC_MtSetStepMode.argtypes = [c_ushort, c_short, c_short]
        return libc.NMC_MtSetStepMode(axisHandle, inv, mode)

    """ 设置轴速度滤波参数
    // 注：filterCoef系数在0~5之间,值越大,速度越平滑，默认值为0
    """

    def NMC_MtSetAxisVelFilter(axisHandle, filterCoef):
        libc.NMC_MtSetAxisVelFilter.argtypes = [c_ushort, c_short]
        return libc.NMC_MtSetAxisVelFilter(axisHandle, filterCoef)

    """ 硬件限位配置
    // posLmtEnable: 正向限位触发允许设置,1为允许,0为禁止
    // negLmtEnable: 负向限位触发允许设置,1为允许,0为禁止
    // posLmtSns: 正向限位触发电平,1为高电平触发,0为低电平触发
    // negLmtSns: 正向限位触发电平,1为高电平触发,0为低电平触发
    """

    def NMC_MtSetLmtCfg(axisHandle, posLmtEnable, negLmtEnable, posLmtSns, negLmtSns):
        libc.NMC_MtSetLmtCfg.argtypes = [c_ushort, c_short, c_short, c_short, c_short]
        return libc.NMC_MtSetLmtCfg(axisHandle, posLmtEnable, negLmtEnable, posLmtSns, negLmtSns)

    """ 伺服报警配置
    // alarmEnable: 伺服报警触发允许设置,1为允许,0为禁止
    // alarmSns:     伺服报警触发电平,1为高电平触发,0为低电平触发
    """

    def NMC_MtSetAlarmCfg(axisHandle, alarmEnable, alarmSns):
        libc.NMC_MtSetAlarmCfg.argtypes = [c_ushort, c_short, c_short]
        return libc.NMC_MtSetAlarmCfg(axisHandle, alarmEnable, alarmSns)

    """ 设置脉冲输出滤波
    // coe系数： 范围0~65535,0不滤波,数值越大滤波效果越明显。
    """

    def NMC_MtSetStepFilter(axisHandle, coe):
        libc.NMC_MtSetStepFilter.argtypes = [c_ushort, c_ushort]
        return libc.NMC_MtSetStepFilter(axisHandle, coe)

    """------------------------------------------------------------------------------------------------------------
    //
    //          3.单轴控制指令
    //
    //------------------------------------------------------------------------------------------------------------
    """
    """各轴的规划模式"""
    MT_NONE_PRF_MODE = -1  # 无效
    MT_PTP_PRF_MODE = 0  # 梯形规划
    MT_JOG_PRF_MODE = 1  # 连续速度模式
    MT_CRD_PRF_MODE = 3  # 坐标系
    MT_GANTRY_MODE = 4  # 龙门跟随模式
    MT_PT_PRF_MODE = 5  # PT模式
    MT_MULTI_LINE_MODE = 6  # 多轴直线插补
    MT_GEAR_PRF_MODE = 7  # 电子齿轮模式
    MT_FOLLOW_PRF_MODE = 8  # Follow跟随模式

    """ 设置单轴规划模式
    // mode：单轴运动模式
    """

    def NMC_MtSetPrfMode(axisHandle, mode):
        libc.NMC_MtSetPrfMode.argtypes = [c_ushort, c_short]
        return libc.NMC_MtSetPrfMode(axisHandle, mode)

    """
    // 获取轴规划模式
    // pMode：返回轴运动模式
    """

    def NMC_MtGetPrfMode(axisHandle):
        Mode_tmp = c_short()
        libc.NMC_MtGetPrfMode.argtypes = [c_ushort,  POINTER(c_short)]
        ret = libc.NMC_MtGetPrfMode(axisHandle, byref(Mode_tmp))
        return Mode_tmp, ret

    """ 单轴PTP运动参数结构"""

    class TPtpPara(Structure):
        _fields_ = [("acc", c_double),  # 加速度
                    ("dec", c_double),  # 减速度
                    ("startVel", c_double),  # 起跳速度
                    ("endVel", c_double),  # 终止速度
                    ("smoothCoef", c_short),  # 平滑系数,取值范围[0,199]
                    ("reserved", c_short * 3)]  # 保留

    """ 设置多个参数, 并更新。
    // pAxPara：参数,参考结构定义。
    """

    def NMC_MtSetPtpPara(axisHandle, axPara):  # TPtpPara(axPara)
        libc.NMC_MtSetPtpPara.argtypes = [c_ushort, POINTER(pymtn.TPtpPara)]
        return libc.NMC_MtSetPtpPara(axisHandle, byref(axPara))

    """ 单轴JOG运动参数结构"""

    class TJogPara(Structure):  # TsafePara(safePrm)
        _fields_ = [("acc", c_double),  # 加速度
                    ("dec", c_double),  # 减速度
                    ("smoothCoef", c_double)]  # 平滑系数,取值范围[0,199]

    """ 设置Jog运动参数
    // pAxPara：参数,参考结构定义。
    """

    def NMC_MtSetJogPara(axisHandle, jogPrm):
        libc.NMC_MtSetJogPara.argtypes = [c_ushort, POINTER(pymtn.TJogPara)]
        return libc.NMC_MtSetJogPara(axisHandle, byref(jogPrm))

    """ 设置目标运动速度,只针对PTP和Jog：PTP模式下只接受正数,Jog模式下正负号标识运动方向
    // vel: 目标速度（最大速度）,单位是 脉冲/ms
    """

    def NMC_MtSetVel(axisHandle, vel):
        libc.NMC_MtSetVel.argtypes = [c_ushort, c_double]
        return libc.NMC_MtSetVel(axisHandle, vel)

    """ 设置目标运动位置,只针对PTP
    // pos: 目标位置,单位是 脉冲
    """

    def NMC_MtSetPtpTgtPos(axisHandle, pos):
        libc.NMC_MtSetPtpTgtPos.argtypes = [c_ushort, c_long]
        return libc.NMC_MtSetPtpTgtPos(axisHandle, pos)

    """ 参数更新, 只针对PTP和Jog
    """

    def NMC_MtUpdate(axisHandle):
        libc.NMC_MtUpdate.argtypes = [c_ushort]
        return libc.NMC_MtUpdate(axisHandle)

    """ 单轴运动停止
    // 注：运动会按设定的减速度停止。
    """

    def NMC_MtStop(axisHandle):
        libc.NMC_MtStop.argtypes = [c_ushort]
        return libc.NMC_MtStop(axisHandle)

    """ 单轴急停，不会置起急停标志位
    // 注：运动会按设定的急停加速度停止。如果没有设置,则会立即停止。
    """

    def NMC_MtAbruptStop(axisHandle):
        libc.NMC_MtAbruptStop.argtypes = [c_ushort]
        return libc.NMC_MtAbruptStop(axisHandle)

    """ 单轴位置系统清零,规划以及编码器
    """

    def NMC_MtZeroPos(axisHandle):
        libc.NMC_MtZeroPos.argtypes = [c_ushort]
        return libc.NMC_MtZeroPos(axisHandle)

    """ 设置伺服报警清除输出的状态
    // swt: 设置开关有效状态。1, 有效（输出低电平）,0,无效（输出高电平）
    """

    def NMC_MtSetSvClr(axisHandle, swt):
        libc.NMC_MtSetSvClr.argtypes = [c_ushort, c_short]
        return libc.NMC_MtSetSvClr(axisHandle, swt)

    """ 设置伺服ON, 轴静止时执行,如果后面是update指令,需要延时一个周期
    """

    def NMC_MtSetSvOn(axisHandle):
        libc.NMC_MtSetSvOn.argtypes = [c_ushort]
        return libc.NMC_MtSetSvOn(axisHandle)

    """ 设置伺服OFF, 轴静止时执行,如果后面是update指令,需要延时一个周期
    """

    def NMC_MtSetSvOff(axisHandle):
        libc.NMC_MtSetSvOff.argtypes = [c_ushort]
        return libc.NMC_MtSetSvOff(axisHandle)

    """ 清除轴错误状态
    """

    def NMC_MtClrError(axisHandle):
        libc.NMC_MtClrError.argtypes = [c_ushort]
        return libc.NMC_MtClrError(axisHandle)

    """ 清除轴错误状态,按位清除
    // stsMask:对应位为1表明需要清除对应位的错误状态
    """

    def NMC_MtClrStsByBits(axisHandle, stsMask):
        libc.NMC_MtClrStsByBits.argtypes = [c_ushort, c_short]
        return libc.NMC_MtClrStsByBits(axisHandle, stsMask)

    """ 单轴点位运动,包含NMC_MtSetPrfMode,NMC_MtSetPtpPara,NMC_MtSetVel,NMC_MtSetPtpTgtPos,NMC_MtUpdate
    // acc:加速度,dec：减速度,startVel:起跳速度,endVel:终止速度,smoothCoef:平滑系数
    // maxVel：最大速度
    // tgtPos:目标位置,单位：脉冲
    """

    def NMC_MtMovePtpAbs(axisHandle, acc, dec, startVel, endVel, maxVel, smoothCoef, tgtPos):
        libc.NMC_MtMovePtpAbs.argtypes = [c_ushort, c_double, c_double, c_double, c_double, c_double, c_short, c_long]
        return libc.NMC_MtMovePtpAbs(axisHandle, acc, dec, startVel, endVel, maxVel, smoothCoef, tgtPos)

    """ 单轴连续速度运动
    // acc:加速度,dec：减速度,smoothCoef:平滑系数
    // maxVel：最大速度
    // clrStsFlag:是否运动前先清除轴状态，0：不清除，1：清除
    """

    def NMC_MtMoveJog(axisHandle, acc, dec, maxVel, smoothCoef, clrStsFlag):
        libc.NMC_MtMoveJog.argtypes = [c_ushort, c_double, c_double, c_double, c_short, c_short]
        return libc.NMC_MtMoveJog(axisHandle, acc, dec, maxVel, smoothCoef, clrStsFlag)

    class TMovePtpPack8(Structure):
        _fields_ = [("axisMask", c_short),  # 轴掩码，对应bit为1表示该轴参与运动
                    ("clrStsFlag", c_short),  # 是否运动前先清除轴状态，0：不清除，1：清除
                    ("reserved", c_short * 2),  # 保留
                    ("acc", c_double * 8),  # 加速度
                    ("dec", c_double * 8),  # 减加速度
                    ("startVel", c_double * 8),  # 起跳速度
                    ("endVel", c_double * 8),  # 终止速度
                    ("maxVel", c_double * 8),  # 最大速度
                    ("smoothCoef", c_short * 8),  # 平滑系数
                    ("tgtPos", c_long * 8)]  # 位置，单位:脉冲

    """ 单轴点位运动打包(相对运动)
    // axisFirstHandle:数组的第一个轴句柄
    // pPackData:打包参数
    // 注意：1.如果某轴存在无法运动的错误状态，则所有轴不会启动运动
    """

    def NMC_MtMovePtpAbsPack8(axisFirstHandle, packData):
        libc.NMC_MtMovePtpAbsPack8.argtypes = [c_ushort, POINTER(pymtn.TMovePtpPack8)]
        return libc.NMC_MtMovePtpAbsPack8(axisFirstHandle, byref(packData))

    """ 单轴点位运动,相对运动
    // acc:加速度,dec：减速度,startVel:起跳速度,endVel:终止速度,smoothCoef:平滑系数
    // maxVel：最大速度
    // relPos:相对当前位置的移动量,单位：脉冲
    """

    def NMC_MtMovePtpRel(axisHandle, acc, dec, startVel, endVel, maxVel, smoothCoef, relPos):
        libc.NMC_MtMovePtpRel.argtypes = [c_ushort, c_double, c_double, c_double, c_double, c_double, c_short, c_long]
        return libc.NMC_MtMovePtpRel(axisHandle, acc, dec, startVel, endVel, maxVel, smoothCoef, relPos)

    """ PTP两段速运动参数"""

    class TPtpTwoStagePrm(Structure):
        _fields_ = [("acc", c_double),  # 加速度
                    ("dec", c_double),  # 减速度
                    ("startVel", c_double),  # 启动速度
                    ("endVel", c_double),  # 终点速度
                    ("maxVel", c_double),  # 最大速度
                    ("tgtPos", c_long),  # 目标位置
                    ("reserved", c_short),  # 保留参数
                    ("smoothCoef", c_short),  # 平滑系数
                    ("inType", c_short),  # 输入类型：0：通用DI，1：Home信号"),
                    ("inIdx", c_short),  # 输入信号通道号
                    ("inTrigLevel", c_short),  # 触发电平，0：低电平，1：高电平
                    ("action", c_short),  # 触发后的动作， 0:不动作，1:更新目标速度,
                    #                       2:更新目标位置
                    #                       3:更新目标位置（位置为相对触发点的相对位置）
                    #                       4:急停
                    ("prm1", c_double),  # action=1时表示更新的目标速度
                    ("prm2", c_double),  # action=2，3时表示更新的目标位置
                    ("prm3", c_double),  # 保留
                    ("prm4", c_double)]  # 保留

    """ 两段速PTP运动"""

    def NMC_MtMovePtpAbsTwoStage(axisHandle, prm):
        libc.NMC_MtMovePtpAbsTwoStage.argtypes = [c_ushort, POINTER(pymtn.TPtpTwoStagePrm)]
        return libc.NMC_MtMovePtpAbsTwoStage(axisHandle, byref(prm))

    """------------------------------------------------------------------------------------------------------------
    //
    //         4.单轴状态读取
    //
    //------------------------------------------------------------------------------------------------------------
    """
    """ 读取规划坐标系的位置
    //  pPos : 返回位置,单位是 脉冲
    """

    def NMC_MtGetPrfPos(axisHandle):
        pos_tmp = c_long()
        libc.NMC_MtGetPrfPos.argtypes = [c_ushort, POINTER(c_long)]
        ret = libc.NMC_MtGetPrfPos(axisHandle, byref(pos_tmp))
        return pos_tmp, ret

    """ 读当前轴规划速度
    // pVel: 返回速度,单位是 脉冲/ms
    """

    def NMC_MtGetPrfVel(axisHandle):
        vel_tmp = c_double()
        libc.NMC_MtGetPrfVel.argtypes = [c_ushort, POINTER(c_double)]
        ret = libc.NMC_MtGetPrfVel(axisHandle, byref(vel_tmp))
        return vel_tmp, ret

    """ 读取打包轴状态（4轴）"""
    class TAxisStsPack(Structure):
        _fields_ = [
            ("prfPos", c_long * PACK_AXIS_NUM),  # 规划位置数组
            ("encPos", c_long * PACK_AXIS_NUM),  # 实际位置数组
            ("prfVel", c_float * PACK_AXIS_NUM),  # 规划速度数组
            ("motionIO", c_long * PACK_AXIS_NUM),  # 轴专用IO数组
            ("sts", c_short * PACK_AXIS_NUM),  # 轴状态数组
            ("gpo", c_long),  # 通用输出
            ("gpi", c_long)  # 通用输入
        ]

    def NMC_MtGetStsPack(axisFirstHandle, count):
        packSts_tmp = pymtn.TAxisStsPack()
        libc.NMC_MtGetStsPack.argtypes = [c_ushort, c_short, POINTER(pymtn.TAxisStsPack)]
        ret = libc.NMC_MtGetStsPack(axisFirstHandle, count, byref(packSts_tmp))
        return packSts_tmp, ret

    """ 读取打包轴状态（12轴）"""

    class TAxisStsPack12Ex(Structure):
        _fields_ = [("mtSts", c_short * 12),  # 单轴状态，位定义参考NMC_MtGetSts
                    ("mtMio", c_short * 12),  # 单轴专用IO,位定义参考NMC_MtGetMotionIO
                    ("mtMioLog", c_short * 12),  # 单轴专用IO:逻辑电平,位定义参考NMC_MtGetMotionIOLogical
                    ("mtPrfPos", c_long * 12),  # 单轴规划位置
                    ("mtEncPos", c_long * 12),  # 单轴实际位置
                    ("mtPrfVel", c_float * 12),  # 单轴规划速度

                    ("crdSts", c_short * 2),  # 坐标系状态
                    ("crdPrfVel", c_float * 2),  # 坐标系运动速度
                    ("crdUserSeg", c_long * 2),  # 坐标系运行的缓冲区段号
                    ("crdFreeSpace", c_long * 2),  # 坐标系缓冲区剩余空间
                    ("crdUsedSpace", c_long * 2),  # 坐标系缓冲区使用空间

                    ("gpi", c_long),  # 通用输入
                    ("gpo", c_long),  # 通用输出
                    ("crdLeftLen", c_long * 2),  # 坐标系缓冲区剩余段长，单位:脉冲
                    ("crdAllCmdCnt", c_long * 2),  # 坐标系缓冲区总共压入的指令数目
                    ("extDi", c_long * 6),  # 扩展模块输入，2号站~8号站
                    ("extDo", c_long * 6),  # 扩展模块输出，2号站~8号站
                    ("adc", c_short * 4),  # 模拟量输入值 0~4通道
                    ("adcAux", c_short * 2),  # 扩展模拟量输入值 0~1通道
                    ("dac", c_short * 4),  # 模拟量输出值 0~4通道
                    ("dacAux", c_short * 2),  # 扩展模拟量输出值 0~1通道
                    ("reserved", c_long * 10)]  # 预留

    """ 打包读取12个轴的状态
    // axisFirstHandle : 第一个轴句柄
    // pPackSts: 打包的状态数据,参考结构体定义
    """

    def NMC_MtGetStsPack12Ex(axisFirstHandle):
        packSts_tmp = pymtn.TAxisStsPack12Ex()
        libc.NMC_MtGetStsPack12Ex.argtypes = [c_ushort, POINTER(pymtn.TAxisStsPack12Ex)]
        ret = libc.NMC_MtGetStsPack12Ex(axisFirstHandle, byref(packSts_tmp))
        return packSts_tmp, ret

    """ 读当前轴编码器通道
    //  pPos:返回编码器数值
    """

    def NMC_MtGetEncPos(axisHandle):
        pos_tmp = c_long()
        libc.NMC_MtGetEncPos.argtypes = [c_ushort, POINTER(c_long)]
        ret = libc.NMC_MtGetEncPos(axisHandle, byref(pos_tmp))
        return pos_tmp, ret

    """ 读轴编码器速度(单位是：脉冲/ms)"""

    def NMC_GetEncVel(devHandle, encId):
        vel_tmp = c_double()
        libc.NMC_GetEncVel.argtypes = [c_ushort, c_short, POINTER(c_double)]
        ret = libc.NMC_GetEncVel(devHandle, encId, byref(vel_tmp))
        return vel_tmp, ret

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

    """ 读当前轴状态
    // pStsWord: 返回轴状态字。参考位定义
    """

    def NMC_MtGetSts(axisHandle):
        stsword_tmp = c_short()
        libc.NMC_MtGetSts.argtypes = [c_ushort, POINTER(c_short)]
        ret = libc.NMC_MtGetSts(axisHandle, byref(stsword_tmp))
        return stsword_tmp, ret

    """ 专用IO定义,arrive,alm : home : limit+ , limit- """
    BIT_AXMTIO_LMTN = 0x00000001  # bit 0  ,负向限位
    BIT_AXMTIO_LMTP = 0x00000002  # bit 1  ,正向限位
    BIT_AXMTIO_HOME = 0x00000004  # bit 2  ,原点
    BIT_AXMTIO_ALARM = 0x00000008  # bit 3  ,驱动报警
    BIT_AXMTIO_ARRIVE = 0x00000010  # bit 4  ,电机到位
    BIT_AXMTIO_CAPT = 0x00000020  # bit 5  ,捕获源信号
    BIT_AXMTIO_SVRCLR = 0x00000100  # bit 8  ,伺服清除信号
    """ 读运动控制专用IO
    //  pIoValue : 返回专用IO的状态,原点,限位,报警。参考位定义。对应位为0为低电平,1为高电平
    """

    def NMC_MtGetMotionIO(axisHandle):
        ioValue_tmp = c_long()
        libc.NMC_MtGetMotionIO.argtypes = [c_ushort, POINTER(c_long)]
        ret = libc.NMC_MtGetMotionIO(axisHandle, byref(ioValue_tmp))
        return ioValue_tmp, ret

    """ 读运动控制专用IO,逻辑电平
    //  pIoValue : 返回专用IO的状态,原点,限位,报警。参考位定义。对应位为0为低电平,1为高电平
    """

    def NMC_MtGetMotionIOLogical(axisHandle):
        ioValue_tmp = c_long()
        libc.NMC_MtGetMotionIOLogical.argtypes = [c_ushort, POINTER(c_long)]
        ret = libc.NMC_MtGetMotionIOLogical(axisHandle, byref(ioValue_tmp))
        return ioValue_tmp, ret

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

    def NMC_SetDOGroup(devHandle, value, groupID):
        libc.NMC_SetDOGroup.argtypes = [c_ushort, c_long, c_short]
        return libc.NMC_SetDOGroup(devHandle, value, groupID)

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

    def NMC_GetDIGroup(devHandle, groupID):
        inValue_tmp = c_long()
        libc.NMC_GetDIGroup.argtypes = [c_ushort, POINTER(c_long), c_short]
        ret = libc.NMC_GetDIGroup(devHandle, byref(inValue_tmp), groupID)
        return inValue_tmp, ret

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

    def NMC_GetDOGroup(devHandle, groupID):
        doValue_tmp = c_long()
        libc.NMC_GetDOGroup.argtypes = [c_ushort, POINTER(c_long), c_short]
        ret = libc.NMC_GetDOGroup(devHandle, byref(doValue_tmp), groupID)
        return doValue_tmp, ret

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

    def NMC_SetDOBit(devHandle, bitIndex, value):
        libc.NMC_SetDOBit.argtypes = [c_ushort, c_short, c_short]
        return libc.NMC_SetDOBit(devHandle, bitIndex, value)

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

    def NMC_GetDIBit(devHandle, bitIndex):
        bitValue_tmp = c_short()
        libc.NMC_GetDI.argtypes = [c_ushort, c_short, POINTER(c_short)]
        ret = libc.NMC_GetDIBit(devHandle, bitIndex, byref(bitValue_tmp))
        return bitValue_tmp, ret

    """ 读取扩展IO模块的状态
    // sts:io模块状态
    """

    def NMC_GetIOModuleSts(devHandle):
        sts_tmp = c_ulong()
        libc.NMC_GetIOModuleSts.argtypes = [c_ushort, POINTER(c_ulong)]
        ret = libc.NMC_GetIOModuleSts(devHandle, sts_tmp)
        return (sts_tmp, ret)

    """ 设置扩展IO模块有效（默认为IO64模块）
    // chDevId:设备ID
    """

    def NMC_SetIOModuleEn(devHandle, chDevId):
        libc.NMC_SetIOModuleEn.argtypes = [c_ushort, c_ubyte]
        return libc.NMC_SetIOModuleEn(devHandle, chDevId)

    """ 扩展模块类型定义"""
    IOMODULE_TYPE_IO64 = 1  # 32DI32DO模块（包括16DI16DO模块）
    IOMODULE_TYPE_IO32_DA = 2  # 4AD4DA模块

    """ 设置扩展IO模块有效(带模块类型)
    // chDevId:设备ID
    // chDevType:模块类型，见宏定义
    """

    def NMC_IOModuleSetEn(devHandle, chDevId, chDevType):
        libc.NMC_IOModuleSetEn.argtypes = [c_ushort, c_ubyte, c_short]
        return libc.NMC_IOModuleSetEn(devHandle, chDevId, chDevType)

    """ 读取扩展IO模块类型
    // chDevId:设备ID
    // pChDevType:返回的模块类型，见宏定义
    """

    def NMC_IOModuleGetType(devHandle, chDevId):
        chDevType_tmp = c_short()
        libc.NMC_IOModuleGetType.argtypes = [c_ushort, c_ubyte, POINTER(c_short)]
        ret = libc.NMC_IOModuleGetType(devHandle, chDevId, byref(chDevType_tmp))
        return chDevType_tmp, ret

    """ 扩展IO模块通道写，8位长度
    // chDevId：设备站号
    // offset:数据偏移
    """

    def NMC_IOModuleWr8Bit(devHandle, chDevId, offset, data):
        libc.NMC_IOModuleWr8Bit.argtypes = [c_ushort, c_ubyte, c_ubyte, c_ubyte]
        return libc.NMC_IOModuleWr8Bit(devHandle, chDevId, offset, data)

    """ 扩展IO模块通道写，16位长度"""

    def NMC_IOModuleWr16Bit(devHandle, chDevId, offset, data):
        libc.NMC_IOModuleWr16Bit.argtypes = [c_ushort, c_ubyte, c_ubyte, c_ushort]
        return libc.NMC_IOModuleWr16Bit(devHandle, chDevId, offset, data)

    """ 扩展IO模块通道写，32位长度"""

    def NMC_IOModuleWr32Bit(devHandle, chDevId, offset, data):
        libc.NMC_IOModuleWr32Bit.argtypes = [c_ushort, c_ubyte, c_ubyte, c_ulong]
        return libc.NMC_IOModuleWr32Bit(devHandle, chDevId, offset, data)

    """ 扩展IO模块通道读输出，8位长度
    // chDevId：设备站号
    // offset:数据偏移
    """

    def NMC_IOModuleRdOut8Bit(devHandle, chDevId, offset):
        data_tmp = c_ubyte()
        libc.NMC_IOModuleRdOut8Bit.argtypes = [c_ushort, c_ubyte, c_ubyte, POINTER(c_ubyte)]
        ret = libc.NMC_IOModuleRdOut8Bit(devHandle, chDevId, offset, byref(data_tmp))
        return data_tmp, ret

    """ 扩展IO模块通道读输出，16位长度"""

    def NMC_IOModuleRdOut16Bit(devHandle, chDevId, offset):
        data_tmp = c_ushort()
        libc.NMC_IOModuleRdOut16Bit.argtypes = [c_ushort, c_ubyte, c_ubyte, POINTER(c_ushort)]
        ret = libc.NMC_IOModuleRdOut16Bit(devHandle, chDevId, offset, byref(data_tmp))
        return data_tmp, ret

    """ 扩展IO模块通道读输出，32位长度"""

    def NMC_IOModuleRdOut32Bit(devHandle, chDevId, offset):
        data_tmp = c_ulong()
        libc.NMC_IOModuleRdOut32Bit.argtypes = [c_ushort, c_ubyte, c_ubyte, POINTER(c_ulong)]
        ret = libc.NMC_IOModuleRdOut32Bit(devHandle, chDevId, offset, byref(data_tmp))
        return data_tmp, ret

    """ 扩展IO模块通道读，8位长度
    // chDevId：设备站号
    // offset:数据偏移"""

    def NMC_IOModuleRd8Bit(devHandle, chDevId, offset):
        data_tmp = c_ubyte()
        libc.NMC_IOModuleRd8Bit.argtypes = [c_ushort, c_ubyte, c_ubyte, POINTER(c_ubyte)]
        ret = libc.NMC_IOModuleRd8Bit(devHandle, chDevId, offset, byref(data_tmp))
        return data_tmp, ret

    """ 扩展IO模块通道读，16位长度"""

    def NMC_IOModuleRd16Bit(devHandle, chDevId, offset):
        data_tmp = c_ushort()
        libc.NMC_IOModuleRd16Bit.argtypes = [c_ushort, c_ubyte, c_ubyte, POINTER(c_ushort)]
        ret = libc.NMC_IOModuleRd16Bit(devHandle, chDevId, offset, byref(data_tmp))
        return data_tmp, ret

    """ 扩展IO模块通道读，32位长度"""

    def NMC_IOModuleRd32Bit(devHandle, chDevId, offset):
        data_tmp = c_ulong()
        libc.NMC_IOModuleRd32Bit.argtypes = [c_ushort, c_ubyte, c_ubyte, POINTER(c_ulong)]
        ret = libc.NMC_IOModuleRd32Bit(devHandle, chDevId, offset, byref(data_tmp))
        return data_tmp, ret

    """------------------------------------------------------------------------------------------------------------
    //
    //        6.坐标系配置
    //
    //------------------------------------------------------------------------------------------------------------
    """
    CRD_MAX_DIMENSION = 4

    """ 坐标系配置"""

    class TCrdConfig(Structure):
        _fields_ = [("axCnts", c_short),  # 参与的轴数量
                    ("reserved", c_short * 3),  # 保留
                    ("pAxArray", c_short * 4),  # 坐标系轴映射表,轴序号取值范围[0,n]
                    ("port", c_short * 4)]  # 坐标系端口映射表,统一设为0

    """ 建立插补坐标系系统(必须)
    // pConfig:坐标系配置,参考结构体定义"""

    def NMC_CrdConfig(crdHandle, crdCfg):  # TCrdConfig(crdCfg)
        libc.NMC_CrdConfig.argtypes = [c_ushort, POINTER(pymtn.TCrdConfig)]
        return libc.NMC_CrdConfig(crdHandle, byref(crdCfg))

    """ 坐标系运动参数
    //缓冲区运动安全参数"""

    class TCrdSafePara(Structure):
        _fields_ = [("estpDec", c_double),  # 急停加速度
                    ("maxVel", c_double),  # 最大速度
                    ("maxAcc", c_double)]  # 最大加速度

    """ 设置轴缓冲区运动安全参数
    // pPara：包含急停减速度、最大允许速度、最大允许加速度"""

    def NMC_CrdSetSafePara(crdHandle, para):
        libc.NMC_MtSetSafePara.argtypes = [c_ushort, POINTER(pymtn.TCrdSafePara)]
        return libc.NMC_MtSetSafePara(crdHandle, byref(para))

    """ 设置轴缓冲区运动偏移
    // count:设置偏移的轴数
    // pOffsetArray：缓冲区运动偏移,long数组
    // 注：会同时修改坐标系内相关轴的运动偏移！"""

    def NMC_CrdSetOffset(crdHandle, count, offsetArray):
        offsetArray_tmp = (c_long * count)(*map(c_long, offsetArray[:count]))
        libc.NMC_CrdSetOffset.argtypes = [c_ushort, c_short, POINTER(c_long)]
        return libc.NMC_CrdSetOffset(crdHandle, count, offsetArray_tmp)

    """ 删除坐标系"""

    def NMC_CrdDelete(crdHandle):
        libc.NMC_CrdDelete.argtypes = [c_ushort]
        return libc.NMC_CrdDelete(crdHandle)

    """------------------------------------------------------------------------------------------------------------
    //
    //        7.坐标系运行控制
    //
    //------------------------------------------------------------------------------------------------------------
    """
    """ 坐标系缓冲运动启动  
    """

    def NMC_CrdStartMtn(crdHandle):
        libc.NMC_CrdStartMtn.argtypes = [c_ushort]
        return libc.NMC_CrdStartMtn(crdHandle)

    """ 立即平滑停止运动
    // 注：立即停止运动。并不清空指令缓冲区。需要再次启动才能继续运行缓冲区指令。
    """

    def NMC_CrdStopMtn(crdHandle):
        libc.NMC_CrdStopMtn.argtypes = [c_ushort]
        return libc.NMC_CrdStopMtn(crdHandle)

    """ 急停
    // 并不清空指令缓冲区
    """

    def NMC_CrdEstopMtn(crdHandle):
        libc.NMC_CrdEstopMtn.argtypes = [c_ushort]
        return libc.NMC_CrdEstopMtn(crdHandle)

    """ 结束缓冲区运动（等待运动完后才结束区运动,并置空闲标志）
    // 注：缓冲区运动结束并不立即停止运动。把指令缓冲区全部执行完后,结束缓冲区运动状态。
    """

    def NMC_CrdEndMtn(crdHandle):
        libc.NMC_CrdEndMtn.argtypes = [c_ushort]
        return libc.NMC_CrdEndMtn(crdHandle)

    """ 返回缓冲区运动的断点
    // vel:返回时使用的速度
    // acc:返回时使用的加速度
    """

    def NMC_CrdGotoBreak(crdHandle, acc, vel):
        libc.NMC_CrdGotoBreak.argtypes = [c_ushort, c_double, c_double]
        return libc.NMC_CrdGotoBreak(crdHandle, acc, vel)

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

    def NMC_CrdGetSts(crdHandle):
        stsWord_tmp = c_short()
        libc.NMC_CrdGetSts.argtypes = [c_ushort, POINTER(c_short)]
        ret = libc.NMC_CrdGetSts(crdHandle, byref(stsWord_tmp))
        return stsWord_tmp, ret

    class TPackedCrdSts4(Structure):
        _fields_ = [("crdSts", c_short),  # 坐标系状态
                    ("axSts", c_short),  # 坐标系里各轴状态
                    ("prfPos", c_long * 4),  # 用户坐标系下的规划位置
                    ("axisPos", c_long * 4),  # 机械坐标系下的规划位置
                    ("encPos", c_long * 4),  # 编码器位置
                    ("userSeg", c_long),  # 运行的缓冲区段号
                    ("prfVel", c_double),  # 运动速度
                    ("gpDi", c_long),  # 通用输入0~31
                    ("gpDo", c_long),  # 通用输出0~31
                    ("motDi", c_short * 4),  # 限位、原点、报警。请参考专用IO位定义( 搜索 BIT_AXMTIO_LMTN )
                    ("reserved", c_short),  # 保留
                    ("crdFreeSpace", c_long),  # 缓冲区剩余空间
                    ("crdUsedSpace", c_long)]

    """
    // 坐标系运动模式下,打包读取控制器状态
    """

    def NMC_CrdGetStsPack4(crdHandle):
        packSts_tmp = pymtn.TPackedCrdSts4()
        libc.NMC_CrdGetStsPack4.argtypes = [c_ushort, POINTER(pymtn.TPackedCrdSts4)]
        ret = libc.NMC_CrdGetStsPack4(crdHandle, byref(packSts_tmp))
        return packSts_tmp, ret

    """ 清坐标系运动错误状态,同时清除所包含轴的错误状态
    """

    def NMC_CrdClrError(crdHandle):
        libc.NMC_CrdClrError.argtypes = [c_ushort]
        return libc.NMC_CrdClrError(crdHandle)

    """ 读取指令缓冲区空闲长度
    // pRes：返回空闲的长度
    """

    def NMC_CrdBufGetFree(crdHandle):
        res = c_long()
        libc.NMC_CrdBufGetFree.argtypes = [c_ushort, POINTER(c_long)]
        ret = libc.NMC_CrdBufGetFree(crdHandle, byref(res))
        return res, ret

    """ 读取指令缓冲区已用长度
    // pLen: 长度。缓冲区中还未执行的指令个数。
    """

    def NMC_CrdBufGetUsed(crdHandle):
        len_tmp = c_long()
        libc.NMC_CrdBufGetUsed.argtypes = [c_ushort, POINTER(c_long)]
        ret = libc.NMC_CrdBufGetUsed(crdHandle, byref(len_tmp))
        return len_tmp, ret

    """ 获取插补缓冲区中尚未完成的总位移量
    // pLen: 长度
    """

    def NMC_CrdGetBufLeftLength(crdHandle):
        len_tmp = c_double()
        libc.NMC_CrdGetBufLeftLength.argtypes = [c_ushort, POINTER(c_double)]
        ret = libc.NMC_CrdGetBufLeftLength(crdHandle, byref(len_tmp))
        return len_tmp, ret

    """ 指令缓冲区清空
    """

    def NMC_CrdBufClr(crdHandle):
        libc.NMC_CrdBufClr.argtypes = [c_ushort]
        return libc.NMC_CrdBufClr(crdHandle)

    """ 设置坐标系剩余位移量，用于控制激光能量跟随后的关闭波形输出
    // group:波形数组组号
    // ch:激光通道号
    """

    def NMC_CrdSetLeftLenForLaserWaveOff(crdHandle, length, group, ch):
        libc.NMC_CrdSetLeftLenForLaserWaveOff.argtypes = [c_ushort, c_double, c_short, c_short]
        return libc.NMC_CrdSetLeftLenForLaserWaveOff(crdHandle, length, group, ch)

    """ 读段号
    // pSegNo：返回的当前段号
    """

    def NMC_CrdGetUserSegNo(crdHandle):
        segNo_tmp = c_long()
        libc.NMC_CrdGetUserSegNo.argtypes = [c_ushort, POINTER(c_long)]
        ret = libc.NMC_CrdGetUserSegNo(crdHandle, byref(segNo_tmp))
        return segNo_tmp, ret

    """  读取总共压了多少条指令
    //  pCnt:返回的指令数
    """

    def NMC_CrdGetBufAllCmdCnt(crdHandle):
        cnt_tmp = c_long()
        libc.NMC_CrdGetBufAllCmdCnt.argtypes = [c_ushort, POINTER(c_long)]
        ret = libc.NMC_CrdGetBufAllCmdCnt(crdHandle, byref(cnt_tmp))
        return cnt_tmp, ret

    """ 开始计算缓冲区执行时间
    // 注意:1.如果需要计算执行时间，需要使用上位机前瞻
    //     2.开始后，所有的缓冲区指令，都不会压入控制器
    """

    def NMC_CrdStartExeTimeCalc():
        libc.NMC_CrdStartExeTimeCalc.argtypes = []
        return libc.NMC_CrdStartExeTimeCalc()

    """ 读取缓冲区指令的执行时间，并停止计算，单位:ms
    """

    def NMC_CrdGetExeTime():
        time_tmp = c_double()
        libc.NMC_CrdGetExeTime.argtypes = [POINTER(c_double)]
        ret = libc.NMC_CrdGetExeTime(byref(time_tmp))
        return time_tmp, ret

    """------------------------------------------------------------------------------------------------------------
    //
    //        9.缓冲区插补运动和IO控制
    //
    //------------------------------------------------------------------------------------------------------------

    // 四轴直线插补
    // segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
    // crdAxMask:参与的轴,按位表示
    // endVel,vel,synAcc:终点速度，最大速度，插补加速度
    // pTgPosArray：目标位置数组
    // lookaheadDis:是否使用前瞻,0：使用前瞻,则控制器自动计算终点速度,1：禁用前瞻,使用设定的终点速度（endVel）
    """

    def NMC_CrdLineXYZA(crdHandle, segNo, crdAxMask, tgPosArray, endVel, vel, synAcc, lookaheadDis):
        tgPosArray_tmp = (c_long * 4)(*map(c_long, tgPosArray))
        libc.NMC_CrdLineXYZA.argtypes = [c_ushort, c_long, c_short, POINTER(c_long), c_double, c_double, c_double,
                                         c_short]
        ret = libc.NMC_CrdLineXYZA(crdHandle, segNo, crdAxMask, tgPosArray_tmp, endVel, vel, synAcc, lookaheadDis)
        return ret

    """ 设置4维插补下，A轴的最大容忍转弯速度，若大于该速度，则需要进行降速处理
    """

    def NMC_CrdSetFourthAxisTolTurnVel(crdHandle, tolVel):
        libc.NMC_CrdSetFourthAxisTolTurnVel.argtypes = [c_ushort, c_double]
        return libc.NMC_CrdSetFourthAxisTolTurnVel(crdHandle, tolVel)

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

    def NMC_CrdLineXYZEx(crdHandle, segNo, crdAxMask, tgPosArray, endVel, vel, synAcc, lookaheadDis):
        tgPosArray_tmp = (c_long * 3)(*map(c_long, tgPosArray))
        libc.NMC_CrdLineXYZEx.argtypes = [c_ushort, c_long, c_short, POINTER(c_long), c_double, c_double, c_double,
                                          c_short]
        return libc.NMC_CrdLineXYZEx(crdHandle, segNo, crdAxMask, tgPosArray_tmp, endVel, vel, synAcc, lookaheadDis)

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

    def NMC_CrdLineXYZD8(crdHandle, segNo, crdAxmask, extAxMask, tgPosArray, endVel, vel, synAcc, lookaheadDis):
        tgPosArray_tmp = (c_long * len(tgPosArray))(*map(c_long, tgPosArray))
        libc.NMC_CrdLineXYZD8.argtypes = [c_ushort, c_long, c_long, c_long, POINTER(c_long), c_double, c_double,
                                          c_double, c_short]
        return libc.NMC_CrdLineXYZD8(crdHandle, segNo, crdAxmask, extAxMask, tgPosArray_tmp, endVel, vel, synAcc,
                                     lookaheadDis)

    """ 8轴插补打包单元结构体"""

    class TCrdLineXYZD8Unit(Structure):
        _fields_ = [("segNo", c_long),  # 用户自定义段号
                    ("crdAxMask", c_short),
                    ("extAxMask", c_short),
                    ("tgPos[8]", c_long * 8),  # 目标位置
                    ("vel", c_float),  # 最大速度
                    ("endVel", c_float),  # 终点速度
                    ("acc", c_float),  # 插补加速度
                    ("lookaheadDis", c_short),  # 是否使用前瞻
                    ("reserved", c_short)]  # 保留

    """ 打包的多轴直线插补
    // count:打包指令数,取值范围[1,18]
    // pCmdArray:指令列表
    """

    def NMC_CrdLineXYZD8Pack(crdHandle, count, cmdArray):
        libc.NMC_CrdLineXYZD8Pack.argtypes = [c_ushort, c_short, POINTER(pymtn.TCrdLineXYZD8Unit)]
        return libc.NMC_CrdLineXYZD8Pack(crdHandle, count, cmdArray)

    """ 4轴插补打包单元结构体"""

    class TCrdLineXYZD4Unit(Structure):
        _fields_ = [("segNo", c_long),  # 用户自定义段号
                    ("crdAxMask", c_short),
                    ("extAxMask", c_short),
                    ("tgPos[4]", c_long * 4),  # 目标位置
                    ("vel", c_float),  # 最大速度
                    ("endVel", c_float),  # 终点速度
                    ("acc", c_float),  # 插补加速度
                    ("lookaheadDis", c_short),  # 是否使用前瞻
                    ("reserved", c_short)]  # 保留

    """ 打包的4轴直线插补
    // count:打包指令数,取值范围[1,25]
    // pCmdArray:指令列表
    """

    def NMC_CrdLineXYZD4Pack(crdHandle, count, cmdArray):
        libc.NMC_CrdLineXYZD4Pack.argtypes = [c_ushort, c_short, POINTER(pymtn.TCrdLineXYZD4Unit)]
        return libc.NMC_CrdLineXYZD4Pack(crdHandle, count, cmdArray)

    class TCrdLineXYZUnit(Structure):
        _fields_ = [("segNo", c_long),  # 用户自定义段号
                    ("tgPos[3]", c_long * 3),  # 目标位置
                    ("endVel", c_double),  # 终点速度
                    ("vel", c_double),  # 最大速度
                    ("synAcc", c_double),  # 插补加速度
                    ("mask", c_short),  # 参与的轴,按位表示
                    ("lookaheadDis", c_short),  # 是否使用前瞻
                    ("reserved[2]", c_short * 2)]  # 保留

    """ 打包的直线插补
    // count:打包指令数,取值范围[1,20]
    // pCmdArray:指令列表
    """

    def NMC_CrdLineXYZPack(crdHandle, count, cmdArray):
        libc.NMC_CrdLineXYZPack.argtypes = [c_ushort, c_short, POINTER(pymtn.TCrdLineXYZUnit)]
        return libc.libc.NMC_CrdLineXYZPack(crdHandle, count, byref(cmdArray))

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

    def NMC_CrdArcRadius(crdHandle, segNo, tgPosArray, radius, circleDir, endVel, vel, synAcc):
        tgPos_tmp = (c_long * 2)(*map(c_long, tgPosArray))
        libc.NMC_CrdArcRadius.argtypes = [c_ushort, c_long, POINTER(c_long), c_double, c_short, c_double, c_double,
                                          c_double]
        return libc.NMC_CrdArcRadius(crdHandle, segNo, tgPos_tmp, radius, circleDir, endVel, vel, synAcc)

    """ YZ平面圆弧插补：终点位置、半径、方向
    // segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
    // radius:圆弧半径,大于0表示劣弧,小于0表示优弧
    // pTgPosArray：目标位置数组（二维数组,分别表示YZ的位置）                                                           #####yufacuowu二维数组
    // circleDir:圆弧方向,0表示顺时针方向,1表示逆时针方向
    """

    def NMC_CrdArcRadiusYZ(crdHandle, segNo, tgPos, radius, circleDir, velEnd, vel, synAcc):
        tgPos_tmp = (c_long * 2)(*map(c_long, tgPos))
        libc.NMC_CrdArcRadiusYZ.argtypes = [c_ushort, c_long, POINTER(c_long), c_double, c_short, c_double, c_double,
                                            c_double]
        return libc.NMC_CrdArcRadiusYZ(crdHandle, segNo, tgPos_tmp, radius, circleDir, velEnd, vel, synAcc)

    """ ZX平面圆弧插补：终点位置、半径、方向
    // segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
    // radius:圆弧半径,大于0表示劣弧,小于0表示优弧
    // pTgPosArray：目标位置数组（二维数组,分别表示ZX的位置）                                                           #####yufacuowu 二维数组
    // circleDir:圆弧方向,0表示顺时针方向,1表示逆时针方向
    """

    def NMC_CrdArcRadiusZX(crdHandle, segNo, tgPos, radius, circleDir, velEnd, vel, synAcc):
        tgPos_tmp = (c_long * 2)(*map(c_long, tgPos))
        libc.NMC_CrdArcRadiusZX.argtypes = [c_ushort, c_long, POINTER(c_long), c_double, c_short, c_double, c_double,
                                            c_double]
        return libc.NMC_CrdArcRadiusZX(crdHandle, segNo, tgPos_tmp, radius, circleDir, velEnd, vel, synAcc)

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

    def NMC_CrdArcRadiusEx(crdHandle, segNo, tgPosArray, radius, circleDir, endVel, vel, synAcc, lookaheadDis):
        tgPos_tmp = (c_long * 2)(*map(c_long, tgPosArray))
        libc.NMC_CrdArcRadiusEx.argtypes = [c_ushort, c_long, POINTER(c_long), c_double, c_short, c_double, c_double,
                                            c_double, c_short]
        return libc.NMC_CrdArcRadiusEx(crdHandle, segNo, tgPos_tmp, radius, circleDir, endVel, vel, synAcc,
                                       lookaheadDis)

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

    def NMC_CrdArcRadiusYZEx(crdHandle, segNo, tgPos, radius, circleDir, velEnd, vel, synAcc, lookaheadDis):
        tgPos_tmp = (c_long * 2)(*map(c_long, tgPos))
        libc.NMC_CrdArcRadiusYZEx.argtypes = [c_ushort, c_long, POINTER(c_long), c_double, c_short, c_double, c_double,
                                              c_double, c_short]
        return libc.NMC_CrdArcRadiusYZEx(crdHandle, segNo, tgPos_tmp, radius, circleDir, velEnd, vel, synAcc, lookaheadDis)

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

    def NMC_CrdArcRadiusZXEx(crdHandle, segNo, tgPos, radius, circleDir, velEnd, vel, synAcc, lookaheadDis):
        tgPos_tmp = (c_long * 2)(*map(c_long, tgPos))
        libc.NMC_CrdArcRadiusZXEx.argtypes = [c_ushort, c_long, POINTER(c_long), c_double, c_short, c_double, c_double,
                                              c_double, c_short]
        return libc.NMC_CrdArcRadiusZXEx(crdHandle, segNo, tgPos_tmp, radius, circleDir, velEnd, vel, synAcc, lookaheadDis)

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

    def NMC_CrdArcCenter(crdHandle, segNo, tgPosArray, centerPosArray, circleDir, endVel, vel, synAcc):
        tgPosArray_tmp = (c_long * 3)(*map(c_long, tgPosArray))
        centerPosArray_tmp = (c_long * 3)(*map(c_long, centerPosArray))
        libc.NMC_CrdArcCenter.argtypes = [c_ushort, c_long, POINTER(c_long * 3), POINTER(c_long * 3), c_short, c_double,
                                          c_double, c_double]
        return libc.NMC_CrdArcCenter(crdHandle, segNo, tgPosArray_tmp, centerPosArray_tmp, circleDir, endVel, vel, synAcc)

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

    def NMC_CrdArcCenterYZ(crdHandle, segNo, tgPosArray, centerPosArray, circleDir, velEnd, vel, synAcc):
        tgPosArray_tmp = (c_long * 2)(*map(c_long, tgPosArray))
        centerPosArray_tmp = (c_long * 2)(*map(c_long, centerPosArray))
        libc.NMC_CrdArcCenterYZ.argtypes = [c_ushort, c_long, POINTER(c_long), POINTER(c_long), c_short, c_double,
                                            c_double, c_double]
        return libc.NMC_CrdArcCenterYZ(crdHandle, segNo, tgPosArray_tmp, centerPosArray_tmp, circleDir, velEnd, vel, synAcc)

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

    def NMC_CrdArcCenterZX(crdHandle, segNo, tgPosArray, centerPosArray, circleDir, velEnd, vel, synAcc):
        tgPosArray_tmp = (c_long * 2)(*map(c_long, tgPosArray))
        centerPosArray_tmp = (c_long * 2)(*map(c_long, centerPosArray))
        libc.NMC_CrdArcCenterZX.argtypes = [c_ushort, c_long, POINTER(c_long), POINTER(c_long), c_short, c_double,
                                            c_double, c_double]
        return libc.NMC_CrdArcCenterZX(crdHandle, segNo, tgPosArray_tmp, centerPosArray_tmp, circleDir, velEnd, vel, synAcc)

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

    def NMC_CrdArcCenterEx(crdHandle, segNo, tgPosArray, centerPosArray, circleDir, endVel, vel, synAcc, lookaheadDis):
        tgPosArray_tmp = (c_long * 2)(*map(c_long, tgPosArray))
        centerPosArray_tmp = (c_long * 2)(*map(c_long, centerPosArray))
        libc.NMC_CrdArcCenterEx.argtypes = [c_ushort, c_long, POINTER(c_long), POINTER(c_long), c_short, c_double,
                                            c_double, c_double, c_short]
        return libc.NMC_CrdArcCenterEx(crdHandle, segNo, tgPosArray_tmp, centerPosArray_tmp, circleDir, endVel, vel, synAcc,
                                       lookaheadDis)

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

    def NMC_CrdArcCenterYZEx(crdHandle, segNo, tgPosArray, centerPosArray, circleDir, velEnd, vel, synAcc,
                             lookaheadDis):
        tgPosArray_tmp = (c_long * 2)(*map(c_long, tgPosArray))
        centerPosArray_tmp = (c_long * 2)(*map(c_long, centerPosArray))
        libc.NMC_CrdArcCenterYZEx.argtypes = [c_ushort, c_long, POINTER(c_long), POINTER(c_long), c_short, c_double,
                                              c_double, c_double, c_short]
        return libc.NMC_CrdArcCenterYZEx(crdHandle, segNo, tgPosArray_tmp, centerPosArray_tmp, circleDir, velEnd, vel, synAcc,
                                         lookaheadDis)

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

    def NMC_CrdArcCenterZXEx(crdHandle, segNo, tgPosArray, centerPosArray, circleDir, velEnd, vel, synAcc,
                             lookaheadDis):
        tgPosArray_tmp = (c_long * 2)(*map(c_long, tgPosArray))
        centerPosArray_tmp = (c_long * 2)(*map(c_long, centerPosArray))
        libc.NMC_CrdArcCenterZXEx.argtypes = [c_ushort, c_long, POINTER(c_long), POINTER(c_long), c_short, c_double,
                                              c_double, c_double, c_short]
        return libc.NMC_CrdArcCenterZXEx(crdHandle, segNo, tgPosArray_tmp, centerPosArray_tmp, circleDir, velEnd, vel, synAcc,
                                         lookaheadDis)

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

    def NMC_CrdArcPPP(crdHandle, segNo, midPosArray, tgPosArray, endVel, vel, synAcc):
        midPosArray_tmp = (c_long * 2)(*map(c_long, midPosArray))
        tgPosArray_tmp = (c_long * 2)(*map(c_long, tgPosArray))
        libc.NMC_CrdArcPPP.argtypes = [c_ushort, c_long, POINTER(c_long), POINTER(c_long), c_double, c_double, c_double]
        return libc.NMC_CrdArcPPP(crdHandle, segNo, midPosArray_tmp, tgPosArray_tmp, endVel, vel, synAcc)

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

    def NMC_CrdArcPPPEx(crdHandle, segNo, midPosArray, tgPosArray, endVel, vel, synAcc, lookaheadDis):
        libc.NMC_CrdArcPPPEx.argtypes = [c_ushort, c_long, POINTER(c_long), POINTER(c_long), c_double, c_double,
                                         c_double, c_short]
        return libc.NMC_CrdArcPPPEx(crdHandle, segNo, byref(midPosArray), byref(tgPosArray), endVel, vel, synAcc, lookaheadDis)

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

    def NMC_CrdHelixCenter(crdHandle, segNo, pTgPosArray, pCenterPosArray, circleDir, rounds, endVel, vel, synAcc):
        pTgPosArray_tmp = (c_long * 3)(*map(c_long, pTgPosArray))
        pCenterPosArray_tmp = (c_long * 2)(*map(c_long, pCenterPosArray))
        libc.NMC_CrdHelixCenter.argtypes = [c_ushort, c_long, POINTER(c_long), POINTER(c_long), c_short, c_double,
                                            c_double, c_double, c_double]
        return libc.NMC_CrdHelixCenter(crdHandle, segNo, pTgPosArray_tmp, pCenterPosArray_tmp, circleDir, rounds, endVel, vel,
                                       synAcc)

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

    def NMC_CrdHelixCenterEx(crdHandle, segNo, pTgPosArray, pCenterPosArray, circleDir, rounds, endVel, vel, synAcc,
                             lookaheadDis):
        pTgPosArray_tmp = (c_long * 3)(*map(c_long, pTgPosArray))
        pCenterPosArray_tmp = (c_long * 2)(*map(c_long, pCenterPosArray))
        libc.NMC_CrdHelixCenterEx.argtypes = [c_ushort, c_long, POINTER(c_long), POINTER(c_long), c_short, c_double,
                                              c_double, c_double, c_double, c_short]
        return libc.NMC_CrdHelixCenterEx(crdHandle, segNo, pTgPosArray_tmp, pCenterPosArray_tmp, circleDir, rounds, endVel, vel,
                                         synAcc, lookaheadDis)

    """ 3D圆弧插补
    // segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
    // pMidPos：中点位置（三维数组,分别表示中点的XYZ轴的位置）
    // pTgPos:终点位置（三维数组,分别表示终点的XYZ轴的位置）
    """

    def NMC_CrdArc3D(crdHandle, segNo, midPos, tgPos, velEnd, vel, synAcc):
        MidPosArr_tmp = (c_long * 3)(*map(c_long, midPos))
        TgPosArr_tmp = (c_long * 3)(*map(c_long, tgPos))
        libc.NMC_CrdArc3D.argtypes = [c_ushort, c_long, POINTER(c_long), POINTER(c_long), c_double, c_double, c_double]
        return libc.NMC_CrdArc3D(crdHandle, segNo, MidPosArr_tmp, TgPosArr_tmp, velEnd, vel, synAcc)

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

    def NMC_CrdArc3DEx(crdHandle, segNo, midPos, tgPos, velEnd, vel, synAcc, lookaheadDis):
        MidPosArr_tmp = (c_long * 3)(*map(c_long, midPos))
        TgPosArr_tmp = (c_long * 3)(*map(c_long, tgPos))
        libc.NMC_CrdArc3DEx.argtypes = [c_ushort, c_long, POINTER(c_long), POINTER(c_long), c_double, c_double,
                                        c_double, c_short]
        return libc.NMC_CrdArc3DEx(crdHandle, segNo, MidPosArr_tmp, TgPosArr_tmp, velEnd, vel, synAcc, lookaheadDis)

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

    def NMC_CrdCircle3DEx(crdHandle, segNo, pMidPos, pTgPos, velEnd, vel, synAcc, lookaheadDis):
        MidPosArr_tmp = (c_long * 3)(*map(c_long, pMidPos))
        TgPosArr_tmp = (c_long * 3)(*map(c_long, pTgPos))
        libc.NMC_CrdCircle3DEx.argtypes = [c_ushort, c_long, POINTER(c_long), POINTER(c_long), c_double, c_double,
                                           c_double, c_short]
        return libc.NMC_CrdCircle3DEx(crdHandle, segNo, MidPosArr_tmp, TgPosArr_tmp, velEnd, vel, synAcc, lookaheadDis)

    """ 缓冲区输出DO组定义"""
    CRD_BUFF_DO_MOTOR_ENABLE = 1  # 电机使能
    CRD_BUFF_DO_MOTOR_CLEAR = 2  # 电机报警清除
    CRD_BUFF_DO_GPDO1 = 3  # 通用输出1
    CRD_BUFF_DO_GPDO2 = 4  # 通用输出2
    CRD_BUFF_DO_EXTDO1 = 5  # 扩展模块1
    CRD_BUFF_DO_EXTDO2 = 6  # 扩展模块2
    CRD_BUFF_DO_EXTDO3 = 7  # 扩展模块3
    CRD_BUFF_DO_EXTDO4 = 8  # 扩展模块4
    CRD_BUFF_DO_EXTDO5 = 9  # 扩展模块5
    CRD_BUFF_DO_EXTDO6 = 10  # 扩展模块6

    """ 缓冲区DO
    // segNo:段号
    // doType:Do类型,见宏定义
    // ch：位序号,取值范围[0,31]
    // value：输出值,取值范围[0,1]
    """

    def NMC_CrdBufDo(crdHandle, segNo, doType, ch, value):
        libc.NMC_CrdBufDo.argtypes = [c_ushort, c_long, c_short, c_long, c_long]
        return libc.NMC_CrdBufDo(crdHandle, segNo, doType, ch, value)

    """ 缓冲区DO
    // segNo:段号
    // gourp:Do组别,见宏定义
    // doMask：位掩码
    // doValue：输出值
    """

    def NMC_CrdBufDoEx(crdHandle, segNo, group, doMask, doValue):
        libc.NMC_CrdBufDoEx.argtypes = [c_ushort, c_long, c_short, c_long, c_long]
        return libc.NMC_CrdBufDoEx(crdHandle, segNo, group, doMask, doValue)

    """ 通用输出宏类型"""
    BUF_OUT_GROUP_DA = 0  # 模拟量输出
    BUF_OUT_GROUP_PWM = 1  # PWM输出

    """缓冲区输出
    // segNo:段号
    // gourp:组别,见宏定义
    // ch：通道号,取值范围[0,n]
    // value：输出值
    """

    def NMC_CrdBufOut(crdHandle, segNo, group, ch, value):
        libc.NMC_CrdBufOut.argtypes = [c_ushort, c_long, c_short, c_short, c_long]
        return libc.NMC_CrdBufOut(crdHandle, segNo, group, ch, value)

    """ 缓冲区DI等待
    // index:通道号,取值范围[0,127],前64通道代表通用DI，后64通道代表扩展IO
    // diValue：等待值
    // waitLastTime：超时,单位：毫秒
    """

    def NMC_CrdBufWaitDI(crdHandle, segNo, index, diValue, waitLastTime):
        return libc.NMC_CrdBufWaitDI(crdHandle, segNo, index, diValue, waitLastTime)

    """ 功能:缓冲区等待电机运动到位
    // segNo:段号
    // axisMask:需要等待到位的轴掩码（按位对应轴号,不能超出控制器的最大轴数）
    // overTime:等待到位超时的时间，单位：ms
    """

    def NMC_CrdBufWaitEncInPosition(crdHandle, segNo, axisMask, overTime):
        return libc.NMC_CrdBufWaitEncInPosition(crdHandle, segNo, axisMask, overTime)

    """ 功能:缓冲区等待特定位置，满足条件才执行下一条指令
    // segNo:段号
    // axisNo:需要等待到位的轴号
    // condition:到位条件，0：小于等于设定位置  1：大于等于设定位置
    // pos:设定位置
    // posSrc:等待规划还是编码器，0：编码器 1：内部规划
    // overTime:等待到位超时的时间，单位：ms
    """

    def NMC_CrdBufWaitPos(crdHandle, segNo, axisNo, condition, pos, posSrc, overTime):
        libc.NMC_CrdBufWaitPos.argtypes = [c_ushort, c_long, c_short, c_short, c_long, c_short, c_long]
        return libc.NMC_CrdBufWaitPos(crdHandle, segNo, axisNo, condition, pos, posSrc, overTime)

    """ 缓冲区延时单位"""
    CRD_BUFF_DELAY_SCALE_MS = 0  # 毫秒
    CRD_BUFF_DELAY_SCALE_SECAND = 1  # 秒

    """ 缓冲区延时
    // segNo:段号
    // scale:延时单位,0表示单位为毫秒,1表示单位为秒
    // count：延时时长
    """

    def NMC_CrdBufDelay(crdHandle, segNo, scale, count):
        libc.NMC_CrdBufDelay.argtypes = [c_ushort, c_long, c_short, c_long]
        return libc.NMC_CrdBufDelay(crdHandle, segNo, scale, count)

    """ 缓冲区单轴移动(绝对位移移动)
    // segNo:段号
    // axisMask:参与的轴
    // pTgPos：目标位置
    // blockEn:是否为阻塞模式
    // synEn：是否为同步模式,如果synEn和blockEn同时为1,则同步优先
    """

    def NMC_CrdBufAxMove(crdHandle, segNo, axisMask, tgPos, blockEn, synEn):
        libc.NMC_CrdBufAxMove.argtypes = [c_ushort, c_long, c_short, POINTER(c_long), c_short, c_short]
        return libc.NMC_CrdBufAxMove(crdHandle, segNo, axisMask, byref(tgPos), blockEn, synEn)

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

    def NMC_CrdBufAxMoveEx(crdHandle, segNo, axisMask, tgPos, vel, acc, blockEn, synEn):
        libc.NMC_CrdBufAxMoveEx.argtypes = [c_ushort, c_long, c_short, POINTER(c_long), c_double, c_double, c_short,
                                            c_short]
        return libc.NMC_CrdBufAxMoveEx(crdHandle, segNo, axisMask, byref(tgPos), vel, acc, blockEn, synEn)

    """ 缓冲区单轴移动(相对位移移动)
    // segNo:段号
    // axisMask:参与的轴
    // pRelPos：相对移动位置
    // blockEn:是否为阻塞模式
    // synEn：是否为同步模式,如果synEn和blockEn同时为1,则同步优先
    """

    def NMC_CrdBufAxMoveRe(crdHandle, segNo, axisMask, relPos, blockEn, synEn):
        libc.NMC_CrdBufAxMoveRel.argtypes = [c_ushort, c_long, c_short, POINTER(c_long), c_short, c_short]
        return libc.NMC_CrdBufAxMoveRel(crdHandle, segNo, axisMask, byref(relPos), blockEn, synEn)

    """ 缓冲区单轴移动参数设置
    // segNo:段号
    // axisNo：轴号,[0,n]
    // vel:运动速度
    // acc:运动加速度
    // smoothCoef:平滑系数
    """

    def NMC_CrdBufSetPtpMovePara(crdHandle, segNo, axisNo, vel, acc, soomthCoef):
        libc.NMC_CrdBufSetPtpMovePara.argtypes = [c_ushort, c_long, c_short, c_double, c_double, c_short]
        return libc.NMC_CrdBufSetPtpMovePara(crdHandle, segNo, axisNo, vel, acc, soomthCoef)

    """ 缓冲区跟随
    // segNo:段号
    // onOff:开关
    """

    def NMC_CrdBufValueFollow(crdHandle, segNo, onOff):
        libc.NMC_CrdBufValueFollow.argtypes = [c_ushort, c_long, c_short]
        return libc.NMC_CrdBufValueFollow(crdHandle, segNo, onOff)

    """ 缓冲区设置加工幅面范围，超出范围则停止运动
    // crdAxMask:是否激活幅面限制	按位进行判断 ，bit0~2，分别对应XYZ轴 1：开启，0 关闭
    // pXMax: pXMax[0]为X的最小行程边界	pXMax[1]为X的最大行程边界  pXMax[2]为X发生干涉时等待的参考位置
    // pYMax和pZMax 同pXMax说明
    """

    def NMC_CrdBufSetScaleLimit(crdHandle, segNo, crdAxMask, xMax, yMax, zMax):
        libc.NMC_CrdBufSetScaleLimit.argtypes = [c_ushort, c_long, c_short, POINTER(c_long), POINTER(c_long),
                                                 POINTER(c_long)]
        return libc.NMC_CrdBufSetScaleLimit(crdHandle, segNo, crdAxMask, byref(xMax), byref(yMax), byref(zMax))

    """ 设置跟随运动前的运动补偿量
    // axis:轴号  0~N
    //relDistance：相对补偿位移量
    //vel：补偿速度
    """

    def NMC_CrdBufBeforeAxSyncMove(crdHandle, segNo, axis, relDistance, vel):
        libc.NMC_CrdBufBeforeAxSyncMove.argtypes = [c_ushort, c_long, c_short, c_long, c_double]
        return libc.NMC_CrdBufBeforeAxSyncMove(crdHandle, segNo, axis, relDistance, vel)

    """ 设置坐标系速度倍率
    // overRide：坐标系速度倍率,取值范围(0,10)
    """

    def NMC_CrdSetOverRide(crdHandle, overRide):
        libc.NMC_CrdSetOverRide.argtypes = [c_ushort, c_double]
        return libc.NMC_CrdSetOverRide(crdHandle, overRide)

    """------------------------------------------------------------------------------------------------------------
    //
    //        10.回零
    //
    //------------------------------------------------------------------------------------------------------------
    """
    """ 回零类型定义"""

    class THomeMode(IntEnum):  # 回零模式
        HM_MODE1 = 0  # 单原点
        HM_MODE2 = 1  # 单限位
        HM_MODE3 = 2  # 单Z相
        HM_MODE4 = 3  # 原点+Z相
        HM_MODE5 = 4  # 原点+-Z相
        HM_MODE6 = 5  # 限位+ -Z相

        def from_param(obj):
            return obj

    """ 回零参数设置"""

    class THomeSetting(Structure):
        _fields_ = [("mode", c_short),  # 模式,HM_MODE1 ~ HM_MODE6 （必须）
                    ("dir", c_short),  # 搜寻零点方向（必须）, 0:负向,1：正向,其它值无意义
                    ("offset", c_long),  # 原点偏移（必须）
                    ("scan1stVel", c_double),  # 基本搜寻速度（必须）
                    ("scan2ndVel", c_double),  # 低速（两次搜寻时需要）
                    # 当usePreSetPtpPara=0时,回零运动的减加速度默认等于acc,起跳速度、终点速度、平滑系数默认为0
                    ("acc", c_double),  # 加速度
                    ("reScanEn", c_ubyte),  # 是否两次搜寻零点（可选,不用时设为0）
                    ("homeEdge", c_ubyte),  # 原点,触发沿（默认下降沿）
                    ("lmtEdge", c_ubyte),  # 限位,触发沿（默认下降沿）
                    ("zEdge", c_ubyte),  # 限位,触发沿（默认下降沿）
                    ("iniRetPos", c_ulong),  # 起始反向运动距离（可选,不用时设为0）
                    ("retSwOffset", c_ulong),  # 反向运动时离开开关距离（可选,不用时设为0）
                    ("safeLen", c_ulong),  # 安全距离,回零时最远搜寻距离（可选,不用时设为0,不限制距离）
                    ("usePreSetPtpPara", c_ubyte),  # 为1表示用户需要在启动回零前,自己设置回零运动（点到点）的参数
                    ("reserved", c_ubyte * 3),  # 保留
                    ("reserved2", c_long)]  # 保留

    """ 设置回零参数
    // pHomePara: 回零参数结构,参考结构定义
    """

    def NMC_MtSetHomePara(axisHandle, homePara):  # THomeSetting(homePara)
        libc.NMC_MtSetHomePara.argtypes = [c_ushort, POINTER(pymtn.THomeSetting)]
        return libc.NMC_MtSetHomePara(axisHandle, byref(homePara))

    """ 回零状态字位定义 """
    BIT_AXHOME_BUSY = 0x00000001  # bit 0  , 忙
    BIT_AXHOME_OK = 0x00000002  # bit 1  , 成功
    BIT_AXHOME_FAIL = 0x00000004  # bit 2  , 失败
    BIT_AXHOME_ERR_MV = 0x00000008  # bit 3  , 错误：运动参数出错导致不动
    BIT_AXHOME_ERR_SWT = 0x00000010  # bit 4  , 错误：搜寻过程中开关没触发
    """ 读回零状态
    // pStsWord: 返回状态字。参数宏定义,高8位为错误代码
    """

    def NMC_MtGetHomeSts(axisHandle):
        stsWord_tmp = c_short()
        libc.NMC_MtGetHomeSts.argtypes = [c_ushort, POINTER(c_short)]
        ret = libc.NMC_MtGetHomeSts(axisHandle, byref(stsWord_tmp))
        return stsWord_tmp, ret

    """
     // 启动回零
    """

    def NMC_MtHome(axisHandle):
        libc.NMC_MtHome.argtypes = [c_ushort]
        return libc.NMC_MtHome(axisHandle)

    """ 
    // 尝试性回零（测试回零误差,不清位置）
    """

    def NMC_MtTryHome(axisHandle):
        libc.NMC_MtTryHome.argtypes = [c_ushort]
        return libc.NMC_MtTryHome(axisHandle)

    """ 终止回零
    """

    def NMC_MtHomeStop(axisHandle):
        libc.NMC_MtHomeStop.argtypes = [c_ushort]
        return libc.NMC_MtHomeStop(axisHandle)

    """ 读新回零位置和历史回零位置的差值
    // pErrPos: 回零位置偏差
    // 注：回零成功时才有意义
    """

    def NMC_MtGetHomeError(axisHandle, errPos):
        libc.NMC_MtGetHomeError.argtypes = [c_ushort, POINTER(c_long)]
        return libc.NMC_MtGetHomeError(axisHandle, byref(errPos))

    """------------------------------------------------------------------------------------------------------------
    //
    //        11.电子齿轮
    //
    //------------------------------------------------------------------------------------------------------------
    // 设置Gear跟随方向
    // dir：  0:双向跟随，<0负向跟随， >0正向跟随
    """

    def NMC_MtGearSetDir(axisHandle, dir):
        libc.NMC_MtGearSetDir.argtypes = [c_ushort, c_short]
        return libc.NMC_MtGearSetDir(axisHandle, dir)

    """ 获取Gear跟随方向
    // pDir：  0:双向跟随，<0负向跟随， >0正向跟随
    """

    def NMC_MtGearGetDir(axisHandle):
        dir_tmp = c_short()
        libc.NMC_MtGearGetDir.argtypes = [c_ushort, POINTER(c_short)]
        ret = libc.NMC_MtGearGetDir(axisHandle, byref(dir_tmp))
        return dir_tmp, ret

    """ 设置Gear主轴参数
    // axisHandle：从轴跟随轴号
    // masterNo：  主轴序列号（0~N）
    // masterType：  主轴类型  1:AXIS规划值  2：AXIS反馈值 3：编码器值
    """

    def NMC_MtGearSetMaster(axisHandle, masterNo, masterType):
        libc.NMC_MtGearSetMaster.argtypes = [c_ushort, c_short, c_short]
        return libc.NMC_MtGearSetMaster(axisHandle, masterNo, masterType)

    """ 获取Gear主轴参数
    // pMasterNo：  主轴序列号（0~N）
    // pMasterType：  主轴类型
    """

    def NMC_MtGearGetMaster(axisHandle):
        masterNo_tmp = c_short()
        masterType_tmp = c_short()
        libc.NMC_MtGearGetMaster.argtypes = [c_ushort, POINTER(c_short), POINTER(c_short)]
        ret = libc.NMC_MtGearGetMaster(axisHandle, byref(masterNo_tmp), byref(masterType_tmp))
        return masterNo_tmp, masterType_tmp, ret

    """ 设置Gear跟随倍率
    // axisHandle：从轴跟随轴号
    // masterEven： 传动比系数，主轴位移
    // slaveEven：  传动比系数，从轴位移
    // masterSlope：主轴离合区位移,必须大于0，同时不能等于1
    """

    def NMC_MtGearSetRatio(axisHandle, masterEven, slaveEven, masterSlope):
        libc.NMC_MtGearSetRatio.argtypes = [c_ushort, c_long, c_long, c_long]
        return libc.NMC_MtGearSetRatio(axisHandle, masterEven, slaveEven, masterSlope)

    """ 获取Gear跟随倍率
    // axisHandle：从轴跟随轴号
    // pMasterEven： 传动比系数，主轴位移
    // pSlaveEven：  传动比系数，从轴位移
    // pMasterSlope：主轴离合区位移,必须大于0，同时不能等于1
    """

    def NMC_MtGearGetRatio(axisHandle):
        masterEven_tmp = c_long()
        slaveEven_tmp = c_long()
        masterSlope_tmp = c_long()
        libc.NMC_MtGearGetRatio.argtypes = [c_ushort, POINTER(c_long), POINTER(c_long), POINTER(c_long)]
        ret = libc.NMC_MtGearGetRatio(axisHandle, byref(masterEven_tmp), byref(slaveEven_tmp), byref(masterSlope_tmp))
        return masterEven_tmp, slaveEven_tmp, masterSlope_tmp, ret

    """ 启动Gear运动
    // syncCount： 不包括axisHandle 的其他同步启动轴数量
    // pSyncAxisArray: 其他同步启动轴的序号：0~N	
    // 注：同步的轴必须属于同一个控制器
    """

    def NMC_MtGearStartMtn(axisHandle, syncAxCnts, syncAxArray):
        syncAxArray_tmp = (c_short * syncAxCnts)(*syncAxArray)
        libc.NMC_MtGearStartMtn.argtypes = [c_ushort, c_short, POINTER(c_short)]
        return libc.NMC_MtGearStartMtn(axisHandle, syncAxCnts, syncAxArray_tmp)

    """------------------------------------------------------------------------------------------------------------
    //
    //        12.电子凸轮
    //
    //------------------------------------------------------------------------------------------------------------
    // 设置FOLLOW跟随方向
    // dir：  0:双向跟随，<0负向跟随， >0正向跟随
    """

    def NMC_MtFollowSetDir(axisHandle, dir):
        libc.NMC_MtFollowSetDir.argtypes = [c_ushort, c_short]
        return libc.NMC_MtFollowSetDir(axisHandle, dir)

    """ 获取FOLLOW跟随方向
    // pDir：  0:双向跟随，<0负向跟随， >0正向跟随
    """

    def NMC_MtFollowGetDir(axisHandle):
        dir_tmp = c_short()
        libc.NMC_MtFollowGetDir.argtypes = [c_ushort, POINTER(c_short)]
        ret = libc.NMC_MtFollowGetDir(axisHandle, byref(dir_tmp))
        return dir_tmp, ret

    """ FOLLOW跟随的主轴类型
    PROFILE_FOLLOW_MASTER_NONE = 0	# 0:无效
    PROFILE_FOLLOW_MASTER_AXIS_PRF = 1 # 1:AXIS规划值
    PROFILE_FOLLOW_MASTER_AXIS_ENC = 2	# 2：AXIS反馈值
    PROFILE_FOLLOW_MASTER_ENC = 3 # 3：编码器值
    """
    """设置FOLLOW主轴参数
    // axisHandle：从轴跟随轴号
    // masterNo：  主轴序列号（0~N）
    // masterType：  主轴类型  见上面宏定
    """

    def NMC_MtFollowSetMaster(axisHandle, masterNo, masterType):
        libc.NMC_MtFollowSetMaster.argtypes = [c_ushort, c_short, c_short]
        return libc.NMC_MtFollowSetMaster(axisHandle, masterNo, masterType)

    """ 获取FOLLOW主轴参数
    // axisHandle：从轴跟随轴号
    // pMasterNo：  主轴序列号（0~N）
    // pMasterType：  主轴类型  见上面宏定义
    """

    def NMC_MtFollowGetMaster(axisHandle):
        masterNo_tmp = c_short()
        masterType_tmp = c_short()
        libc.NMC_MtFollowGetMaster.argtypes = [c_ushort, POINTER(c_short), POINTER(c_short)]
        ret = libc.NMC_MtFollowGetMaster(axisHandle, byref(masterNo_tmp), byref(masterType_tmp))
        return (masterNo_tmp, masterType_tmp, ret)

    """ 设置FOLLOW的循环执行次数
    // loopCnt：循环
    """

    def NMC_MtFollowSetLoopCount(axisHandle, loopCnt):
        libc.NMC_MtFollowSetLoopCount.argtypes = [c_ushort, c_long]
        return libc.NMC_MtFollowSetLoopCount(axisHandle, loopCnt)

    """ 获取FOLLOW的循环执行次数
    // pLoopCnt：循环
    """

    def NMC_MtFollowGetLoopCount(axisHandle):
        loopCnt_tmp = c_long()
        libc.NMC_MtFollowGetLoopCount.argtypes = [c_ushort, POINTER(c_long)]
        ret = libc.NMC_MtFollowGetLoopCount(axisHandle, byref(loopCnt_tmp))
        return loopCnt_tmp, ret

    """ FOLLOW跟随事件
    PROFILE_FOLLOW_EVENT_START = 1	# 立即启动
    PROFILE_FOLLOW_EVENT_PASS  = 2	# 主轴穿越设定位置以后启动跟随
    """
    """ 设置FOLLOW的的启动事件
    // eventType：1 表示调用启动指令以后	立即启动，2表示	主轴穿越设定位置以后启动跟随
    // masterDir:穿越启动时，主轴的运动方向，1 主轴正向运动，-1 主轴负向运动
    // pos:穿越位置
    """

    def NMC_MtFollowSetEvent(axisHandle, eventType, masterDir, pos):
        libc.NMC_MtFollowSetEvent.argtypes = [c_ushort, c_short, c_short, c_long]
        return libc.NMC_MtFollowSetEvent(axisHandle, eventType, masterDir, pos)

    """ 获取FOLLOW的启动事件
    // pEvent：1 表示调用启动指令以后立即启动，2表示主轴穿越设定位置以后启动跟随
    // pMasterDir:穿越启动时，主轴的运动方向，1 主轴正向运动，-1 主轴负向运动
    // pPos:穿越位置
    """

    def NMC_MtFollowGetEvent(axisHandle):
        pEvent_tmp = c_short()
        pMasterDir_tmp = c_short()
        pPos_tmp = c_long()
        libc.NMC_MtFollowGetEvent.argtypes = [c_ushort, POINTER(c_short), POINTER(c_short), POINTER(c_long)]
        ret = libc.NMC_MtFollowGetEvent(axisHandle, byref(pEvent_tmp), byref(pMasterDir_tmp), byref(pPos_tmp))
        return pEvent_tmp, pMasterDir_tmp, pPos_tmp, ret

    """ 获取FOLLOW的fifo剩余空间
    // pSpace：空间大小
    // fifoNo:fifo号，0或1
    """

    def NMC_MtFollowGetSpace(axisHandle, fifoNo):
        space_tmp = c_short()
        libc.NMC_MtFollowGetSpace.argtypes = [c_ushort, POINTER(c_short), c_short]
        ret = libc.NMC_MtFollowGetSpace(axisHandle, byref(space_tmp), fifoNo)
        return space_tmp, ret

    """ FOLLOW的段类型
    PROFILE_FOLLOW_SEGMENT_NORMAL = 0 # 0普通段
    PROFILE_FOLLOW_SEGMENT_EVEN = 1 # 1匀速段
    PROFILE_FOLLOW_SEGMENT_STOP = 2 # 2停止段
    PROFILE_FOLLOW_SEGMENT_CONTINUE = 3 # 3连续段
    """
    """ 设置FOLLOW的数据
    // masterPos：主轴位移
    // slavePos:从轴位移
    // type:数据段类型：0普通段，默认；1匀速段；2 减速到 0 段；3保持 FIFO 之间速度连续
    // fifoNo:fifo号，0或1
    """

    def NMC_MtFollowPushData(axisHandle, masterPos, slavePos, type, fifoNo):
        libc.NMC_MtFollowPushData.argtypes = [c_ushort, c_long, c_double, c_short, c_short]
        return libc.NMC_MtFollowPushData(axisHandle, masterPos, slavePos, type, fifoNo)

    """ 清除FOLLOW对应fifo号的数据
    // fifoNo:fifo号，0或1
    """

    def NMC_MtFollowClear(axisHandle, fifoNo):
        libc.NMC_MtFollowClear.argtypes = [c_ushort, c_short]
        return libc.NMC_MtFollowClear(axisHandle, fifoNo)

    """ 启动Follow运动
    // syncCount： 不包括axisHandle 的其他同步启动轴数量
    // pSyncAxisArray: 其他同步启动轴的序号：0~N	
    """

    def NMC_MtFollowStart(axisHandle, syncAxCnts, pSyncAxArray):
        pSyncAxArray_tmp = (c_short * syncAxCnts)(*pSyncAxArray)
        libc.NMC_MtFollowStart.argtypes = [c_ushort, c_short, POINTER(c_short)]
        return libc.NMC_MtFollowStart(axisHandle, syncAxCnts, pSyncAxArray_tmp)

    """ 切换Follow运动的fifo号
    // syncCount： 不包括axisHandle 的其他同步进行fifo切换的轴数量
    // pSyncAxisArray: 其他同步进行fifo切换的轴的序号：0~N	
    """

    def NMC_MtFollowSwitch(axisHandle, syncAxCnts, syncAxArray):
        syncAxArray_tmp = (c_short * syncAxCnts)(*syncAxArray)
        libc.NMC_MtFollowSwitch.argtypes = [c_ushort, c_short, POINTER(c_short)]
        return libc.NMC_MtFollowSwitch(axisHandle, syncAxCnts, syncAxArray_tmp)


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

    """ 
    // 启动Ethercat主站
    """
    def NMC_EcatStart(devHandle):
        libc.NMC_EcatStart.argtypes = [c_ushort]
        return libc.NMC_EcatStart(devHandle)

    """ 
    // 停止Ethercat主站
    """
    def NMC_EcatStop(devHandle):
        libc.NMC_EcatStop.argtypes = [c_ushort]
        return libc.NMC_EcatStop(devHandle)

    """ 获取当前在线的从站数量
    // pSlaveCnt:从站的总数
    // pDriverCnt:驱动器数量
    // pIoCnt:IO类型从站数量
    """
    def NMC_EcatGetResource(devHandle):
        SlaveCnt_tmp = c_short()
        DriverCnt_tmp = c_short()
        IoCnt_tmp = c_short()
        libc.NMC_EcatGetResource.argtypes = [c_ushort, POINTER(c_short),  POINTER(c_short),  POINTER(c_short)]
        ret = libc.NMC_EcatGetResource(devHandle,  byref(SlaveCnt_tmp),  byref(DriverCnt_tmp),  byref(IoCnt_tmp))
        return SlaveCnt_tmp, DriverCnt_tmp, IoCnt_tmp, ret

    """ 获取从站信息结构体"""
    class TEcatSlvInfo(Structure):
        _fields_ = [
            ("vendor_id", c_uint32),  # 厂商ID
            ("product_id", c_uint32),  # 设备ID
            ("devType", c_uint16),  # 设备类型：1：驱动器，2：IO，3：其他
            ("dcCode", c_uint16),   # DC码
            ("txPdoCnt", c_uint16),  # txPdo数量
            ("rxPdoCnt", c_uint16),  # rxPdo数量
            ("reserved", c_int16 * 4),  # 保留字段（4个 short）
        ]

        def __init__(self):
            super().__init__()
            self.vendor_id = 0
            self.product_id = 0
            self.devType = 0
            self.dcCode = 0
            self.txPdoCnt = 0
            self.rxPdoCnt = 0
            self.reserved = (c_int16 * 4)(0, 0, 0, 0)
    """
    // 获取从站信息
    """
    def NMC_EcatGetSaveInfoEx(devHandle, masterIdx, slvIdx, Info):
        libc.NMC_EcatGetSaveInfoEx.argtypes = [c_ushort,  c_short,  c_short,  POINTER(pymtn.TEcatSlvInfo)]
        ret = libc.NMC_EcatGetSaveInfoEx(devHandle,  masterIdx,  slvIdx,  byref(Info))
        return Info, ret

    """ 
    // 获取从站信息（用户下载的配置信息）
    """
    def NMC_EcatGetSaveInfoEx2(devHandle, masterIdx, slvIdx,Info):
        libc.NMC_EcatGetSaveInfoEx2.argtypes = [c_ushort, c_ushort, c_short, POINTER(pymtn.TEcatSlvInfo)]
        ret = libc.NMC_EcatGetSaveInfoEx2(devHandle,  masterIdx,  slvIdx,  byref(Info))
        return Info, ret

    """ 
    // 获取主站状态
    // pSts:返回状态码
    //        bit0-bit7:主站状态（取值：0x01,0x02,0x03,0x04,0x08）
    //                  0x01: INIT
    //                  0x02: PREOP
    //                  0x03: BOOT
    //                  0x04: SAFEOP
    //                  0x0: OP
    //        bit8-bit11:状态机步骤
    """
    def NMC_EcatGetSts(devHandle):
        Sts_tmp = c_ushort()
        libc.NMC_EcatGetSts.argtypes = [c_ushort, POINTER(c_ushort)]
        ret = libc.NMC_EcatGetSts(devHandle,  byref(Sts_tmp))
        return Sts_tmp, ret

    """ 
    // 设置从站驱动器的工作模式，用户一般不需要调用
    // mode: Control Mode : CSP:8 CSV:9  CST:10
    // axisHandle:轴句柄，通过NMC_MtOpen获取，ethercat从站轴的编号从16开始
    """
    def NMC_EcatAxisSetMode(axisHandle, mode):
        libc.NMC_EcatAxisSetMode.argtypes = [c_ushort,  c_uint8]
        return libc.NMC_EcatAxisSetMode(axisHandle,  mode)

    """ 
    // 获取从站驱动器的工作模式
    // axisHandle:轴句柄，通过NMC_MtOpen获取，ethercat从站轴的编号从16开始
    """
    def NMC_EcatAxisGetMode(axisHandle):
        Mode_tmp = c_uint8()
        libc.NMC_EcatAxisGetMode.argtypes = [c_ushort, POINTER(c_uint8)]
        ret = libc.NMC_EcatAxisGetMode(axisHandle,  byref(Mode_tmp))
        return Mode_tmp, ret

    """ 
    // 获取从站驱动器的错误代码
    // axisHandle:轴句柄，通过NMC_MtOpen获取，ethercat从站轴的编号从16开始
    """
    def NMC_EcatAxisGetErrorCode(axisHandle):
        Error_tmp = c_ushort()
        libc.NMC_EcatAxisGetErrorCode.argtypes = [c_ushort,  POINTER(c_ushort)]
        ret = libc.NMC_EcatAxisGetErrorCode(axisHandle,  byref(Error_tmp))
        return Error_tmp, ret

    """ 
    // 获取从站驱动器的数字量输入状态
    // axisHandle:轴句柄，通过NMC_MtOpen获取，ethercat从站轴的编号从16开始
    """
    def NMC_EcatAxisGetDi(axisHandle):
        DiVal_tmp = c_int32()
        libc.NMC_EcatAxisGetDi.argtypes = [c_ushort, POINTER(c_int32)]
        ret = libc.NMC_EcatAxisGetDi(axisHandle,  byref(DiVal_tmp))
        return DiVal_tmp, ret

    """ 
    // 获取从站驱动器的编码器
    """
    def NMC_EcatAxisGetEncPos(axisHandle):
        EncPos_tmp = c_int32()
        libc.NMC_EcatAxisGetEncPos.argtypes = [c_ushort,  POINTER(c_int32)]
        ret = libc.NMC_EcatAxisGetEncPos(axisHandle,  byref(EncPos_tmp))
        return EncPos_tmp, ret

    """ 
    // 启动回零，回零状态可以通过NMC_MtGetHomeSts查询
    // method:回零方式，根据标准，只支持402要求必须实现的，具体请参考驱动器相关的说明
    // velSwitch:找原点速度command/s
    // velZero:找index脉冲速度command/s
    // acc:加速度command/s^2
    // prmEx:保留
    // axisHandle:轴句柄，通过NMC_MtOpen获取，ethercat从站轴的编号从16开始
    """
    def NMC_EcatStartHome(axisHandle, method, velSwitch, velZero, acc, prmEx):
        libc.NMC_EcatStartHome.argtypes = [c_ushort,  c_int32,  c_double,  c_double,  c_double,  c_double]
        return libc.NMC_EcatStartHome(axisHandle,  method,  velSwitch,  velZero,  acc,  prmEx)

    """ 
    // 获取驱动器的回零状态
    // bit2    bit1    bit0
    // 0       0       0       回零中
    // 0       0       1       回零未开始
    // 0       1       0       回零中
    // 0       1       1       回零OK
    // 1       0       0       回零中，但是有错误发生
    // 1       0       1       回零错误终止
    """
    def NMC_EcatGetHomeSts(axisHandle):
        Status_tmp = c_uint8()
        libc.NMC_EcatGetHomeSts.argtypes = [c_ushort,  POINTER(c_uint8)]
        ret = libc.NMC_EcatGetHomeSts(axisHandle,  byref(Status_tmp))
        return Status_tmp, ret

    """ 
    // 终止回零 
    // axisHandle:轴句柄，通过NMC_MtOpen获取，ethercat从站轴的编号从16开始
    """
    def NMC_EcatStopHome(axisHandle):
        libc.NMC_EcatStopHome.argtypes = [c_ushort]
        return libc.NMC_EcatStopHome(axisHandle)

    """ Ethercat SDO 写
    // devId:从站号
    // idx:SDO的Index
    // sub_idx:SDO的SubIndex
    // len:数据长度
    // val:数据内容
    // abort_code:错误码
    """
    def NMC_EcatSdoWrite(devHandle, devId, idx,  sub_idx, len, val):
        val_tmp = (c_uint8 * len(val))(*val)
        abort_code_tmp = c_uint32()
        libc.NMC_EcatSdoWrite.argtypes = [c_ushort, c_short, c_ushort, c_uint8, c_uint32, POINTER(c_uint8),  POINTER(c_uint32)]
        ret = libc.NMC_EcatSdoWrite(devHandle,  devId,  idx,  sub_idx,  len,  val_tmp,  byref(abort_code_tmp))
        return abort_code_tmp, ret

    """ 
    // 下载Ethercat配置文件（配置文件通过配置工具生成）
    // gmlFileName:配置工具路径
    // masterIdx:主站序号，保留，写0
    """
    def NMC_EcatLoadConfigFromFile(devHandle, gmlFileName, masterIdx):
        gmlFileName_tmp = create_string_buffer(gmlFileName.encode('utf-8'))
        libc.NMC_EcatLoadConfigFromFile.argtypes = [c_ushort, c_char_p,  c_short]
        return libc.NMC_EcatLoadConfigFromFile(devHandle,  gmlFileName_tmp,  masterIdx)

    """ 
    // Ehercat:设置目标转矩，对应PDO序号0x6071
    // slv:从轴号，取值范围[0,n)
    // tgtTorque:目标转矩，参数范围及单位请参考对应的伺服驱动器手册
    """
    def NMC_EcatAxisTorqSetTgt(devHandle, slv, tgtTorque):
        libc.NMC_EcatAxisTorqSetTgt.argtypes = [c_ushort,  c_short,  c_int32]
        ret = libc.NMC_EcatAxisTorqSetTgt(devHandle,  slv,  tgtTorque)
        return ret

    def NMC_EcatAxisTorqGetTgt(devHandle, slv):
        tgtTorque_tmp = c_int32()
        libc.NMC_EcatAxisTorqSetTgt.argtypes = [c_ushort, c_short, POINTER(c_int32)]
        ret = libc.NMC_EcatAxisTorqSetTgt(devHandle,  slv,  byref(tgtTorque_tmp))
        return tgtTorque_tmp, ret

    """ 
    // Ehercat:设置最大转矩，对应PDO序号0x6072
    // slv:从轴号，取值范围[0,n)
    // maxTorque:最大转矩，参数范围及单位请参考对应的伺服驱动器手册
    """
    def NMC_EcatAxisTorqSetMax(devHandle, slv, maxTorque):
        libc.NMC_EcatAxisTorqSetMax.argtypes = [c_ushort, c_short, c_int32]
        return libc.NMC_EcatAxisTorqSetMax(devHandle, slv, maxTorque)

    def NMC_EcatAxisTorqGetMax(devHandle, slv):
        maxTorque_tmp = c_int32()
        libc.NMC_EcatAxisTorqSetMax.argtypes = [c_ushort, c_short, POINTER(c_int32)]
        ret = libc.NMC_EcatAxisTorqSetMax(devHandle, slv, byref(maxTorque_tmp))
        return maxTorque_tmp, ret

    """ 
    // Ehercat:设置转矩斜坡值，对应PDO序号0x6087
    // slv:从轴号，取值范围[0,n)
    // torqueSlope:转矩斜坡值，参数范围及单位请参考对应的伺服驱动器手册
    """
    def NMC_EcatAxisTorqSetSlope(devHandle, slv, torqueSlope):
        libc.NMC_EcatAxisTorqSetSlope.argtypes = [c_ushort,  c_short,  c_int32]
        return libc.NMC_EcatAxisTorqSetSlope(devHandle,  slv,  torqueSlope)

    def NMC_EcatAxisTorqGetSlope(devHandle, slv):
        torqueSlope_tmp = c_int32()
        libc.NMC_EcatAxisTorqSetMax.argtypes = [c_ushort, c_short, POINTER(c_int32)]
        ret = libc.NMC_EcatAxisTorqSetMax(devHandle, slv, byref(torqueSlope_tmp))
        return torqueSlope_tmp, ret

    """ 
    // Ehercat:设置转矩偏移值，对应PDO序号0x60B2
    // slv:从轴号，取值范围[0,n)
    // torqueOffset:转矩偏移值，参数范围及单位请参考对应的伺服驱动器手册
    """
    def NMC_EcatAxisTorqSetOffset(devHandle,slv, torqueOffset):
        libc.NMC_EcatAxisTorqSetOffset.argtypes = [c_ushort,  c_short,  c_int32]
        return libc.NMC_EcatAxisTorqSetOffset(devHandle,  slv,  torqueOffset)
    
    def NMC_EcatAxisTorqGetOffset(devHandle,slv):
        torqueOffset_tmp = c_int32()
        libc.NMC_EcatAxisTorqSetOffset.argtypes = [c_ushort,  c_short,  POINTER(c_int32)]
        ret = libc.NMC_EcatAxisTorqGetOffset(devHandle, slv, byref(torqueOffset_tmp))
        return torqueOffset_tmp, ret

    """ 
    // Ehercat:设置转矩正向的限定值，对应PDO序号0x60E0
    // slv:从轴号，取值范围[0,n)
    // torquePosLmt:转矩正向的限定值，参数范围及单位请参考对应的伺服驱动器手册
    """
    def NMC_EcatAxisTorqSetPosLmt(devHandle, slv, torquePosLmt):
        libc.NMC_EcatAxisTorqSetPosLmt.argtypes = [c_ushort,  c_short,  c_int32]
        return libc.NMC_EcatAxisTorqSetPosLmt(devHandle,  slv,  torquePosLmt)

    def NMC_EcatAxisTorqGetPosLmt(devHandle, slv):
        torquePosLmt_tmp = c_int32()
        libc.NMC_EcatAxisTorqSetPosLmt.argtypes = [c_ushort,  c_short,   POINTER(c_int32)]
        ret = libc.NMC_EcatAxisTorqGetOffset(devHandle, slv, byref(torquePosLmt_tmp))
        return torquePosLmt_tmp, ret

    """ 
    // Ehercat:设置转矩负向的限定值，对应PDO序号0x60E1
    // slv:从轴号，取值范围[0,n)
    // torquePosLmt:转矩负向的限定值，参数范围及单位请参考对应的伺服驱动器手册
    """
    def NMC_EcatAxisTorqSetNegLmt(devHandle, slv, torqueNegLmt):
        libc.NMC_EcatAxisTorqSetNegLmt.argtypes = [c_ushort,  c_short,  c_int32]
        return libc.NMC_EcatAxisTorqSetNegLmt(devHandle,  slv,  torqueNegLmt)

    def NMC_EcatAxisTorqGetNegLmt(devHandle, slv):
        torqueNegLmt_tmp = c_int32()
        libc.NMC_EcatAxisTorqSetPosLmt.argtypes = [c_ushort,  c_short,   POINTER(c_int32)]
        ret = libc.NMC_EcatAxisTorqGetOffset(devHandle, slv, byref(torqueNegLmt_tmp))
        return torqueNegLmt_tmp, ret

    """ 
    // Ehercat:设置伺服的最大电机速度，对应PDO序号0x6080
    // slv:从轴号，取值范围[0,n)
    // maxMotorVel:最大电机速度，参数范围及单位请参考对应的伺服驱动器手册
    """
    def NMC_EcatAxisSetMaxMotorVel(devHandle, slv, maxMotorVel):
        libc.NMC_EcatAxisSetMaxMotorVel.argtypes = [c_ushort,  c_short,  c_int32]
        return libc.NMC_EcatAxisSetMaxMotorVel(devHandle,  slv,  maxMotorVel)

    def NMC_EcatAxisGetMaxMotorVel(devHandle, slv):
        maxMotorVel_tmp = c_int32()
        libc.NMC_EcatAxisTorqSetPosLmt.argtypes = [c_ushort, c_short, POINTER(c_int32)]
        ret = libc.NMC_EcatAxisTorqGetOffset(devHandle, slv, byref(maxMotorVel_tmp))
        return maxMotorVel_tmp, ret
    """ 
    // Ehercat:设置伺服的最大规划速度，对应PDO序号0x607F
    // slv:从轴号，取值范围[0,n)
    // maxPrfVel:最大规划速度，参数范围及单位请参考对应的伺服驱动器手册
    """
    def NMC_EcatAxisSetMaxPrfVel(devHandle, slv, maxPrfVel):
        libc.NMC_EcatAxisSetMaxPrfVel.argtypes = [c_ushort,  c_short,  c_int32]
        return libc.NMC_EcatAxisSetMaxPrfVel(devHandle,  slv,  maxPrfVel)

    def NMC_EcatAxisGetMaxPrfVel(devHandle, slv):
        maxPrfVel_tmp = c_int32()
        libc.NMC_EcatAxisTorqSetPosLmt.argtypes = [c_ushort, c_short, POINTER(c_int32)]
        ret = libc.NMC_EcatAxisTorqGetOffset(devHandle, slv, byref(maxPrfVel_tmp))
        return maxPrfVel_tmp, ret

    """
    ///******************************************************************
    //
    // Moudle Name  :   mtn_lib20_ext.h
    // Abstract     :   GaoChuan Motion 2.0 external user header 
    // Note :			1.结构体定义中所有的‘reservedxxx’的成员都是保留参数,为保持兼容性,请设置为0
    //					2.无特别说明,所有API返回RTN_CMD_SUCCESS（即0值）表示执行成功,其他则表示错误代码
    //					3.所有的API参数中,无特别说明,axisHandle表示操作轴的句柄,devHandle表示目标控制器的句柄,crdHandle表示目标坐标系组句柄
    //                  4.mtn_lib20中所有的结构体都是以四字节对齐方式编译，为了避免结构体对齐引起的问题，请将编译环境设置为四字节对齐
    // Modification History :
    ///******************************************************************
    """
    """
    //------------------------------------------------------------------------------------------------------------
    //
    //           指令分组索引
    //
    //------------------------------------------------------------------------------------------------------------
    //	1.设备高级配置等
    //	2.单轴配置读取
    //	3.单轴高级指令
    //	4.缓冲区高级指令
    //	5.硬件捕获及不常用指令
    //	6.平台相关指令
    //	7.数据采集模块(高级指令)
    //	8.激光
    //	9.龙门
    //  10.通讯扩展等其他
    //  11.手轮
    //  12.PT
    //  13.线性距离位置比较
    //  14.二维位置点比较
    //  15.多维位置比较输出
    //  16.坐标系输出转换
    //  17.结构体初始化函数及常见习惯指令
    //  18.闭环
    //  19.高级BufIo输出配置及控制
    //  20.模拟量控制
    //  21.scara
    //  22.坐标系干涉保护指令
    //  23.不常用指令
    //  24.自动状态返回
    //  25 : 点位自动收发
    //  26 : 高速一维位置比较
    //  27 ：带count及clock
    ///////////////////////////////////////////////////////////////////指令
    //------------------------------------------------------------------------------------------------------------
    //
    //	1.设备高级配置等
    //
    //------------------------------------------------------------------------------------------------------------
    
    // 设置通讯参数
    // devHandle : 设备句柄
    // waitTimeInUs：等待时间,微秒
    // retryTimes： 通讯重试次数
    """
    def NMC_SetCommPara(devHandle, waitTimeInUs, retryTimes ):
        libc.NMC_SetCommPara.argtypes = [c_ushort,  c_ulong,  c_ulong]
        ret = libc.NMC_SetCommPara(devHandle,  waitTimeInUs,  retryTimes )
        return ret

    """ 
    // 板卡打开（根据名称）
    // idStr: 板卡ID字符串, 可通过指令写入。pDevHandle: 返回设备操作句柄
    // 注：ID号用户可写入,掉电不丢失,可用于区分板卡。出厂板卡号ID号为0
    """
    def NMC_DevOpenByID(idStr):
        idStr_tmp = create_string_buffer(idStr.encode('utf-8'), 32)
        devHandle_tmp = c_ushort()
        libc.NMC_DevOpenByID.argtypes = [c_char_p,  POINTER(c_ushort)]
        ret = libc.NMC_DevOpenByID(idStr_tmp,  byref(devHandle_tmp))
        return devHandle_tmp, ret

    """ 
    // 板卡打开（根据IP地址）
    // pIPv4Array: 板卡IP地址,四个字节,例如：unsinged char ipv4[4] = {192,168,1,110};
    // pDevHandle: 返回设备操作句柄
    """
    def NMC_DevOpenByIP(ip_list):
        IPv4Array_tmp = (c_ubyte * 4)(*ip_list)
        devHandle_tmp = c_ushort()
        libc.NMC_DevOpenByIP.argtypes = [POINTER(c_ubyte),  POINTER(c_ushort)]
        ret = libc.NMC_DevOpenByIP(IPv4Array_tmp, byref(devHandle_tmp))
        return devHandle_tmp, ret

    """ 
    // 修改板卡ID号
    // pIdStr: 要写入的板卡ID字符串,最长16字节,以\0结尾
    // 注：修改ID号完成后,板卡要掉电重启,新的ID才有效。
    """
    def NMC_DevWriteID(devHandle, IdStr):
        IdStr_tmp = create_string_buffer(IdStr.encode('utf-8'), 16)
        libc.NMC_DevWriteID.argtypes = [c_ushort,  c_char_p]
        ret = libc.NMC_DevWriteID(devHandle,  IdStr_tmp)
        return ret

    """ 
    // 读取板卡ID号
    // pIdStr: 存储字符串的数组,数组长度大于16字节
    """
    def NMC_DevReadID(devHandle):
        IdStr_tmp = create_string_buffer(16)
        libc.NMC_DevReadID.argtypes = [c_ushort,  c_char_p]
        ret = libc.NMC_DevReadID(devHandle,  IdStr_tmp)
        id_bytes = bytes(IdStr_tmp)
        id_str = id_bytes.split(b'\x00')[0].decode('utf-8')
        return id_str, ret

    """ 
    // 读取库的版本
    // pVersion：接收版本信息
    // example(c):
    //          char dllVersion[128];
    //          NMC_GetDllVersion(dllVersion);
    """
    def NMC_GetDllVersion():
        IdStr_tmp = create_string_buffer(128)
        libc.NMC_GetDllVersion.argtypes = [c_char_p]
        ret = libc.NMC_GetDllVersion(IdStr_tmp)
        Version_bytes = bytes(IdStr_tmp)
        Version_str = Version_bytes.split(b'\x00')[0].decode('utf-8')
        return Version_str, ret

    """
     // 当前运动控制器固件的版本等信息
    """
    class TMtLibVersion(Structure):
        _fields_ = [
            ("strVer", c_char * 16),  # 主版本号 (16字节)
            ("strOemVer", c_char * 16),  # OEM版本号 (16字节)
            ("strBuild", c_char * 32)  # 构建版本号 (32字节)
        ]

    """
    // 读取当前运动控制器固件的版本等信息
    // devHandle : 设备句柄
    // pVersion：版本信息
    """
    def NMC_GetMtLibVersion (devHandle, Version):
        libc.NMC_GetMtLibVersion.argtypes = [c_ushort,  POINTER(pymtn.TMtLibVersion)]
        ret = libc.NMC_GetMtLibVersion(devHandle,  byref(Version))
        return Version, ret


    """运动控制器信息"""
    class TCardInfo(Structure):
        _fields_ = [("strVer", c_char * 16),     # 控制器版本号
                    ("strOemVer", c_char * 16),  # OEM版本号(定制控制器才有),默认为0
                    ("time", c_short * 6),       # 时间,年月日,时分秒
                    ("axisNum", c_short),        # 支持的轴数
                    ("encNum", c_short),         # 支持的编码器数
                    ("diNum", c_short),          # 数字输入数量
                    ("doNum", c_short),          # 数字输出数量
                    ("daNum", c_short),          # 模拟量通道
                    ("adNum", c_short),          # 模拟量输入通道
                    ("shioNum", c_short),        # 同步高速IO通道
                    ("address", c_short),        # 控制器的拨码地址
                    ("ipv4", c_char * 4),        # IP地址
                    ("idStr", c_char * 16),      # 板卡名称,多卡时可用名称打开参考NMC_DevOpenByID
                    ("uid", c_uint32 * 4)]           # 唯一序列号

    # 读取当前运动控制器信息
    def NMC_GetCardInfo (devHandle):
        info_tmp = pymtn.TCardInfo()
        libc.NMC_GetCardInfo.argtypes = [c_ushort,  POINTER(pymtn.TCardInfo)]
        ret = libc.NMC_GetCardInfo(devHandle,  byref(info_tmp))

        class CardInfo:
            def __init__(self):
                self.strVer = ""
                self.strOemVer = ""
                self.time = []
                self.axisNum = 0
                self.encNum = 0
                self.diNum = 0
                self.doNum = 0
                self.daNum = 0
                self.adNum = 0
                self.shioNum = 0
                self.address = 0
                self.ipv4 = ""
                self.idStr = ""
                self.uid = []

        cardinfolist = []
        if ret == 0:
            # 创建Python对象并转换数据
            card_info = CardInfo()
            card_info.strVer = bytes(info_tmp.strVer).split(b'\x00')[0].decode('ascii')
            card_info.strOemVer = bytes(info_tmp.strOemVer).split(b'\x00')[0].decode('ascii')

            # 转换时间数组
            card_info.time = [info_tmp.time[i] for i in range(6)]

            card_info.axisNum = info_tmp.axisNum
            card_info.encNum = info_tmp.encNum
            card_info.diNum = info_tmp.diNum
            card_info.doNum = info_tmp.doNum
            card_info.daNum = info_tmp.daNum
            card_info.adNum = info_tmp.adNum
            card_info.shioNum = info_tmp.shioNum
            card_info.address = info_tmp.address

            # 转换IP地址
            card_info.ipv4 = '.'.join(str(b) for b in info_tmp.ipv4)

            card_info.idStr = bytes(info_tmp.idStr).split(b'\x00')[0].decode('ascii')

            # 转换UID数组
            card_info.uid = [info_tmp.uid[i] for i in range(4)]

            cardinfolist.append(card_info)
            return (cardinfolist[0], ret)
        else:
            return ([], ret)

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

    # 读取当前运动控制器信息
    def NMC_GetCardInfoEx (devHandle, Info):
        libc.NMC_GetCardInfoEx.argtypes = [c_ushort,  POINTER(pymtn.TCardInfo)]
        ret = libc.NMC_GetCardInfoEx(devHandle,  byref(Info))
        return ret

    # 检查PCIe卡的驱动顺序是否正常
    # instCardNum: 返回系统安装的卡数量
    # 返回0表示安装顺序正常，返回1表示不正常，通常为刚安装完驱动或者硬件有更改，重启windows即可
    def NMC_DevIndexCheck():
        instCardNum_tmp = c_int()
        libc.NMC_DevIndexCheck.argtypes = [POINTER(c_int)]
        ret = libc.NMC_DevIndexCheck(byref(instCardNum_tmp))
        return instCardNum_tmp.value, ret

    """ 
    // 启动指令调试
    // enable:0关闭调试信息,默认关闭,1:打开通讯的debug输出；2:打印到文件；3：打印输出到GCS
    // debugOutputFile:调试输出文件，仅在enable=2时需要
    """
    def NMC_SetCmdDebug(enable, debugOutputFile):
        debugOutputFile_tmp = create_string_buffer(debugOutputFile.encode('utf-8'), 260)
        libc.NMC_SetCmdDebug.argtypes = [c_short,  c_char_p]
        ret = libc.NMC_SetCmdDebug(enable,  debugOutputFile_tmp)
        return ret

    """ 
    // 获取错误代码信息
    // errCode:错误代码
    // errDesc:返回的错误代码描述
    """
    def NMC_GetErrDesc(errCode):
        errDesc_tmp = create_string_buffer(256)
        libc.NMC_GetErrDesc.argtypes = [c_short,  c_char_p]
        ret = libc.NMC_GetErrDesc(errCode,  errDesc_tmp)
        errDesc_bytes = bytes(errDesc_tmp)
        errDesc_str = errDesc_bytes.split(b'\x00')[0].decode('gbk')
        return errDesc_str, ret

    """ 
    // 加载配置文件
    """
    def NMC_LoadConfigFromFile(devHandle, FilePath):
        FilePath_tmp = create_string_buffer(FilePath.encode('utf-8'))
        libc.NMC_LoadConfigFromFile.argtypes = [c_ushort,  c_char_p]
        ret = libc.NMC_LoadConfigFromFile(devHandle,  FilePath_tmp)
        return ret

    """ 
    // 保存为配置文件
    """
    def NMC_SaveConfigToFile(devHandle, FilePath):
        FilePath_tmp = create_string_buffer(FilePath.encode('utf-8'))
        libc.NMC_SaveConfigToFile.argtypes = [c_ushort,  c_char_p]
        ret = libc.NMC_SaveConfigToFile(devHandle,  FilePath_tmp)
        return ret

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

    """ 
    // 获取平台版本号
    """
    def NMC_GetVersion(devHandle):
        verArray_tmp = (c_ubyte * 40)()
        libc.NMC_GetVersion.argtypes = [c_ushort,  POINTER(c_ubyte)]
        ret = libc.NMC_GetVersion(devHandle,  cast(verArray_tmp, POINTER(c_ubyte)))
        version_bytes = bytes(verArray_tmp)
        version_numbers = list(version_bytes)
        version_str = ':'.join(str(num) for num in version_numbers if num != 0)
        return version_str, ret

    """ 
    // 获取控制器功能信息 example : char flags[1024];NMC_DevGetMcInfoFlag(g_hDev,flags);
    """
    def NMC_DevGetMcInfoFlag(devHandle):
        flags_tmp = create_string_buffer(1024)
        libc.NMC_DevGetMcInfoFlag.argtypes = [c_ushort,  c_char_p]
        ret = libc.NMC_DevGetMcInfoFlag(devHandle,  flags_tmp)
        flags_bytes = bytes(flags_tmp)
        flags_bytes = flags_bytes.split(b'\x00')[0]
        flags_str = ' '.join(f'{b:02x}' for b in flags_bytes)
        return flags_str, ret


    """------------------------------------------------------------------------------------------------------------
    //
    //	2.单轴配置读写
    //
    //------------------------------------------------------------------------------------------------------------
    """
    """ 
    // 获取Ptp参数
    // pAxPara：参数
    """
    def NMC_MtGetPtpPara(axisHandle, AxPara):
        libc.NMC_MtGetPtpPara.argtypes = [c_ushort,  POINTER(pymtn.TPtpPara)]
        ret = libc.NMC_MtGetPtpPara(axisHandle, byref(AxPara))
        return AxPara, ret

    """ 
    // 获取Jog参数
    // pAxPara：参数
    """
    def NMC_MtGetJogPara (axisHandle, AxPara ):
        libc.NMC_MtGetJogPara.argtypes = [c_ushort,  POINTER(pymtn.TJogPara)]
        ret = libc.NMC_MtGetJogPara(axisHandle,  byref(AxPara))
        return AxPara, ret

    """ 
    // 获取目标运动速度
    // pVel: 目标速度（最大速度）,单位是 脉冲/ms
    """
    def NMC_MtGetVel(axisHandle):
        Vel_tmp = c_double()
        libc.NMC_MtGetVel.argtypes = [c_ushort, POINTER(c_double)]
        ret = libc.NMC_MtGetVel(axisHandle,  byref(Vel_tmp))
        return Vel_tmp, ret

    """ 
    // 获取目标运动位置,只针对PTP
    // pPos: 目标位置,单位是 脉冲
    """
    def NMC_MtGetPtpTgtPos( axisHandle):
        Pos_tmp = c_long()
        libc.NMC_MtGetPtpTgtPos.argtypes = [c_ushort,  POINTER(c_long)]
        ret = libc.NMC_MtGetPtpTgtPos(axisHandle,  byref(Pos_tmp))
        return Pos_tmp, ret

    """ 
    // 读编码器通道位置
    // devHandle : 控制器句柄
    // encId: 编码器ID,取值范围[0,n]
    // pPos:返回编码器数值
    """
    def NMC_GetEncPos(devHandle, encId):
        Pos_tmp = c_long()
        libc.NMC_GetEncPos.argtypes = [c_ushort,  c_short,  POINTER(c_long)]
        ret = libc.NMC_GetEncPos(devHandle,  encId,  byref(Pos_tmp))
        return Pos_tmp, ret

    """ 
    // 写编码器通道位置
    // devHandle : 控制器句柄
    // encId: 编码器ID,对于轴编码器通道,取值范围[0,n]
    //				  对于扩展编码器通道,256表示第一个扩展编码器通道,257表示第二个,以此类推
    // encPos:编码器数值
    """
    def NMC_SetEncPos(devHandle, encId, encPos ):
        libc.NMC_SetEncPos.argtypes = [c_ushort,  c_short,  c_long]
        return libc.NMC_SetEncPos(devHandle,  encId,  encPos)

    """ 
    // 设置允许的位置误差,当位置误差超过设定值时,电机停止运动,提示位置误差超限
    // posErr为0表示不检查
    """
    def NMC_MtSetPosErrLmt(axisHandle, posErr):
        libc.NMC_MtSetPosErrLmt.argtypes = [c_ushort,  c_long]
        return libc.NMC_MtSetPosErrLmt(axisHandle,  posErr)

    """ 
    // 读取允许的位置误差设定值
    """
    def NMC_MtGetPosErrLmt(axisHandle):
        PosErr_tmp = c_long()
        libc.NMC_MtGetPosErrLmt.argtypes = [c_ushort, POINTER(c_long)]
        ret = libc.NMC_MtGetPosErrLmt(axisHandle,  byref(PosErr_tmp))
        return PosErr_tmp, ret

    """ 
    // 读取限位开关输入是否停止运动
    // posEn：正向限位触发允许设置,1为允许,0为禁止
    // negEn: 负向限位触发允许设置
    """
    def NMC_MtGetLmtOnOff(axisHandle):
        PosSwt_tmp = c_short()
        NegSwt_tmp = c_short()
        libc.NMC_MtGetLmtOnOff.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_short)]
        ret = libc.NMC_MtGetLmtOnOff(axisHandle,  byref(PosSwt_tmp),  byref(NegSwt_tmp))
        return PosSwt_tmp, NegSwt_tmp, ret

    """ 
    // 读取限位开关触发电平
    // posSwt：正向限位触发电平设置,1为高电平触发,0为低电平触发
    // negSwt: 负向限位触发电平设置
    """
    def NMC_MtGetLmtSns(axisHandle):
        PosSwt_tmp = c_short()
        NegSwt_tmp = c_short()
        libc.NMC_MtGetLmtSns.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_short)]
        ret = libc.NMC_MtGetLmtSns(axisHandle,  byref(PosSwt_tmp),  byref(NegSwt_tmp))
        return PosSwt_tmp, NegSwt_tmp, ret

    """ 
    // 读取伺服报警开关是否停止运动
    // swt：伺服报警开关输入允许设置,1为允许,0为禁止。（默认为高电平触发）
    """
    def NMC_MtGetAlarmOnOff(axisHandle):
        Swt_tmp = c_short()
        libc.NMC_MtGetAlarmOnOff.argtypes = [c_ushort,  POINTER(c_short)]
        ret = libc.NMC_MtGetAlarmOnOff(axisHandle,  byref(Swt_tmp))
        return Swt_tmp, ret

    """ 
    // 读取伺服报警开关电平
    // swt：伺服报警触发电平设置,1为高电平触发,0为低电平触发
    """
    def NMC_MtGetAlarmSns(axisHandle):
        Swt_tmp = c_short()
        libc.NMC_MtGetAlarmSns.argtypes = [c_ushort,  POINTER(c_short)]
        ret = libc.NMC_MtGetAlarmSns(axisHandle,  byref(Swt_tmp))
        return Swt_tmp, ret

    """ 
    // 读取软件限位是否停止运动
    // enable：软件限位触发允许设置,1为允许,0为禁止
    """
    def NMC_MtGetSwLmtOnOff(axisHandle):
        Swt_tmp = c_short()
        libc.NMC_MtGetSwLmtOnOff.argtypes = [c_ushort,  POINTER(c_short)]
        ret = libc.NMC_MtGetSwLmtOnOff(axisHandle,  byref(Swt_tmp))
        return Swt_tmp, ret

    """ 
    // 读取软件限位数值
    // posLmt：正向软件限位设置值
    // negLmt：负向软件限位设置值。单位为脉冲数
    """
    def NMC_MtGetSwLmtValue(axisHandle):
        PosLmt_tmp = c_long()
        NegLmt_tmp = c_long()
        libc.NMC_MtGetSwLmtValue.argtypes = [c_ushort,  POINTER(c_long),  POINTER(c_long)]
        ret = libc.NMC_MtGetSwLmtValue(axisHandle,  byref(PosLmt_tmp),  byref(NegLmt_tmp))
        return PosLmt_tmp, NegLmt_tmp, ret

    """  
    // 读取轴安全参数
    """
    def NMC_MtGetSafePara(axisHandle, Para):
        libc.NMC_MtGetSafePara.argtypes = [c_ushort,  POINTER(pymtn.TSafePara)]
        ret = libc.NMC_MtGetSafePara(axisHandle,  byref(Para))
        return Para, ret

    """ 
    // 读取脉冲输出模式
    // pInv, 1：取反,0：不取反
    // pMode 0：脉冲方向 1：正负脉冲
    """
    def NMC_MtGetStepMode(axisHandle):
        Inv_tmp = c_short()
        Mode_tmp = c_short()
        libc.NMC_MtGetStepMode.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_short)]
        ret = libc.NMC_MtGetStepMode(axisHandle,  byref(Inv_tmp),  byref(Mode_tmp))
        return Inv_tmp, Mode_tmp, ret

    """ 
    // 读取轴速度滤波参数
    """
    def NMC_MtGetAxisVelFilter(axisHandle):
        FilterCoef_tmp = c_short()
        libc.NMC_MtGetAxisVelFilter.argtypes = [c_ushort,  POINTER(c_short)]
        ret = libc.NMC_MtGetAxisVelFilter(axisHandle,  byref(FilterCoef_tmp))
        return FilterCoef_tmp, ret

    """ 
    // 读取回零参数
    // pHomePara: 回零参数结构,参考结构定义
    """
    def NMC_MtGetHomePara(axisHandle, HomePara ):
        libc.NMC_MtGetHomePara.argtypes = [c_ushort, POINTER(pymtn.THomeSetting)]
        ret = libc.NMC_MtGetHomePara(axisHandle,  byref(HomePara))
        return HomePara, ret

    """------------------------------------------------------------------------------------------------------------
    //
    //	3.单轴高级指令
    //
    //------------------------------------------------------------------------------------------------------------
    """
    """
    // 读取机械坐标的位置
    // pPos : 返回位置,单位是 脉冲
    """
    def NMC_MtGetAxisPos(axisHandle):
        Pos_tmp = c_long()
        libc.NMC_MtGetAxisPos.argtypes = [c_ushort,  POINTER(c_long)]
        ret = libc.NMC_MtGetAxisPos(axisHandle,  byref(Pos_tmp))
        return Pos_tmp, ret

    """ 
    // 读发送到执行器的位置
    // pPos : 返回位置,单位是 脉冲
    """
    def NMC_MtGetCmdPos(axisHandle):
        Pos_tmp = c_long()
        libc.NMC_MtGetCmdPos.argtypes = [c_ushort, POINTER(c_long)]
        ret = libc.NMC_MtGetCmdPos(axisHandle,  byref(Pos_tmp))
        return Pos_tmp, ret

    """ 
    // 设定机械位置, 轴静止时执行,如果后面是update指令,需要延时一个周期
    // axisPos: 设定机械位置值
    // 注：只能在轴静止时使用
    """
    def NMC_MtSetAxisPos(axisHandle,  axisPos):
        libc.NMC_MtSetAxisPos.argtypes = [c_ushort,  c_long]
        return libc.NMC_MtSetAxisPos(axisHandle,  axisPos)

    """ 
    // 设定编码器位置, 轴静止时执行,如果后面是update指令,需要延时一个周期
    // encPos: 设定编码器位置值
    // 注：只能在轴静止时使用
    """
    def NMC_MtSetEncPos(axisHandle, encPos):
        libc.NMC_MtSetEncPos.argtypes = [c_ushort,  c_long]
        return libc.NMC_MtSetEncPos(axisHandle,  encPos)

    """ 设置单轴规划高级参数
    // axisHandle : 轴句柄
    // mapAxisNo：轴号,取值范围[0,n]
    // port：端口号,取值范围[0,1],默认为0
    // startPos：偏置,默认为0
    // pCrdHandle：坐标系组句柄
    """
    def NMC_MtPrfConfig(axisHandle, mapAxisNo, port, startPos):
        libc.NMC_MtPrfConfig.argtypes = [c_ushort,  c_short,  c_short,  c_long]
        return libc.NMC_MtPrfConfig(axisHandle,  mapAxisNo,  port,  startPos)

    """ 
    // 读取单轴规划高级参数
    """
    def NMC_MtGetPrfConfig(axisHandle):
        mapAxisNo_tmp = c_short()
        port_tmp = c_short()
        startPos_tmp = c_long()
        libc.NMC_MtGetPrfConfig.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_short),  POINTER(c_long)]
        ret = libc.NMC_MtGetPrfConfig(axisHandle,  byref(mapAxisNo_tmp),  byref(port_tmp),  byref(startPos_tmp))
        return mapAxisNo_tmp, port_tmp, startPos_tmp, ret

    """ 
    // 设置单轴比例系数
    // axisHandle : 轴句柄
    // inCoe：单轴比例系数,取值范围(0,1]
    """
    def NMC_MtSetPrfCoe(axisHandle, inCoe):
        libc.NMC_MtSetPrfCoe.argtypes = [c_ushort,  c_double]
        return libc.NMC_MtSetPrfCoe(axisHandle,  inCoe)

    """ 
    // 读取单轴比例系数
    // axisHandle : 轴句柄
    // pInCoe：单轴比例系数,取值范围(0,1]
    """
    def NMC_MtGetPrfCoe(axisHandle):
        InCoe_tmp = c_double()
        libc.NMC_MtGetPrfCoe.argtypes = [c_ushort,  POINTER(c_double)]
        ret = libc.NMC_MtGetPrfCoe(axisHandle,  byref(InCoe_tmp))
        return InCoe_tmp, ret

    """ 
    // 设置轴通道编码器的系数,默认为1
    // axisHandle : 轴句柄
    // encCoe：单轴通道编码器比例系数,取值范围(0,1]
    """
    def NMC_MtSetEncCoe(axisHandle, encCoe):
        libc.NMC_MtSetEncCoe.argtypes = [c_ushort,  c_double]
        return libc.NMC_MtSetEncCoe(axisHandle,  encCoe)

    """ 
    // 读取轴通道编码器的系数
    // axisHandle : 轴句柄
    // pEncCoe：比例系数,取值范围(0,1]
    """
    def NMC_MtGetEncCoe(axisHandle):
        EncCoe_tmp = c_double()
        libc.NMC_MtGetEncCoe.argtypes = [c_ushort, POINTER(c_double)]
        ret = libc.NMC_MtGetEncCoe(axisHandle,  byref(EncCoe_tmp))
        return EncCoe_tmp, ret

    """ 
    // 设置轴的到位误差参数
    // axisHandle : 轴句柄
    // arrivalBand: 到位误差,单位Pulse 取值大于0
    // stableTime: 到位保持时间,单位 ms 取值大于0
    """
    def NMC_MtSetAxisArrivalPara(axisHandle, arrivalBand, stableTime):
        libc.NMC_MtSetAxisArrivalPara.argtypes = [c_ushort,  c_long,  c_long]
        ret = libc.NMC_MtSetAxisArrivalPara(axisHandle,  arrivalBand,  stableTime)
        return ret

    """ 
    // 获取轴的到位误差参数
    // axisHandle : 轴句柄
    // pArrivalBand:到位误差,单位Pulse 
    // pStableTime：到位保持时间,单位 ms
    """
    def NMC_MtGetAxisArrivalPara(axisHandle):
        ArrivalBand_tmp = c_long()
        StableTime_tmp = c_long()
        libc.NMC_MtGetAxisArrivalPara.argtypes = [c_ushort,  POINTER(c_long),  POINTER(c_long)]
        ret = libc.NMC_MtGetAxisArrivalPara(axisHandle,  byref(ArrivalBand_tmp),  byref(StableTime_tmp))
        return ArrivalBand_tmp, StableTime_tmp, ret

    """ 
    // 设置螺距误差补偿参数
    // num：补偿的段数,取值范围[2,128]
    // startPos：补偿起始位置，终止位置为 startPos + cmpLen
    // cmpLen:补偿长度
    // pCompPos:正向补偿值
    // pCompNeg:负向补偿值
    """
    def NMC_MtSetLeadScrewCompPara(axisHandle, num, startPos, cmpLen, CompPos, CompNeg):
        CompPos_tmp = (c_short * num)(*CompPos)
        CompNeg_tmp = (c_short * num)(*CompNeg)
        libc.NMC_MtSetLeadScrewCompPara.argtypes = [c_ushort,  c_short,  c_long,  c_long,  POINTER(c_short),  POINTER(c_short)]
        ret = libc.NMC_MtSetLeadScrewCompPara(axisHandle,  num,  startPos,  cmpLen,  CompPos_tmp,  CompNeg_tmp)
        return ret

    """ 
    // 使能或禁止螺距位置补偿
    """
    def NMC_MtEnableLeadScrew(axisHandle, enable):
        libc.NMC_MtEnableLeadScrew.argtypes = [c_ushort,  c_short]
        return libc.NMC_MtEnableLeadScrew(axisHandle,  enable)

    """ 
    // 设置反向间隙补偿
    // compValue： 补偿量
    // compDelta： 周期补偿量，比如补偿量为100，周期补偿量为10，则反向补偿会在10个规划周期完成100个脉冲的补偿
    // compDir：	 补偿方向,0:正向补偿，1：负向补偿
    """
    def NMC_MtSetBacklash(axisHandle, compValue, compDelta,compDir):
        libc.NMC_MtSetBacklash.argtypes = [c_ushort,  c_long,  c_double,  c_long]
        return libc.NMC_MtSetBacklash(axisHandle,  compValue,  compDelta,  compDir)

    """ 
    // 获取反向间隙补偿
    """
    def NMC_MtGetBacklash(axisHandle):
        CompValue_tmp = c_long()
        CompDelta_tmp = c_double()
        CompDir_tmp = c_long()
        libc.NMC_MtGetBacklash.argtypes = [c_ushort,  POINTER(c_long),  POINTER(c_double),  POINTER(c_long)]
        ret = libc.NMC_MtGetBacklash(axisHandle,  byref(CompValue_tmp),  byref(CompDelta_tmp),  byref(CompDir_tmp))
        return CompValue_tmp, CompDelta_tmp, CompDir_tmp, ret

    """ 
    // 设置单轴急停DI
    // gpiIndex：通用输入序号,[0,]，设置为-1，则表示取消急停DI
    // sense :触发电平,0：低电平,1：高电平
    """
    def NMC_MtSetEstopDI(axisHandle, gpiIndex, sense):
        libc.NMC_MtSetEstopDI.argtypes = [c_ushort,  c_short,  c_short]
        return libc.NMC_MtSetEstopDI(axisHandle,  gpiIndex,  sense)

    """ 
    // 读取单轴急停DI
    // gpiIndex：通用输入序号,[0,]
    // sense :触发电平,0：低电平,1：高电平
    """
    def NMC_MtGetEstopDI(axisHandle):
        gpiIndex_tmp = c_short()
        sense_tmp = c_short()
        libc.NMC_MtGetEstopDI.argtypes = [c_ushort, POINTER(c_short),  POINTER(c_short)]
        ret = libc.NMC_MtGetEstopDI(axisHandle,  byref(gpiIndex_tmp),  byref(sense_tmp))
        return gpiIndex_tmp, sense_tmp, ret

    # 高级捕获通道数目
    CAPT_EX_CH_NUM = 6

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

    class TAdvCaptureParam(Structure):
        _fields_ = [
            ("capPosIndex", c_short),  # 捕获的位置源序号,0~N：轴1~N+1。（默认0）注：捕获的编码器位置根据用户设置的编码器模式决定
            ("trigSrc", c_short),  # 触发源类型 (默认CAPT_EX_SRC_GPI)
            ("trigIndex", c_short),  # 触发源序号 (默认0)
            ("filter", c_short),  # 滤波时间常数(单位0.1ms,范围0-255)
            ("trigValue", c_long)  # 触发值,对于触发源为IO,表示信号触发的有效电平；对于触发源为位置,则表示触发捕获的位置。（默认0）
        ]
    """
    // 设置高级捕获参数,并启动捕获
    // pParam:参数
    // ch：高级捕获通道号,[0~3]
    """
    def NMC_MtSetAdvCaptParam(devHandle, Param, ch):
        libc.NMC_MtSetAdvCaptParam.argtypes = [c_ushort,  POINTER(pymtn.TAdvCaptureParam),  c_short]
        ret = libc.NMC_MtSetAdvCaptParam(devHandle,  byref(Param),  ch)
        return ret

    """ 
    // 清除高级捕获状态,并取消该通道的捕获
    // ch：高级捕获通道号,[0~3]
    """
    def NMC_MtClrAdvCaptSts(devHandle, ch):
        libc.NMC_MtClrAdvCaptSts.argtypes = [c_ushort,  c_short]
        return libc.NMC_MtClrAdvCaptSts(devHandle, ch)

    """ 
    // 读取高级捕获状态
    // captSts:捕获状态,bit0表示设置的信号前沿触发到,bit1表示信号的后沿触发到。
    // pPosArray : 返回位置,在触发到时,位置为捕获到的位置值。
    //				pPosArray[0]:信号前沿触发位置,pPosArray[1]:信号后沿触发位置,单位:脉冲
    """
    def NMC_MtGetAdvCaptPos(devHandle, ch):
        captSts_tmp = c_short()
        PosArray_tmp = (c_long * 2)()
        libc.NMC_MtGetAdvCaptPos.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_long),  c_short]
        ret = libc.NMC_MtGetAdvCaptPos(devHandle,  byref(captSts_tmp),  PosArray_tmp ,  ch)
        return (captSts_tmp, [PosArray_tmp[0], PosArray_tmp[1]], ret)

    """------------------------------------------------------------------------------------------------------------
    //
    //	4.缓冲区高级指令
    //
    //------------------------------------------------------------------------------------------------------------
    """
    """
    // 坐标系运动：扩展参数
    """
    class TExtCrdPara(Structure):
        _fields_ = [
            ("startVel", c_double),  # 起跳速度（默认0.0）
            ("T", c_double),  # 前瞻时间常数，越大则速度变化越小（默认1.0）
            ("smoothDec", c_double),  # 停止减速度（默认等于系统最大加速度）
            ("abruptDec", c_double),  # 急停减速度（默认系统最大可能值）
            ("lookAheadSwitch", c_short),  # 前瞻启动开关（默认为1，表示开启）
            ("eventTime", c_short),  # 最小匀速段时间，单位ms（默认10）
            ("reserved", c_short * 2)  # 保留字段
        ]
    """
    // 设置坐标系扩展参数 
    // extCrdPara:坐标系扩展参数,参考坐标系运动：扩展参数’TExtCrdPara结构体定义
    """
    def NMC_CrdSetExtPara(crdHandle, extCrdPara):
        libc.NMC_CrdSetExtPara.argtypes = [c_ushort,  POINTER(pymtn.TExtCrdPara)]
        ret = libc.NMC_CrdSetExtPara(crdHandle,  byref(extCrdPara))
        return ret

    class TLookaheadPara(Structure):
        _fields_ = [
            ("lookAheadSwitch", c_short),  # 前瞻功能控制
            ("centAccEn", c_short),  # 是否使用指定的向心加速度
            ("crossEn", c_short),  # 短线段合并开关
            ("eventTime", c_short),  # 最小的匀速段时间,单位ms

            ("accMax", c_double),  # 机台允许的最大加速度
            ("T", c_double),  # 前瞻时间常数
            ("slowAng", c_double),  # 减速角度
            ("stopAng", c_double),  # 停止角度
            ("crossProp", c_double),  # 短线段合并粒度
            ("centAcc", c_double),  # 向心加速度
            ("dvMax", c_double * CRD_MAX_DIMENSION),  # 单轴允许的速度变化量
            ("daMax", c_double * CRD_MAX_DIMENSION),  # 单轴允许的最大加速度
            ("radiusCoef", c_double),  # 曲率系数
            ("radiusErr", c_double),  # 曲率误差
            ("radiusAngMax", c_double),  # 曲率角度最大值
            ("radiusAngMin", c_double),  # 曲率角度最小值

            ("preHandleEn", c_short),  # 轨迹预处理功能开关
            ("axPropTimeUnitProp", c_short),  # 传动比时间单位
            ("preHandleDisAngMin", c_float),  # 轨迹预处理最小角度
            ("preHandleDisAngMax", c_float),  # 轨迹预处理最大角度
            ("preHandleTol", c_float),  # 预处理误差
            ("axProp", c_float * CRD_MAX_DIMENSION),  # 各轴传动比
            ("minCornerVel", c_float),  # 最小的拐角速度

            ("reserved1", c_long * 3),  # 保留
            ("reserved2", c_double * 8)  # 保留
        ]

        def __init__(self):
            super().__init__()
            # 设置默认值
            self.lookAheadSwitch = 100
            self.centAccEn = 0
            self.crossEn = 0
            self.eventTime = 0
            self.accMax = 1000.0
            self.T = 0.01
            self.slowAng = 170.0
            self.stopAng = 5.0
            self.crossProp = 0.0
            self.centAcc = 0.0

            # 设置数组默认值
            for i in range(CRD_MAX_DIMENSION):
                self.dvMax[i] = 500.0
                self.daMax[i] = 500.0
                self.axProp[i] = 1.0

            self.radiusCoef = 0.0
            self.radiusErr = 20.0
            self.radiusAngMax = 7.0
            self.radiusAngMin = 0.5

            self.preHandleEn = 0
            self.axPropTimeUnitProp = 0
            self.preHandleDisAngMin = 5.0
            self.preHandleDisAngMax = 175.0
            self.preHandleTol = 10.0
            self.minCornerVel = 2.0

            # 清空保留字段
            for i in range(3):
                self.reserved1[i] = 0
            for i in range(8):
                self.reserved2[i] = 0.0

    """ 
    // 设置前瞻参数
    // lkhPara:前瞻相关的参数
    """
    def NMC_CrdSetLookaheadPara(crdHandle,lkhPara):
        libc.NMC_CrdSetLookaheadPara.argtypes = [c_ushort,  POINTER(pymtn.TLookaheadPara)]
        ret = libc.NMC_CrdSetLookaheadPara(crdHandle,  byref(lkhPara))
        return ret

    """ 
    // 获取前瞻参数
    // lkhPara:前瞻相关的参数
    """
    def NMC_CrdGetLookaheadPara(crdHandle, lkhPara):
        libc.NMC_CrdGetLookaheadPara.argtypes = [c_ushort,  POINTER(pymtn.TLookaheadPara)]
        ret = libc.NMC_CrdGetLookaheadPara(crdHandle,  byref(lkhPara))
        return lkhPara, ret

    """ 
    // 设置坐标系运动缓冲区是否启用,NMC_CrdConfig后默认为启用状态
    // enFlag:启用,1：启动,0：不启用
    // 注意：如果不想使用坐标系运动缓冲区,请在NMC_CrdConfig之后调用该指令
    """
    def NMC_EnableCrdSdram(crdHandle, enFlag):
        libc.NMC_EnableCrdSdram.argtypes = [c_ushort, c_short]
        return libc.NMC_EnableCrdSdram(crdHandle,  enFlag)

    """ 
    // 读取坐标系扩展参数
    // extCrdPara:坐标系扩展参数
    """
    def NMC_CrdGetExtPara(crdHandle, extCrdPara):
        libc.NMC_CrdGetExtPara.argtypes = [c_ushort,  POINTER(pymtn.TExtCrdPara)]
        ret = libc.NMC_CrdGetExtPara(crdHandle,  byref(extCrdPara))
        return extCrdPara, ret

    """ 
    // 坐标系运动：圆弧插补配置
    """
    class TArcSecSetting(Structure):
        _fields_ = [
            ("minSectionLen", c_double),  # 分解的最小段长,默认1脉冲,范围[1,10000]
            ("maxArcDiff", c_double),     # 最大的圆弧有效性误差,单位：脉冲

            # 圆弧插补误差配置表
            # 注意：MTN通过限制圆弧插补速度, 从而保证插补误差。r全部为0, 则表示关闭这个功能
            ("r", c_double * MAX_ERR_TABLE_SECTION),         # 半径
            ("err", c_double * (MAX_ERR_TABLE_SECTION + 1))  # 半径对应的插补误差,半径 [0,r0],对应err0;半径[r0,r1],对应err1;半径[r1,+max],对应err2
        ]
    """
    // 设置圆弧插补参数（高级指令）
    // pSetting : 设置
    """
    def NMC_CrdSetArcSecPara(crdHandle, Setting):
        libc.NMC_CrdSetArcSecPara.argtypes = [c_ushort,  POINTER(pymtn.TArcSecSetting)]
        ret = libc.NMC_CrdSetArcSecPara(crdHandle, byref(Setting))
        return ret

    """ 
    // 读圆弧插补参数（高级指令）
    """
    def NMC_CrdGetArcSecPara(crdHandle, Setting):
        libc.NMC_CrdGetArcSecPara.argtypes = [c_ushort,  POINTER(pymtn.TArcSecSetting)]
        ret = libc.NMC_CrdGetArcSecPara(crdHandle,  byref(Setting))
        return Setting, ret

    """ 
    // 坐标系运动参数
    """
    class TCrdPara(Structure):
        _fields_ = [
            ("orgFlag", c_short),       # 是否自定义坐标系原点：
            ("reserved", c_short * 3),  # 保留
            ("offset", c_long * 4),     # 自定义坐标系原点偏置（基于机械原点）：
            ("synAccMax", c_double),    # 最大合成加速度
            ("synVelMax", c_double)     # 最大合成速度
        ]
    """
    // 设置坐标系参数(必须)
    // pCrdPara:坐标系参数
    """
    def NMC_CrdSetPara(crdHandle, CrdPara):
        libc.NMC_CrdSetPara.argtypes = [c_ushort,  POINTER(pymtn.TCrdPara)]
        ret = libc.NMC_CrdSetPara(crdHandle,  byref(CrdPara))
        return ret

    """ 
    // 读取插补坐标系系统配置信息
    // pConfig:返回坐标系配置,参考结构体定义
    """
    def NMC_CrdGetConfig(crdHandle, Config ):
        libc.NMC_CrdGetConfig.argtypes = [c_ushort,  POINTER(pymtn.TCrdConfig)]
        ret = libc.NMC_CrdGetConfig(crdHandle,  byref(Config))
        return Config, ret

    """ 
    // 获取坐标系参数
    // pCrdPara:坐标系参数
    """
    def NMC_CrdGetPara(crdHandle, CrdPara ):
        libc.NMC_CrdGetPara.argtypes = [c_ushort, POINTER(pymtn.TCrdPara)]
        ret = libc.NMC_CrdGetPara(crdHandle,  byref(CrdPara))
        return CrdPara, ret

    """ 
    // 获取坐标系速度倍率
    // overRide：坐标系速度倍率
    """
    def NMC_CrdGetOverRide(crdHandle):
        OverRide_tmp = c_double()
        libc.NMC_CrdGetOverRide.argtypes = [c_ushort, POINTER(c_double)]
        ret = libc.NMC_CrdGetOverRide(crdHandle,  byref(OverRide_tmp))
        return OverRide_tmp, ret

    #坐标系状态字位定义:内部扩展
    BIT_CORD_POSREC         = 0x00000040    # bit 6 , 伺服位置到达,步进模式时位置到达,伺服模式时实际位置到达误差限
    BIT_CORD_AUXAXIS_BUSY   = 0x00000080    # bit 7 , 坐标系运动中的关联轴启动前处于运动状态错误
    BIT_CORD_AUXAXIS_ERR    = 0x00000100    # bit 8 , 插补辅助轴错误
    BIT_CORD_AXIS_ERR       = 0x00000200    # bit 9 , 插补轴存在报警错误（如限位、驱动报警）
    BIT_CORD_SDRAM_CALC_ERR = 0x00000400    # bit 10 , SDRAM缓冲区计算错误
    BIT_CORD_SCARA_CALC_ERR = 0x00000800    # bit 11 , SCARA计算数据错误
    """
    // 读取内部坐标系状态
    // pStsWord：返回状态字,定义64bits(二维的long数组),便于后续扩展状态位
    """
    def NMC_CrdGetInnerSts(crdHandle):
        StsWord_tmp = c_long()
        libc.NMC_CrdGetInnerSts.argtypes = [c_ushort, POINTER(c_long)]
        ret = libc.NMC_CrdGetInnerSts(crdHandle,  byref(StsWord_tmp))
        return StsWord_tmp, ret

    """ 
    // 直接修改坐标系偏移
    // pOffsetArray:坐标系偏移
    // cnt:数组长度
    """
    def NMC_CrdModifyOffset(crdHandle, OffsetArray, cnt):
        OffsetArray_tmp = (c_long * cnt)(*OffsetArray)
        libc.NMC_CrdModifyOffset.argtypes = [c_ushort, POINTER(c_long),  c_short]
        ret = libc.NMC_CrdModifyOffset(crdHandle,  OffsetArray_tmp,  cnt)
        return ret

    """ 
    // 缓冲区设置急停DI
    // axis:轴号,取值范围[0,n)
    // gpiIndex:通用输入序号
    // sense:触发电平
    """
    def NMC_CrdBufSetEstopDI (crdHandle, segNo, axis, gpiIndex, sense):
        libc.NMC_CrdBufSetEstopDI.argtypes = [c_ushort,  c_long,  c_short,  c_short,  c_short]
        return libc.NMC_CrdBufSetEstopDI(crdHandle,  segNo,  axis,  gpiIndex,  sense)

    # 缓冲区数据打包
    BUF_LINE = 0             # 缓冲区直线插补
    BUF_DO = 1               # 缓冲区DO输出
    BUF_OUT = 2              # 缓冲区OUT输出
    BUF_DELAY = 3            # 缓冲区延时
    BUF_AXMOVE = 4           # 缓冲区单轴运动
    BUF_DOEX = 5             # 缓冲区DO输出（根据掩码输出）
    BUF_ARC_R = 6            # 平面圆弧插补：终点位置、半径、方向
    BUF_ARC_C = 7            # 平面圆弧插补：终点位置、圆心、方向
    BUF_LASER_SETPOWER = 8   # 激光：设置能量
    BUF_LASER_ONOFF = 9      # 激光：缓冲区开关光
    BUF_LASER_SETFOLLOW = 10 # 激光：设置跟随
    BUF_LASER_SETPARAM = 11  # 激光：设置参数
    BUF_LINEXYZA = 12        # 缓冲区四轴直线插补
    BUF_SHIO_GATEPULSE = 13  # 缓冲区输出Gate脉冲
    BUF_DOBITPULSE = 14      # DoBitPulse功能
    BUF_XYZD8 = 15           # LineXYZD8,数据结构体为：TCrdLineXYZD8Unit
    BUF_SHIOMINFRQ = 16      # 设置或清除SHIO最小频率
    BUF_SHIOSETPARAM = 17    # SHIO参数设置
    BUF_SHIOGATEONOFF = 18   # 设置Gate开关
    BUF_WAITENCINPOS = 19    # 等待电机到位
    BUF_WAITDI = 20          # 等待DI

    # # 公共基础结构体
    # class TCrdBufBase(Structure):
    #     _pack_ = 4            # 强制4字节对齐
    #     _fields_ = [
    #         ("segNo", c_long)  # 用户自定义段号
    #     ]

    class TCrdBufLine(Structure):
        _pack_ = 4
        _fields_ = [
            ("segNo", c_long),  # 用户自定义段号
            ("tgPos", c_long * 3),  # 目标位置[X,Y,Z]
            ("endVel", c_double),  # 终点速度(mm/s)
            ("vel", c_double),  # 最大速度(mm/s)
            ("synAcc", c_double),  # 插补加速度(mm/s²)
            ("mask", c_short),  #  crdAxMask,参与的插补轴,按位表示
            ("lookaheadDis", c_short),  # 前瞻使能 0:禁用 1:启用
            ("reserved", c_long)  # 保留
        ]

    class TCrdBufLineXYZA(Structure):
        _pack_ = 4
        _fields_ = [
            ("tgPos", c_long * 4),  # 目标位置[X,Y,Z,A]
            ("endVel", c_double),  # 终点速度
            ("vel", c_double),  # 最大速度
            ("synAcc", c_double),  # 插补加速度
            ("segNo", c_long),  # 用户自定义段号
            ("mask", c_short),  # crdAxMask,参与的插补轴,按位表示
            ("lookaheadDis", c_short)  # 前瞻使能
        ]

    class TCrdBufOut(Structure):
        _pack_ = 4
        _fields_ = [
            ("segNo", c_long),  # 段号
            ("group", c_short),  # Out输出类型
            ("ch", c_short),  # 通道号[0,n]
            ("outValue", c_long)  # 输出值
        ]

    class TCrdBufDO(Structure):
        _pack_ = 4
        _fields_ = [
            ("segNo", c_long),  # 用户自定义段号
            ("group", c_short),  # 缓冲区输出DO组
            ("ch", c_short),  # 位序号[0,31]
            ("value", c_long)  # 输出值(0/1)
        ]

    class TCrdBufDelay(Structure):
        _pack_ = 4
        _fields_ = [
            ("segNo", c_long),  # 段号
            ("scale", c_long),  # 延时单位 0:ms 1:s
            ("count", c_long)  # 延时时长
        ]

    class TCrdBufDOEx(Structure):
        _pack_ = 4
        _fields_ = [
            ("segNo", c_long),  # 段号
            ("group", c_long),  # 缓冲区输出DO组
            ("doMask", c_long), # 输出操作位,bit位为1表示要输出
            ("value", c_long)   # 输出值,bit位指示输出值
        ]

    class TCrdBufAxMove(Structure):
        _pack_ = 4
        _fields_ = [
            ("segNo", c_long),  # 段号
            ("axis", c_short),  # 单轴移动的轴号 [0,n],非坐标系内轴
            ("soomthCoef", c_short),  # 平滑系数
            ("blockEn", c_short),  # 阻塞模式 0:非阻塞 1:阻塞
            ("synEn", c_short),  # 同步模式 0:异步 1:同步
            ("tgPos", c_long),  # 目标位置
            ("vel", c_double),  # 运动速度
            ("acc", c_double)  # 运动加速度
        ]

    class TCrdBufArcR(Structure):
        _pack_ = 4
        _fields_ = [
            ("segNo", c_long),  # 段号
            ("tgPos", c_long * 2),  # 目标位置
            ("circleDir", c_short),  # 是否为同步模式 0 异步 ,1 同步
            ("lookaheadDis", c_char),  # 是否使用前瞻
            ("panelIndex", c_char),  # 圆弧插补平面：0：XY平面，1：YZ平面，其他：ZX平面
            ("radius", c_double),  # 半径(mm)
            ("endVel", c_double),  # 终点速度
            ("vel", c_double),  # 运动速度
            ("acc", c_double)  # 运动加速度
        ]

    class TCrdBufArcC(Structure):
        _pack_ = 4
        _fields_ = [
            ("segNo", c_long),  # 段号
            ("tgPos", c_long * 2),  # 目标位置
            ("centerPos", c_long * 2),  # 目标位置
            ("circleDir", c_short),  # 是否为同步模式 0 异步 ,1 同步
            ("lookaheadDis", c_char),  # 前瞻使能
            ("panelIndex", c_char),  # 圆弧插补平面：0：XY平面，1：YZ平面，其他：ZX平面
            ("endVel", c_double),  # 终点速度
            ("vel", c_double),  # 运动速度
            ("acc", c_double)  # 运动加速度
        ]

    class TCrdBufLaserSetParam(Structure):
        _pack_ = 4
        _fields_ = [
            ("segNo", c_long),  # 段号
            ("onDelay", c_long),  # 开光延时(us)
            ("offDelay", c_long),  # 关光延时(us)
            ("minValue", c_long),  # 最小输出值
            ("maxValue", c_long),  # 最大输出值
            ("standbyPower", c_long),  # 待机能量
            ("ch", c_short),  # 激光控制通道
            ("reserved", c_short)  # 保留
        ]

    class TCrdBufLaserSetFollow(Structure):
        _pack_ = 4
        _fields_ = [
            ("segNo", c_long),  # 段号
            ("followType", c_short),  # 跟随类型
            ("ch", c_short),  # 激光通道号
            ("overRide", c_double)  # 跟随倍率
        ]

    class TCrdBufLaserOnOff(Structure):
        _pack_ = 4
        _fields_ = [
            ("segNo", c_long),  # 段号
            ("onOff", c_short),  # 开关状态 0:关 1:开
            ("ch", c_short)  # 激光通道号
        ]

    class TCrdBufLaserSetPower(Structure):
        _pack_ = 4
        _fields_ = [
            ("segNo", c_long),  # 段号
            ("ch", c_short),  # 激光通道号
            ("reserved", c_short),  # 保留
            ("power", c_double)  # 能量值
        ]

    class TCrdBufSHIOGatePulse(Structure):
        _pack_ = 4
        _fields_ = [
            ("segNo", c_long),  # 段号
            ("outCount", c_long),  # 输出个数
            ("gateTime", c_double),  # gate输出的脉宽，单位：微秒
            ("gateFrq", c_double),  # gate输出的频率，单位：HZ)
            ("ch", c_short),  # 通道
            ("reserved", c_short * 3)  # 保留
        ]

    class TCrdBufDoBitPulse(Structure):
        _pack_ = 4
        _fields_ = [
            ("segNo", c_long),  # 段号
            ("highLevelTime", c_long),  # 高电平宽度(us)
            ("lowLevelTime", c_long),  # 低电平宽度(us)
            ("outCount", c_long),  # 脉冲个数
            ("initialLevel", c_long),  # 0：先输出低电平，1：先输出高电平
            ("ch", c_short),  # 通道
            ("enable", c_short),  # 1:使能,0:关闭
            ("doType", c_short),  # DO类型,默认CRD_BUFF_DO_GPDO1
            ("doIndex", c_short)  # DO序号，取值范围[0,n]
        ]

    class TCrdBufSHIOMinFrq(Structure):
        _pack_ = 4
        _fields_ = [
            ("segNo", c_long),  # 段号
            ("minFrq", c_long),  # 最最小频率，仅当enable=1时有效
            ("ch", c_short),  # 通道
            ("setOrClr", c_short)  # 1:设置,0:清除
        ]

    class TCrdBufSHIOSetParam(Structure):
        _pack_ = 4
        _fields_ = [
            ("segNo", c_long),  # 段号
            ("ch", c_short),  # 通道
            ("reserved", c_short),  # 保留
            ("delay", c_double),  # 延时开关光时间
            ("gateTime", c_double),  # gate打开时间，单位:秒
            ("gateDistance", c_double)  # 固定模式下的位置间隔，单位pulse
        ]

    class TCrdBufSHIOGateOnOff(Structure):
        _pack_ = 4
        _fields_ = [
            ("segNo", c_long),  # 段号
            ("ch", c_short),  # 通道
            ("onOff", c_short)  # 1:打开，0：关闭
        ]

    class TCrdBufWaitEncInPosition(Structure):
        _pack_ = 4
        _fields_ = [
            ("segNo", c_long),  # 段号
            ("axisMask", c_long),  # 轴掩码
            ("overTime", c_long)  # 等待超时时间，单位：毫秒
        ]

    class TCrdBufWaitDI(Structure):
        _pack_ = 4
        _fields_ = [
            ("segNo", c_long),  # 段号
            ("index", c_short),  # 通道号,取值范围[0,127],前64通道代表通用DI，后64通道代表扩展IO
            ("level", c_short),  # 等待电平
            ("waitLastTime", c_long)  # 超时(ms)
        ]

    """
    // 打包插补数据
    // pBufData 插补数据结构存储数组
    // dataLen 数据长度
    // 压入数据时，先压入指令字，然后再压入指令字对应的工作数据，总的数据长度不超过1000个字节
    """
    def NMC_CrdBufDataPack(crdHandle, data_buffer, dataLen):
        BufData_tmp = (c_ubyte * dataLen).from_buffer_copy(data_buffer)
        BufData_tmp = cast(BufData_tmp, POINTER(c_ubyte))
        libc.NMC_CrdBufDataPack.argtypes = [c_ushort, POINTER(c_ubyte),  c_short]
        ret = libc.NMC_CrdBufDataPack(crdHandle,  BufData_tmp,  dataLen)
        return ret

    """
    // 功能：缓冲区探位置停止并后续加位置偏置
    // useCaptPos：是否使用捕获位置  1使用,0不使用
    // axis:轴序号
    // sense:触发电平,0：低电平,1：高电平
    // gpiIndex:通用输入序号
    """
    def NMC_CrdBufSetStopOffset(crdHandle,  segNo,  axis, gpiIndex, sense, useCaptPos):
        libc.NMC_CrdBufSetStopOffset.argtypes = [c_ushort,  c_long,  c_short,  c_short,  c_short,  c_short]
        return libc.NMC_CrdBufSetStopOffset(crdHandle,  segNo,  axis,  gpiIndex,  sense,  useCaptPos)

    """
    // 功能：解除缓冲区探位置停止并后续加位置偏置
    """
    def NMC_CrdBufClrStopOffset(crdHandle, segNo, axis):
        libc.NMC_CrdBufClrStopOffset.argtypes = [c_ushort,  c_long,  c_short]
        return libc.NMC_CrdBufClrStopOffset(crdHandle,  segNo,  axis)

    """ 
    // 设置是否计算所有线段长度
    """
    def NMC_CrdSetBufLengthFlag(crdHandle, flag):
        libc.NMC_CrdSetBufLengthFlag.argtypes = [c_ushort,  c_short]
        return libc.NMC_CrdSetBufLengthFlag(crdHandle,  flag)

    """ 
    // 读取插补线段长度
    """
    def NMC_CrdGetBufLength(crdHandle):
        Len_tmp = c_double()
        libc.NMC_CrdGetBufLength.argtypes = [c_ushort, POINTER(c_double)]
        ret = libc.NMC_CrdGetBufLength(crdHandle,  byref(Len_tmp))
        return Len_tmp, ret

    def NMC_CrdSetIsShortLine(crdHandle, isShortLine):
        libc.NMC_CrdSetIsShortLine.argtypes = [c_ushort, c_short]
        ret = libc.NMC_CrdSetIsShortLine(crdHandle, isShortLine)
        return ret

    def NMC_CrdSetLookAheadCentriAcc(crdHandle, isUsingSetAcc, centriAcc):
        libc.NMC_CrdSetLookAheadCentriAcc.argtypes = [c_ushort, c_short, c_double]
        ret = libc.NMC_CrdSetLookAheadCentriAcc(crdHandle, isUsingSetAcc, centriAcc)
        return ret

    """------------------------------------------------------------------------------------------------------------
    //
    //	5.硬件捕获及不常用指令
    //
    //------------------------------------------------------------------------------------------------------------
    """
    # 编码器硬件捕获模式选择
    CAPT_MODE_Z          = 0   # 编码器Z相捕获
    CAPT_MODE_IO         = 1   # IO 捕获
    CAPT_MODE_Z_AND_IO   = 2   # IO+Z相 捕获
    CAPT_MODE_Z_AFT_IO   = 3   # 先IO触发再Z相触发 捕获

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

    """ 
    // 读取捕获有效电平
    // mode : 模式选择,参考宏定义
    // ioSrc：IO输入源选择,参考宏定义
    // level: 触发沿。0为下降沿,1为上升沿
    """
    def NMC_MtGetCaptSns(axisHandle):
        Mode_tmp = c_short()
        IoSrc_tmp = c_short()
        Level_tmp = c_short()
        libc.NMC_MtGetCaptSns.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_short),  POINTER(c_short)]
        ret = libc.NMC_MtGetCaptSns(axisHandle,  byref(Mode_tmp),  byref(IoSrc_tmp),  byref(Level_tmp))
        return Mode_tmp, IoSrc_tmp, Level_tmp, ret

    """ 
    // 设置启动捕获
    // 注：捕获触发标志在轴状态字里。
    """
    def NMC_MtSetCapt(axisHandle):
        libc.NMC_MtSetCapt.argtypes = [c_ushort]
        return libc.NMC_MtSetCapt(axisHandle )

    """ 
    // 清除轴的捕获状态
    """
    def NMC_MtClrCaptSts(axisHandle):
        libc.NMC_MtClrCaptSts.argtypes = [c_ushort]
        return libc.NMC_MtClrCaptSts(axisHandle)

    """ 
    //读捕获位置
    // pPos : 返回位置,单位:脉冲
    """
    def NMC_MtGetCaptPos(axisHandle):
        Pos_tmp = c_long()
        libc.NMC_MtGetCaptPos.argtypes = [c_ushort, POINTER(c_long)]
        ret = libc.NMC_MtGetCaptPos(axisHandle,  byref(Pos_tmp))
        return Pos_tmp, ret

    """ 
    // 读取脉冲输出滤波
    // pCoe系数： 范围0~65535,0不滤波,数值越大滤波效果越明显。默认值为0
    """
    def NMC_MtGetStepFilter (axisHandle):
        Coe_tmp = c_ushort()
        libc.NMC_MtGetStepFilter.argtypes = [c_ushort, POINTER(c_ushort)]
        ret = libc.NMC_MtGetStepFilter(axisHandle,  byref(Coe_tmp))
        return Coe_tmp, ret

    """ 
    // 多轴同时启动
    // axisHandle:任意轴
    // axisMask：按bit对应相应轴号,bit为1表示启动,bit为0表示不启动
    """
    def NMC_MtUpdateMulti(axisHandle, axisMask ):
        libc.NMC_MtUpdateMulti.argtypes = [c_ushort,  c_long]
        return libc.NMC_MtUpdateMulti(axisHandle, axisMask )

    """ 
    // 多轴同时停止
    // axisHandle:任意轴
    // axisMask：按bit对应相应轴号,bit为1表示启动,bit为0表示不启动
    """
    def NMC_MtStopMulti(axisHandle, axisMask):
        libc.NMC_MtStopMulti.argtypes = [c_ushort,  c_long]
        return libc.NMC_MtStopMulti(axisHandle,  axisMask)

    """ 
    // 按位设置通用输入信号取反
    // bitIndex:取值范围[0,n],位序号,前64位为本地的通用输入,大于64为扩展Di
    // revs:是否取反,1：取反,0：不取反
    """
    def NMC_SetDIBitRevs (devHandle, bitIndex, revs):
        libc.NMC_SetDIBitRevs.argtypes = [c_ushort,  c_short,  c_short]
        return libc.NMC_SetDIBitRevs(devHandle,  bitIndex,  revs)

    """ 
    // 按位读取通用输入信号取反
    // bitIndex:取值范围[0,n],位序号,前64位为本地的通用输入,大于64为扩展Di
    // pRevs:是否取反,1：取反,0：不取反
    """
    def NMC_GetDIBitRevs (devHandle, bitIndex):
        Revs_tmp = c_short()
        libc.NMC_GetDIBitRevs.argtypes = [c_ushort, c_short, POINTER(c_short)]
        ret = libc.NMC_GetDIBitRevs(devHandle,  bitIndex,  byref(Revs_tmp))
        return Revs_tmp, ret

    """ 
    // 按位设置通用输出信号取反
    // bitIndex:取值范围[0,n],位序号,前64位为本地的通用输出,大于64为扩展Do
    // revs:是否取反,1：取反,0：不取反
    """
    def NMC_SetDOBitRevs (devHandle, bitIndex, revs):
        libc.NMC_SetDOBitRevs.argtypes = [c_ushort,  c_short,  c_short]
        return libc.NMC_SetDOBitRevs(devHandle,  bitIndex,  revs)

    """ 
    // 按位读取通用输出信号取反
    // bitIndex:取值范围[0,n],位序号,前64位为本地的通用输出,大于64为扩展Do
    // pRevs:是否取反,1：取反,0：不取反
    """
    def NMC_GetDOBitRevs (devHandle, bitIndex):
        Revs_tmp = c_short()
        libc.NMC_GetDOBitRevs.argtypes = [c_ushort,  c_short,  POINTER(c_short)]
        ret = libc.NMC_GetDOBitRevs(devHandle,  bitIndex,  byref(Revs_tmp))
        return Revs_tmp, ret

    """ 
    // DO输出持续设定时间后翻转
    // bitIndex:取值范围[0,n],位序号,前64位为本地的通用输出,大于64为扩展Do
    // value:设置通用数字量输出。1, 输出高电平,0,输出低电平
    // reverseTime:持续的电平,单位:毫秒
    """
    def NMC_SetDOBitAutoReverse(devHandle, bitIndex, value, reverseTime):
        libc.NMC_SetDOBitAutoReverse.argtypes = [c_ushort,  c_short,  c_short,  c_short]
        ret = libc.NMC_SetDOBitAutoReverse(devHandle,  bitIndex,  value,  reverseTime)
        return ret
    # IO映射
    DIO_MAP_MAX_NUM		= 8	# 最多允许的映射关系

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

    class TDioMappingCfg(Structure):
        """DIO 映射配置"""
        _fields_ = [
            ("enable", c_ubyte),    # 1：启用，0：禁用
            ("pinGrp", c_ubyte),    # 映射的信号类型
            ("pinIndex", c_ubyte),  # 映射的信号序号
            ("outEnable", c_ubyte), # 输出允许
            ("newGrp", c_ubyte),    # 映射到的信号类型
            ("newIndex", c_ubyte),  # 映射到的信号序号
        ]
    """
    // 增加一组映射，映射关系目前最多存在DIO_MAP_MAX_NUM组
    """
    def NMC_SetDioMapping(devHandle,DioCfg):
        libc.NMC_SetDioMapping.argtypes = [c_ushort,  POINTER(pymtn.TDioMappingCfg)]
        ret = libc.NMC_SetDioMapping(devHandle,  byref(DioCfg))
        return ret

    """ 
    // 获取所有的DIO映射数据
    // pDioCfg：映射数据数组,目前为DIO_MAP_MAX_NUM组
    """
    def NMC_GetAllDioMapping(devHandle,DioCfg):
        libc.NMC_GetAllDioMapping.argtypes = [c_ushort,  POINTER(pymtn.TDioMappingCfg)]
        ret = libc.NMC_GetAllDioMapping(devHandle,  DioCfg)
        return DioCfg, ret

    """ 
    // 清除所有的DIO映射关系
    """
    def NMC_ClrAllDioMapping(devHandle):
        libc.NMC_ClrAllDioMapping.argtypes = [c_ushort]
        return libc.NMC_ClrAllDioMapping(devHandle)

    """------------------------------------------------------------------------------------------------------------
    //
    //	6.平台相关指令
    //
    //------------------------------------------------------------------------------------------------------------
    """
    VAR_PWM0_CTL    = 256		# pwm通道0打开关闭,1表示打开,0表示关闭
    VAR_PWM0_VALUE  = 257		# pwm通道0输出值
    VAR_PWM1_CTL    = 258		# pwm通道1打开关闭,1表示打开,0表示关闭
    VAR_PWM1_VALUE  = 259		# pwm通道1输出值
    VAR_EXT_DAC0    = 260		# 扩展的DAC通道0
    VAR_EXT_DAC1    = 261		# 扩展的DAC通道1
    VAR_OUT_OPTION	= 262		# PWM输出通道选项
    VAR_DAC0		= 263		# DAC通道0~7
    VAR_DAC1		= 264
    VAR_DAC2		= 265
    VAR_DAC3		= 266
    VAR_DAC4		= 267
    VAR_DAC5		= 268
    VAR_DAC6		= 269
    VAR_DAC7		= 270
    VAR_ADC0		= 271		# ADC通道0~7
    VAR_ADC1		= 272
    VAR_ADC2		= 273
    VAR_ADC3		= 274
    VAR_ADC4		= 275
    VAR_ADC5		= 276
    VAR_ADC6		= 277
    VAR_ADC7		= 278

    # 内部变量ID定义
    VAR_INNNER_VAR1 = 1000
    VAR_INNNER_VAR2 = 1001
    VAR_INNNER_VAR3 = 1002
    VAR_INNNER_VAR4 = 1003
    VAR_INNNER_VAR5 = 1004
    VAR_INNNER_VAR6 = 1005
    VAR_INNNER_VAR7 = 1006
    VAR_INNNER_VAR8 = 1007



    """
    // 设置通用可寻址变量 8字节数据类型（可涵盖常用的类似,如：char/short/long/double 等）
    """
    def NMC_SetVar8B(devHandle, varID,  value ):
        libc.NMC_SetVar8B.argtypes = [c_ushort,  c_long,  c_longlong]
        return libc.NMC_SetVar8B(devHandle,  varID,  value )

    """ 
    // 读取通用可寻址变量 8字节数据类型（可涵盖常用的类似,如：char/short/long/double 等）
    """
    def NMC_GetVar8B(devHandle,varID):
        Value_tmp = c_longlong()
        libc.NMC_GetVar8B.argtypes = [c_ushort,  c_long,  POINTER(c_longlong)]
        ret = libc.NMC_GetVar8B(devHandle,  varID,  byref(Value_tmp))
        return Value_tmp, ret

    """ 
    系统变量宏定义
    """
    SYS_VAR_SET_STAT_ENABLE		= 100
    SYS_VAR_GET_CLOCK			= 101
    SYS_VAR_GET_USERAPP_COUNT	= 107
    SYS_VAR_GET_USERAPP_MIN		= 108
    SYS_VAR_GET_USERAPP_MAX		= 109
    SYS_VAR_GET_USERAPP_AVG		= 110
    SYS_VAR_GET_USERAPP_CURT	= 111
    SYS_VAR_GET_PRFINT_COUNT	= 112
    SYS_VAR_GET_PRFINT_MIN		= 113
    SYS_VAR_GET_PRFINT_MAX		= 114
    SYS_VAR_GET_PRFINT_AVG		= 115
    SYS_VAR_GET_PRFINT_CURT		= 116
    SYS_VAR_GET_MAINLP_COUNT	= 117
    SYS_VAR_GET_MAINLP_MIN		= 118
    SYS_VAR_GET_MAINLP_MAX		= 119
    SYS_VAR_GET_MAINLP_AVG		= 120
    SYS_VAR_GET_MAINLP_CURT		= 121
    """
    // 设置通用可寻址系统变量 8字节数据类型（可涵盖常用的类似,如：char/short/long/double 等）
    """
    def NMC_SysSetVar8B(devHandle, varID, value):
        libc.NMC_SysSetVar8B.argtypes = [c_ushort,  c_long,  c_longlong]
        return libc.NMC_SysSetVar8B(devHandle,  varID,  value )

    """ 
    // 读取通用可寻址系统变量 8字节数据类型（可涵盖常用的类似,如：char/short/long/double 等）
    """
    def NMC_SysGetVar8B(devHandle,varID):
        Value_tmp = c_longlong()
        libc.NMC_SysGetVar8B.argtypes = [c_ushort,  c_long,  POINTER(c_longlong)]
        ret = libc.NMC_SysGetVar8B(devHandle,  varID,  byref(Value_tmp))
        return Value_tmp, ret

    """
    // 向备份内存写数据(总长度约1500byte)
    //src: 要写入的数据
    //len: 要写入的长度,单位：byte
    //off: 要写入的地址(偏移量)
    // 注：1)写入的数据掉电不丢失。
    //     2)一次最多写1440字节。总长度约1500byte
    """
    def NMC_BackSramWrite(devHandle, src, len, off):
        libc.NMC_BackSramWrite.argtypes = [c_ushort,  c_void_p,  c_long,  c_long]
        ret = libc.NMC_BackSramWrite(devHandle,  src,  len,  off)
        return ret

    """
    // 从备份内存读数据
    //dst: 读出的数据暂存区
    //len: 要读出的长度,单位：byte,一次最多读1440字节。总长度约1500byte
    //off: 读数据的地址(偏移量)
    """
    def NMC_BackSramRead(devHandle,  len, off):
        dst_tmp = (c_uint8 * len)()
        libc.NMC_BackSramRead.argtypes = [c_ushort, POINTER(c_uint8),  c_long,  c_long]
        ret = libc.NMC_BackSramRead(devHandle,  dst_tmp,  len,  off)
        return bytes(dst_tmp), ret

    """ 
    // 平台：控制器时间结构
    """
    class TNMCTime(Structure):
        _fields_ = [
            ("year", c_short),  # 年,真实年份。取值范围[2000,2099]
            ("mon", c_short),   # 月,取值范围[1,12]
            ("day", c_short),   # 日,取值范围[1,31]
            ("hour", c_short),  # 时,取值范围[0,23]
            ("min", c_short),   # 分,取值范围[0,59]
            ("second", c_short) # 秒,取值范围[0,59]
        ]
    """
    // 读时间
    // pTime ：返回时间结构,参考 TNMCTime 结构定义
    // 注：时间在出厂时根据实际时间设定,用户不可通过指令修改
    """
    def NMC_GetTime(devHandle, Time):
        libc.NMC_GetTime.argtypes = [c_ushort, POINTER(pymtn.TNMCTime)]
        ret = libc.NMC_GetTime(devHandle,  Time)
        return Time, ret

    """ 
    // 写时间
    // pTime ：时间结构,参考 TNMCTime 结构定义
    // pPassword : 控制器系统密码,长度最多为16个字节
    """
    def NMC_SetTime(devHandle, Time, Password):
        pwd_bytes = Password.encode('ascii').ljust(16, b'\0')
        Password_tmp = create_string_buffer(pwd_bytes)
        libc.NMC_SetTime.argtypes = [c_ushort,  POINTER(pymtn.TNMCTime),  c_char_p]
        ret = libc.NMC_SetTime(devHandle,  byref(Time),  Password_tmp)
        return ret

    """ 
    // 修改控制器系统密码,密码用于修改系统时钟等
    // pPasswordOld : 控制器系统当前密码,长度最多为15个字符
    // pPasswordNew : 新的控制器系统密码,长度最多为15个字符
    // 注意：1.初始出厂无密码
    //            2.修改密码后,请务必记住新的密码。忘记密码只能返厂复位。
    //            3.密码大小写敏感
    """
    def NMC_ChangePassword(devHandle, PasswordOld, PasswordNew):
        old_bytes = PasswordOld.encode('ascii').ljust(16, b'\0')
        new_bytes = PasswordNew.encode('ascii').ljust(16, b'\0')

        PasswordOld_tmp = create_string_buffer(old_bytes)
        PasswordNew_tmp = create_string_buffer(new_bytes)
        libc.NMC_ChangePassword.argtypes = [c_ushort,  c_char_p,  c_char_p]
        ret = libc.NMC_ChangePassword(devHandle,  PasswordOld_tmp,  PasswordNew_tmp)
        return ret

    """ 
    // 验证系统密码
    // pPassword : 控制器系统当前密码,长度最多为15个字符
    // 返回0表示验证通过,其他表示错误
    """
    def NMC_VerifyPassword(devHandle, Password):
        Password_bytes = Password.encode('ascii').ljust(16, b'\0')
        Password_tmp = create_string_buffer(Password_bytes)
        libc.NMC_VerifyPassword.argtypes = [c_ushort,  c_char_p]
        ret = libc.NMC_VerifyPassword(devHandle,  Password_tmp)
        return ret

    """ 
    // 清除系统密码及用户密码
    // pData:解密数据，长度为8
    """
    def NMC_ClrPassword(devHandle, Data):
        Data_tmp = (c_short * 4)(*Data)
        libc.NMC_ClrPassword.argtypes = [c_ushort, POINTER(c_short)]
        ret = libc.NMC_ClrPassword(devHandle,  Data_tmp)
        return ret

    """ 
    // 读设备唯一序列号
    // pUID ：返回设备唯一序列号,为四个Int32的数据
    // example:unsigned long devID[4];
    //         NMC_GetUID(g_hDev,devID);
    """
    def NMC_GetUID(devHandle):
        UID_tmp = (c_ulong * 4)()
        libc.NMC_GetUID.argtypes = [c_ushort, POINTER(c_ulong)]
        ret = libc.NMC_GetUID(devHandle,  UID_tmp)
        return [UID_tmp[i] for i in range(4)], ret

    """ 
    // 写用户参数
    // add ：参数区的偏移地址(字节地址)
    // len : 写入长度,单位：byte
    // pWrData ：要写入的数据；
    // 注：1)写入的数据掉电不丢失。
    //     2)一次最多写256字节。参数区总长度为2048字节。
    //     3)此指令比其它指令操作时间会长,如果出现通讯错误（返回-1）,则需要将通过NMC_SetCommPara延长指令通讯时间
    """
    def NMC_UserParaWr(devHandle, add, len, WrData):
        WrData_tmp = (c_ubyte * len)(*WrData)
        libc.NMC_UserParaWr.argtypes = [c_ushort,  c_ulong,  c_ulong,  POINTER(c_ubyte)]
        ret = libc.NMC_UserParaWr(devHandle,  add,  len,  WrData_tmp)
        return ret

    """ 
    // 读用户参数
    // add ：参数区的偏移地址(字节地址)
    // len : 写入长度,单位：byte
    // pRdData ：要读取的数据存储
    // 注：一次最多读256字节。参数区总长度为2048字节。（参考函数 ： NMC_UserParaWr）
    """
    def NMC_UserParaRd(devHandle, add, len):
        RdData_tmp = (c_ubyte * len)()
        libc.NMC_UserParaRd.argtypes = [c_ushort,  c_ulong,  c_ulong,  POINTER(c_ubyte)]
        ret = libc.NMC_UserParaRd(devHandle,  add,  len,  RdData_tmp)
        return bytes(RdData_tmp), ret

    """ 
    // 写扩展用户参数
    // add ：参数区的偏移地址(字节地址)
    // len : 写入长度,单位：byte
    // pWrData ：要写入的数据；
    // 注：1)写入的数据掉电不丢失。
    //     2)一次最多写1000字节。参数区总长度为32K字节。
    //     3)此指令比其它指令操作时间会长,如果出现通讯错误（返回-1）,则需要将通过NMC_SetCommPara延长指令通讯时间
    """
    def NMC_UserParaWrEx(devHandle, add, len, WrData):
        WrData_tmp = (c_ubyte * len)(*WrData)
        libc.NMC_UserParaWrEx.argtypes = [c_ushort,  c_ulong,  c_ulong,  POINTER(c_ubyte)]
        ret = libc.NMC_UserParaWrEx(devHandle,  add,  len,  WrData_tmp )
        return ret

    """
    // 读扩展用户参数
    // add ：参数区的偏移地址(字节地址)
    // len : 写入长度,单位：byte
    // pRdData ：要读取的数据存储
    // 注：一次最多读1000字节。参数区总长度为32K字节。（参考函数 ： NMC_UserParaWr）
    """
    def NMC_UserParaRdEx(devHandle, add, len):
        RdData_tmp = (c_ubyte * len)()
        libc.NMC_UserParaRdEx.argtypes = [c_ushort,  c_ulong,  c_ulong,  POINTER(c_ubyte)]
        ret = libc.NMC_UserParaRdEx(devHandle,  add,  len,  RdData_tmp)
        return bytes(RdData_tmp), ret

    """ 
    掉电保存：备份数据定义
    """
    class TBackGroup1(Structure):
        _fields_ = [
            ("crdSegNo", c_long),       # 坐标系运动的段号
            ("crdPrfPos", c_long * 3),  # 坐标系运动的规划位置
            ("axPrfPos", c_long * 8),   # 规划位置(8个轴)
            ("axisPos", c_long * 8),    # 机械位置(8个轴)
            ("encPos", c_long * 8)      # 编码器位置(8个轴)
        ]
    """
    // 读取当前备份的变量数值（断电自动保存）
    // pBackVar : 备份的变量值,参考结构体定义
    """
    def NMC_GetBackedVarGroup1(devHandle, BackVar):
        libc.NMC_GetBackedVarGroup1.argtypes = [c_ushort,  POINTER(pymtn.TBackGroup1)]
        ret = libc.NMC_GetBackedVarGroup1(devHandle,  byref(BackVar))
        return BackVar, ret

    """ 
    // 掉电保存：备份数据定义（12轴）
    """

    class TBackGroup2(Structure):
        _fields_ = [
            ("crdSegNo", c_long * 2),         # 坐标系运动的段号(2个元素)
            ("crdPrfPos", (c_long * 3) * 2),  # 坐标系运动的规划位置(2×3数组)
            ("axPrfPos", c_long * 12),        # 规划位置(12个轴)
            ("axisPos", c_long * 12),         # 机械位置(12个轴)
            ("encPos", c_long * 12)           # 编码器位置(12个轴)
        ]
    """
    // 读取当前备份的变量数值（断电自动保存）
    // pBackVar : 备份的变量值,参考结构体定义
    """
    def NMC_GetBackedVarGroup2(devHandle, BackVar):
        libc.NMC_GetBackedVarGroup2.argtypes = [c_ushort, POINTER(pymtn.TBackGroup2)]
        ret = libc.NMC_GetBackedVarGroup2(devHandle,  byref(BackVar))
        return BackVar, ret

    """ 
    // 开始或者关闭变量的自动备份（断电自动保存,默认为关闭状态）
    // en:是否开启,1：开启变量的自动备份,0：停止变量的自动备份
    """
    def NMC_SetBackedVarOnOff(devHandle,  en):
        libc.NMC_SetBackedVarOnOff.argtypes = [c_ushort,  c_short]
        return libc.NMC_SetBackedVarOnOff(devHandle,  en)

    """ 
    // 读取当前自动备份的开启状态
    // pEn:当前的开启状态
    """
    def NMC_GetBackedVarOnOff(devHandle):
        En_tmp = c_short()
        libc.NMC_GetBackedVarOnOff.argtypes = [c_ushort,  POINTER(c_short)]
        ret = libc.NMC_GetBackedVarOnOff(devHandle,  byref(En_tmp))
        return En_tmp, ret

    """ 
    paraID
    """
    PARA_IP_ADDR   	= 100		# IP地址,四个字节分别表示四段
    PARA_IP_MSK    	= 101		# IP mask
    PARA_IP_GW   	= 102		# Gateway
    PARA_IP_DHCP   	= 103		# DHCP
    PARA_WRITE_EN	= 999		# 参数保存
    """
    // 读取系统参数（long 型）
    // paraID :　系统参数ID,参见后面定义。pValue : 返回值
    // 注：此函数可用于设置板卡上的扩展资源
    """
    def NMC_DevGetPara(devHandle, paraID):
        Value_tmp = c_long()
        libc.NMC_DevGetPara.argtypes = [c_ushort,  c_ulong,  POINTER(c_long)]
        ret = libc.NMC_DevGetPara(devHandle,  paraID,  byref(Value_tmp))
        return Value_tmp, ret

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

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

        PasswordOld_bytes = PasswordOld.encode('ascii').ljust(16, b'\0')
        PasswordOld_tmp = create_string_buffer(PasswordOld_bytes)

        PasswordNew_bytes = PasswordNew.encode('ascii').ljust(16, b'\0')
        PasswordNew_tmp = create_string_buffer(PasswordNew_bytes)

        libc.NMC_UserSetPassword.argtypes = [c_ushort,  c_char_p,  c_char_p,  c_char_p]
        ret = libc.NMC_UserSetPassword(devHandle,  UserName_tmp,  PasswordOld_tmp,  PasswordNew_tmp)
        return ret

    """ 
    // 用户登陆
    // pUserName    : 指定的用户名,目前只支持"USER1"
    // pPassword    : 该用户的密码
    """
    def NMC_UserLogin(devHandle, UserName, Password):
        UserName_bytes = UserName.encode('ascii').ljust(16, b'\0')
        UserName_tmp = create_string_buffer(UserName_bytes)

        Password_bytes = Password.encode('ascii').ljust(16, b'\0')
        Password_tmp = create_string_buffer(Password_bytes)

        libc.NMC_UserLogin.argtypes = [c_ushort,  c_char_p,  c_char_p]
        ret = libc.NMC_UserLogin(devHandle,  UserName_tmp,  Password_tmp)
        return ret

    """ 
    // 用户退出登陆
    // pUserName    : 指定的用户名,目前只支持"USER1"
    """
    def NMC_UserLogout(devHandle, UserName):
        UserName_tmp = create_string_buffer(*UserName.encode('ascii'), 16)
        libc.NMC_UserLogout.argtypes = [c_ushort,  c_char_p]
        ret = libc.NMC_UserLogout(devHandle,  UserName_tmp)
        return ret

    """ 
    // 设置控制器的规划周期，默认1000
    // period：单位us	只能为250 500 1000
    // 注意：1.规划周期设置后立即生效，只能在控制器启动时配置
    //       2.NMC_DevReset会复位规划周期为默认值
    """
    def NMC_SetProfilePeriod(devHandle, period):
        libc.NMC_SetProfilePeriod.argtypes = [c_ushort,  c_short]
        return libc.NMC_SetProfilePeriod(devHandle,  period)

    """ 
    // 获取控制器的规划周期
    // period：单位us	只能为250 500 1000
    """
    def NMC_GetProfilePeriod(devHandle):
        Period_tmp = c_short()
        libc.NMC_GetProfilePeriod.argtypes = [c_ushort, POINTER(c_short)]
        ret = libc.NMC_GetProfilePeriod(devHandle,  byref(Period_tmp))
        return Period_tmp, ret

    """ 
    // 打印信息
    """
    def NMC_UserPrint(msg):
        message = msg.encode('utf-8')
        libc.NMC_UserPrint.argtypes = [c_char_p]
        ret = libc.NMC_UserPrint(message)
        return ret

    """------------------------------------------------------------------------------------------------------------
    //
    //	7.数据采集模块(高级指令)
    //
    //------------------------------------------------------------------------------------------------------------
    """
    # Collect模块：变量类型
    class CollectAddress(IntEnum):
        PRF_POS = 0       # 规划位置
        AXIS_POS = 1      # 机械位置
        ENC_POS = 2       # 编码器位置
        CMD_POS = 3       # 命令位置
        AXIS_VEL = 4      # 电机速度
        CRD_POS0 = 5      # 坐标系0位置
        CRD_VEL0 = 6      # 坐标系0速度
        ENC_VEL = 7       # 编码器速度
        CMD_VEL = 8       # 命令速度
        CRD_POS1 = 9      # 坐标系1位置
        CRD_VEL1 = 10     # 坐标系1速度
        LASER_OUTPUT = 11 # 激光输出(补偿前)
        LASER_GATE = 12   # 激光gate信号状态
        LASER_POWER = 13  # 激光能量当前输出值
        DI = 14           # 数字量输入状态
        DO = 15           # 数字量输出状态
        CRD_USERSEG = 16  # 坐标系用户段号
        DAC = 17          # 模拟量输出
        ADC = 18          # 模拟量输入
    """
    // 获取需要采集数据变量的地址
    //  index:变量的序号(从0开始)
    //  type: 变量的类型,参数‘Collect模块：变量类型’宏定义
    //  pAddr: 返回的数据地址
    //  pDataLen: 返回的该数据长度
    """
    def NMC_GetCollectDataAddr(devHandle, index, dataType):
        Addr_tmp = c_ulong()
        DataLen_tmp = c_short()
        libc.NMC_GetCollectDataAddr.argtypes = [c_ushort,  c_short,  c_short,  POINTER(c_ulong),  POINTER(c_short)]
        ret = libc.NMC_GetCollectDataAddr(devHandle,  index,  dataType,  byref(Addr_tmp),  byref(DataLen_tmp))
        return Addr_tmp, DataLen_tmp, ret

    """ 
    // 采集模块：采集配置
    """
    class TCollectCfg(Structure):
        _pack_ = 4
        _fields_ = [
            ("count", c_short),                       # 需要采集的变量个数
            ("interval", c_short),                    # 采集的间隔时间,0表示每隔1毫米采集一次数据,1表示每隔2ms...
            ("address", c_ulong * COLLECT_LIST_MAX),  # 变量的地址
            ("length", c_short * COLLECT_LIST_MAX)    # 每个变量的长度（单位：char）
        ]

    # 采集模块：触发模式
    COLLECT_MODE_NONE	= 0	# 无条件
    COLLECT_MODE_G_SRC1	= 1	# 采集源1数值大于比较值
    COLLECT_MODE_L_SRC1	= 2	# 采集源1数值小于比较值
    COLLECT_MODE_DIFF	= 3	# 采集源1与采集源2两项差值大于比较值
    class TCollectTrig(Structure):
        _fields_ = [
            ("mode", c_short),        # 触发模式
            ("source1", c_short),     # 触发源1
            ("source2", c_short),     # 触发源2
            ("startDelay", c_short),  # 触发启动延时
            ("value", c_double)       # 触发比较值
        ]
    """
    // 配置采集数据通道,需要配置对应结构体参数
    // pCollect:采集模块配置
    // pTrig:采集模块触发方式配置
    """
    def NMC_ConfigCollect(devHandle, Collect, Trig):
        libc.NMC_ConfigCollect.argtypes = [c_ushort,  POINTER(pymtn.TCollectCfg),  POINTER(pymtn.TCollectTrig)]
        ret = libc.NMC_ConfigCollect(devHandle, byref(Collect), byref(Trig))
        return ret

    """ 
    // 启动或停止数据采集
    // en：1启动 0停止
    """
    def NMC_CollectOnOff(devHandle,  en):
        libc.NMC_CollectOnOff.argtypes = [c_ushort,  c_short]
        return libc.NMC_CollectOnOff(devHandle,  en)

    """ Collect模块：采集状态"""
    COLLECT_BUSY						= 0x0001
    COLLECT_OVERRIDE_DATA				= 0x0002
    COLLECT_PUSH_DATA_ERR				= 0x0004
    """
    // 获取采集状态:
    // pSts：采集状态,按位表示各自状态,参考‘Collect模块：采集状态’宏定义
    // pDataLen: 采集的数据量
    """
    def NMC_GetCollectSts(devHandle):
        Sts_tmp = c_short()
        DataLen_tmp = c_long()
        libc.NMC_GetCollectSts.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_long)]
        ret = libc.NMC_GetCollectSts(devHandle,  byref(Sts_tmp),  byref(DataLen_tmp))
        return Sts_tmp, DataLen_tmp, ret

    """ 
    // 获取采数据:
    // len：采集数据长度（单位：char,一次最多读1440字节）
    // pData: 采集的数据（均以char为单元存储）
    """
    def NMC_GetCollectData(devHandle, data_len):
        buffer_size = 1440
        data_buffer = (c_ubyte * buffer_size)()
        libc.NMC_GetCollectData.argtypes = [c_ushort,  c_short,  POINTER(c_ubyte)]
        ret = libc.NMC_GetCollectData(devHandle,  data_len,  cast(data_buffer, POINTER(c_ubyte)))
        data_bytes = bytes(data_buffer)[:data_len]
        # 每4个字节转换为一个浮点数
        float_data = []
        for i in range(0, len(data_bytes), 8):
            if i + 8 <= len(data_bytes):
                value = struct.unpack('<d', data_bytes[i:i+8])[0]  # 小端双精度
                float_data.append(value )
        return float_data, ret

    """ 
    //清除采集状态
    """
    def NMC_ClearCollectSts(devHandle):
        libc.NMC_ClearCollectSts.argtypes = [c_ushort]
        return libc.NMC_ClearCollectSts(devHandle)

    """------------------------------------------------------------------------------------------------------------
    //
    //	8.激光
    //
    //------------------------------------------------------------------------------------------------------------
    """
    MAX_LASER_NUMS			        = 4	    # 最大激光通道
    
    # 激光控制模式
    LASER_DISABLE_MODE			    = 0	    # 禁用激光功能
    BASIC_OUTPUT_MODE			    = 1		# 基本控制模式
    TIME_ARRAY_OUTPUT_MODE			= 2    	# 波形控制模式
    SHIO_OUTPUT_MODE				= 3     # 位置比较控制模式
    """
    //设置激光控制的模式。该模式的设定,约束相应指令的功能和操作
    //mode: 激光控制模式,参考上述宏定义
    """
    def NMC_LaserSetMode(devHandle, mode, ch ):
        libc.NMC_LaserSetMode.argtypes = [c_ushort,  c_short,  c_short]
        return libc.NMC_LaserSetMode(devHandle,  mode,  ch )

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

    """ 
    // 激光物理信号输出类型配置
    // outputType：输出的类型
    // index :输出通道序号,取值范围[0,n]
    // optionVal: 当作为占空比输出时,该值为PWM的频率,单位HZ；
    //            当为LASER_PWM_FRQ时,该值作为占空比值,（0~100）；
    //            当为LASER_PWM_FRQ_EXT时,该值为脉宽,单位为0.5微秒,取值范围(0,~)
    // ch :激光通道,取值范围[0,n]
    """
    def NMC_LaserSetOutputType(devHandle, outputType, index, optionVal, ch):
        libc.NMC_LaserSetOutputType.argtypes = [c_ushort,  c_short,  c_short,  c_long,  c_short]
        ret = libc.NMC_LaserSetOutputType(devHandle,  outputType,  index,  optionVal,  ch)
        return ret

    """ 
    // 激光物理信号输出类型配置(高精度)
    // outputType：输出的类型
    // index :输出通道序号,取值范围[0,n]
    // optionVal: 当作为占空比输出时,该值为PWM的频率,单位HZ；
    //            当为LASER_PWM_FRQ时,该值作为占空比值,单位为百分比；
    //            当为LASER_PWM_FRQ_EXT时,该值为脉宽,单位为微秒,取值范围(0,~)
    // ch :激光通道,取值范围[0,n]
    """
    def NMC_LaserSetOutputTypeEx(devHandle, outputType, index, optionVal, ch):
        libc.NMC_LaserSetOutputTypeEx.argtypes = [c_ushort,  c_short,  c_short,  c_double,  c_short]
        ret = libc.NMC_LaserSetOutputTypeEx(devHandle,  outputType,  index,  optionVal,  ch)
        return ret

    """ 
    // 功能：设置立即输出激光的能量,
    // outVal: 激光能量（设定值意义与NMC_LaserSetOutputType设置的输出类型对应）
    // ch：输出通道 (需要根据不同物理信号端口数量进行设定)
    """
    def NMC_LaserSetPower(devHandle, outVal, ch):
        libc.NMC_LaserSetPower.argtypes = [c_ushort,  c_long,  c_short]
        return libc.NMC_LaserSetPower(devHandle,  outVal,  ch)

    """ 
    // 功能：读取当前激光的能量 
    // pVal: 激光能量值
    // ch：通道号
    """
    def NMC_LaserGetPower(devHandle, ch):
        Val_tmp = c_double()
        libc.NMC_LaserGetPower.argtypes = [c_ushort,  POINTER(c_double),  c_short]
        ret = libc.NMC_LaserGetPower(devHandle,  byref(Val_tmp),  ch)
        return Val_tmp, ret

    """ 
    // 功能：读取当前激光开关状态 
    // pOnOffState: 激光开关状态，1：激光处于打开状态，0:激光处于关闭状态
    // ch：通道号
    """
    def NMC_LaserGetOnOff(devHandle, ch):
        OnOffState_tmp = c_short()
        libc.NMC_LaserGetOnOff.argtypes = [c_ushort,  POINTER(c_short),  c_short]
        ret = libc.NMC_LaserGetOnOff(devHandle,  byref(OnOffState_tmp),  ch)
        return OnOffState_tmp, ret

    """ 
    // 功能：设置立即输出激光的能量(高精度)
    // chn：输出通道 (需要根据不同物理信号端口数量进行设定)
    // outVal: 激光能量（设定值意义与NMC_LaserSetOutputTypeEx设置的输出类型对应）
    """
    def NMC_LaserSetPowerEx(devHandle, outVal, ch):
        libc.NMC_LaserSetPowerEx.argtypes = [c_ushort,  c_double,  c_short]
        return libc.NMC_LaserSetPowerEx(devHandle,  outVal,  ch)

    """ 
    // 功能：激光立即输出开关 
    // onOffl: 0或者1表示打开或关闭激光输出
    // ch：输出通道 (需要根据不同物理信号端口数量进行设定)
    """
    def NMC_LaserOnOff(devHandle, onOff, ch):
        libc.NMC_LaserOnOff.argtypes = [c_ushort,  c_short,  c_short]
        return libc.NMC_LaserOnOff(devHandle,  onOff,  ch)

    """ 设置激光参数
    // onDelay:开光延时,单位us,取值范围[0,65535]
    // offDelay:关光延时,单位us,取值范围[0,65535]
    // minValue:最小输出值,取值范围[0,32767]
    // maxValue:最大输出值,取值范围[0,32767]
    // standbyPower:待机能量,为0表示取消待机能量输出功能
    // ch:激光控制通道
    """
    def NMC_LaserSetParam(devHandle,  onDelay , offDelay,  minValue , maxValue, standbyPower, ch):
        libc.NMC_LaserSetParam.argtypes = [c_ushort,  c_long,  c_long,  c_long,  c_long,  c_long,  c_short]
        return libc.NMC_LaserSetParam(devHandle,  onDelay ,  offDelay,  minValue ,  maxValue,  standbyPower,  ch)

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

    """ 
    // 读取激光参数
    """
    def NMC_LaserGetParam(devHandle,  ch):
        OnDelay_tmp = c_long()
        OffDelay_tmp = c_long()
        MinValue_tmp = c_long()
        MaxValue_tmp = c_long()
        StandbyPower_tmp = c_long()
        libc.NMC_LaserGetParam.argtypes = [c_ushort,  POINTER(c_long),  POINTER(c_long),  POINTER(c_long),  POINTER(c_long),  POINTER(c_long),  c_short]
        ret = libc.NMC_LaserGetParam(devHandle,  byref(OnDelay_tmp),  byref(OffDelay_tmp),  byref(MinValue_tmp), byref(MaxValue_tmp), byref(StandbyPower_tmp),  ch)
        return OnDelay_tmp, OffDelay_tmp, MinValue_tmp, MaxValue_tmp, StandbyPower_tmp, ret

    """ 
    // 设置缓冲区激光能量跟随
    // segNo:段号
    // overRide:跟随倍率,为0表示取消激光能量跟随
    // followType:跟随类型,0：跟随规划速度,1：跟随实际速度
    // ch:激光通道号,取值范围[0,n]
    """
    def NMC_CrdBufLaserSetFollow(crdHandle, segNo, overRide, followType, ch):
        libc.NMC_CrdBufLaserSetFollow.argtypes = [c_ushort,  c_long,  c_double,  c_short,  c_short]
        ret = libc.NMC_CrdBufLaserSetFollow(crdHandle,  segNo,  overRide,  followType,  ch)
        return ret

    """ 
    // 设置缓冲区激光能量跟随
    // powerFilter:能量输出滤波系数，取值范围[0,32]，0：不开启（默认）
    // followAdvMode:能量输出计算方法能量输出计算方法，0 最小值截取模式 1 最小值起点模式
    // ch:激光通道号,取值范围[0,n]
    """
    def NMC_LaserSetFollowParam(devHandle, powerFilter, followAdvMode, ch):
        libc.NMC_LaserSetFollowParam.argtypes = [c_ushort,  c_short,  c_short,  c_short]
        return libc.NMC_LaserSetFollowParam(devHandle,  powerFilter,  followAdvMode,  ch)

    """ 
    // 缓冲区激光开关
    // segNo:段号
    // onOff:开关,0：关光,1：开光
    // ch:激光控制通道
    """
    def NMC_CrdBufLaserOnOff(crdHandle, segNo, onOff, ch):
        libc.NMC_CrdBufLaserOnOff.argtypes = [c_ushort,  c_long,  c_short,  c_short]
        return libc.NMC_CrdBufLaserOnOff(crdHandle,  segNo,  onOff,  ch)

    """ 
    // 缓冲区设置激光能量,激光能量跟随模式下,调用这条指令无效
    // segNo:段号
    // power:能量
    // ch:激光控制通道
    """
    def NMC_CrdBufLaserPower(crdHandle, segNo, power, ch):
        libc.NMC_CrdBufLaserPower.argtypes = [c_ushort,  c_long,  c_long,  c_short]
        return libc.NMC_CrdBufLaserPower(crdHandle,  segNo,  power,  ch)

    # 激光能量补偿数据表单方向长度最大值
    LASER_CMP_DATA_LEN_MAX			= 10
    """ 
    // 设置激光能量补偿表
    // tableNo： 补偿表号 ：支持20张表
    // pXCmpPos：X方向轴的比较位置,长度为xCount  
    // pYCmpPos: Y方向轴的比较位置,长度为yCount  
    // xCount： 表X方向的长度,取值范围[2,10]
    // yCount： 表Y方向的长度,取值范围[2,10]
    // powerMin:	大于该最小能量才补偿
    // powerMax:	小于该最大能量才补偿
    // pLaserCmpPower：补偿表的值，该参数为2维数组的首地址
    // chn:对应的激光通道号
    """
    def NMC_SetLaserPowerCmpTable(devHandle, tableNo, XCmpPos, YCmpPos, xCount, yCount, powerMin,powerMax, LaserCmpPower, chn):
        XCmpPos_tmp = (c_long * xCount)(*XCmpPos)
        YCmpPos_tmp = (c_long * yCount)(*YCmpPos)
        LaserCmpPower_tmp = (c_ulong * len(LaserCmpPower))(*LaserCmpPower)
        libc.NMC_SetLaserPowerCmpTable.argtypes = [c_ushort,  c_short,  POINTER(c_long),  POINTER(c_long),  c_short,  c_short,  c_ulong,  c_ulong,  POINTER(c_ulong),  c_short]
        ret = libc.NMC_SetLaserPowerCmpTable(devHandle,  tableNo,  XCmpPos_tmp,  YCmpPos_tmp,  xCount,  yCount,  powerMin,  powerMax,  LaserCmpPower_tmp,  chn)
        return ret

    """ 
    // 启动激光能量补偿
    // pAxisNo： pAxisNo[0]表X方向的位置比较轴号 pAxisNo[1]表Y方向的位置比较轴号
    // chn：补偿输出给哪路激光通道
    """
    def NMC_StartLaserPowerComp(devHandle, AxisNo, chn):
        AxisNo_tmp = (c_short * 2)(*AxisNo)
        libc.NMC_StartLaserPowerComp.argtypes = [c_ushort,  POINTER(c_short),  c_short]
        ret = libc.NMC_StartLaserPowerComp(devHandle,  AxisNo_tmp,  chn)
        return ret

    """ 
    // 停止激光能量补偿
    """
    def NMC_StopLaserPowerComp(devHandle, chn):
        libc.NMC_StopLaserPowerComp.argtypes = [c_ushort,  c_short]
        return libc.NMC_StopLaserPowerComp(devHandle,  chn)

    class TTimeArrayPara(Structure):
        _fields_ = [
            ("pwmEnable", c_short),   # 是否需要输出PWM,0:立即输出一个波形，1：根据位移周期输出
            ("outputType", c_short),  # 开关信号输出类型：0：gate,1：GPO
            ("outputCh", c_short),    # 开关信号输出通道
            ("stLevelRevs", c_short), # SHIO输出电平取反,默认为0，不取反
            ("pwmPeriod", c_long),    # 保留,PWM周期,单位us,不能小于时间数组的总周期
            ("pwmWidth", c_long),     # 保留,PWM脉宽,单位us,此参数保留,脉宽等于时间数组的总周期
            ("gateDistance", c_long), # 固定模式下的位置间隔 单位：pulse。默认0,模式2~4 下会进行有效性检查
            ("minFrqFrq", c_long),    # 保留,SHIO输出最低频率，单位HZ
            ("posSrc", c_short),      # 比较模式,外部编码器还是内部规划值。0：外部编码器（推荐）,1：内部规划值。默认0。
            ("axisMask", c_short),    # 轴号,按bit 位对应。（一般两个轴）。默认 0。
            ("minFrqEn", c_short),    # 保留,是否启用SHIO输出最低频率，默认0，不启用
            ("reserved2", c_short)    # 保留
        ]
    """
    // 设置时间数组输出参数
    // ch : 激光通道
    // pPara ： 参数
    // 注：1.仅时间数组输出方式下有效
    """
    def NMC_LaserSetTimeArrayPara (devHandle,Para, ch):
        libc.NMC_LaserSetTimeArrayPara.argtypes = [c_ushort,  POINTER(pymtn.TTimeArrayPara),  c_short]
        ret = libc.NMC_LaserSetTimeArrayPara(devHandle,  byref(Para),  ch)
        return ret

    class TLaserPower(Structure):
        _fields_ = [
            ("time", c_ushort * LASER_POINT),  # 每个点之间的间隔时间,单位:100微秒
            ("power", c_short * LASER_POINT),  # 各点的能量大小
            ("count", c_short)                 # 实际压入点数
        ]
    """ 
    // 设置激光的能量,对于立即输出模式,group无效,pLaserPower为指定的单个能量信息
    // group : 设置哪一组激光能量
    // pLaserPower ： 设置的数据
    // 注：1.即波形设置 
    //     2.该接口对于SHIO模式无效
    """
    def NMC_LaserSetTimeArrayPower(devHandle, group, LaserPower):
        libc.NMC_LaserSetTimeArrayPower.argtypes = [c_ushort,  c_short,  POINTER(pymtn.TLaserPower)]
        ret = libc.NMC_LaserSetTimeArrayPower(devHandle,  group,  byref(LaserPower))
        return ret

    """ 
    // 执行时间序列激光,只在时间序列输出模式下有效
    // group : 设置哪一组激光能量
    // ch:激光通道
    // 注：1.启用时间数组输出后,直到最后一个点,如果最后一个点能量不为0,则维持最后一个能量输出
    //    2.如果最后一个点能量为0,且没有PWM输出配合,则自动关闭激光。有PWM配合则需要调用NMC_LaserOnOff或者NMC_CrdBufLaserOnOff关闭激光
    """
    def NMC_LaserTimeArrayExe(devHandle,  group, ch ):
        libc.NMC_LaserTimeArrayExe.argtypes = [c_ushort,  c_short,  c_short]
        return libc.NMC_LaserTimeArrayExe(devHandle,  group,  ch )

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

    class TSHIOPara(Structure):
        _fields_ = [
            ("isArray", c_short),    # 是否固定间距还是数组。0：固定间距（仅支持）,默认0
            ("outMode", c_short),    # 输出模式。默认1
                                     # 1：只输出gate 立即开或关,
                                     # 2: 根据位移输出gate
                                     # 3: 根据位移输出gate,gate 和同部trigger 信号同步
                                     # 4: 根据位移输出gate,gate 和信号输入同步

            ("posSrc", c_short),     # 比较模式（0=外部编码器，1=内部规划值）
            ("axisMask", c_short),   # 轴号,按bit 位对应。（一般两个轴）。
            ("delay", c_double),     # 延时开关光时间( 暂不用 ),单位：s。默认 0。
            ("gateTime", c_double),  # 设置gate 打开时间,单位：s（内部最小值：1/36us ）,取值范围(0,0.0009)
            ("gateDistance", c_long),# 固定模式位置间隔(pulse),默认0,模式2~4 下会进行有效性检查。
            ("k", c_long),           # 低频过渡系数
            ("startDot", c_long),    # 启动时出光打点
            ("reserved3", c_long),   # 保留参数,应设为0。
            ("reserved4", c_long),   # 保留参数,应设为0。
            ("reserved5", c_long)    # 保留参数,应设为0。
        ]
    """ 
    // 配置SHIO功能的参数
    """
    def NMC_SHIOConfigPara(devHandle, SHIOPara, ch):
        libc.NMC_SHIOConfigPara.argtypes = [c_ushort,  POINTER(pymtn.TSHIOPara),  c_short]
        ret = libc.NMC_SHIOConfigPara(devHandle,  byref(SHIOPara),  ch)
        return ret

    """ 
    // SHIO输出的最小频率功能开
    // minFrq:最低频率，单位HZ
    """
    def NMC_SHIOEnableMinFrq(devHandle, minFrq, ch):
        libc.NMC_SHIOEnableMinFrq.argtypes = [c_ushort,  c_long,  c_short]
        return libc.NMC_SHIOEnableMinFrq(devHandle,  minFrq,  ch)

    """ 
    // SHIO输出的最小频率功能关闭
    """
    def NMC_SHIODisableMinFrq(devHandle, ch):
        libc.NMC_SHIODisableMinFrq.argtypes = [c_ushort,  c_short]
        return libc.NMC_SHIODisableMinFrq(devHandle,  ch)

    """ 
    // 缓冲区配置SHIO功能的参数
    """
    def NMC_CrdBufSHIOConfigPara(crdHandle,  segment, SHIOPara, ch):
        libc.NMC_CrdBufSHIOConfigPara.argtypes = [c_ushort,  c_long,  POINTER(pymtn.TSHIOPara),  c_short]
        ret = libc.NMC_CrdBufSHIOConfigPara(crdHandle,  segment,  byref(SHIOPara),  ch)
        return ret

    """ 
    // 缓冲区SHIO输出的最小频率功能开
    // minFrq:最低频率，单位HZ
    """
    def NMC_CrdBufSHIOSetMinFrq(crdHandle,  segment,  minFrq, ch):
        libc.NMC_CrdBufSHIOSetMinFrq.argtypes = [c_ushort,  c_long,  c_long,  c_short]
        return libc.NMC_CrdBufSHIOSetMinFrq(crdHandle,  segment,  minFrq,  ch)

    """ 
    // 缓冲区SHIO输出的最小频率功能关闭
    """
    def NMC_CrdBufSHIOClrMinFrq(crdHandle,  segment, ch):
        libc.NMC_CrdBufSHIOClrMinFrq.argtypes = [c_ushort,  c_long,  c_short]
        return libc.NMC_CrdBufSHIOClrMinFrq(crdHandle,  segment,  ch)

    """ 
    // 缓冲区配置SHIO功能的参数
    // delay:延时开关光时间( 暂不用 ),单位：s。默认 0。
    // gateTime:设置gate 打开时间,单位：s（内部最小值：1/36us ）,取值范围(0,0.0009),默认0。
    // gateDistance:固定模式下的位置间隔 单位：pulse。
    """
    def NMC_CrdBufSHIOSetParam(crdHandle,  segment, delay, gateTime, gateDistance, ch):
        libc.NMC_CrdBufSHIOSetParam.argtypes = [c_ushort,  c_long,  c_double,  c_double,  c_double,  c_short]
        ret = libc.NMC_CrdBufSHIOSetParam(crdHandle,  segment,  delay,  gateTime,  gateDistance,  ch)
        return ret

    """ 
    // 切换轴（允许和坐标系不完全一致）
    """
    def NMC_SHIOChangeAxisMask(devHandle,  axisMask, ch ):
        libc.NMC_SHIOChangeAxisMask.argtypes = [c_ushort,  c_short,  c_short]
        return libc.NMC_SHIOChangeAxisMask(devHandle,  axisMask,  ch )

    """ 
    // 切换轴（允许和坐标系不完全一致）,缓冲区指令
    """
    def NMC_CrdBufSHIOChangeAxisMask(crdHandle,  segment,  axisMask, ch ):
        libc.NMC_CrdBufSHIOChangeAxisMask.argtypes = [c_ushort,  c_long,  c_short,  c_short]
        return libc.NMC_CrdBufSHIOChangeAxisMask(crdHandle,  segment,  axisMask,  ch )

    """ 
    // 允许GATE输出
    // 注：设置后根据模式输出
    """
    def NMC_SHIOGateOn(devHandle , ch):
        libc.NMC_SHIOGateOn.argtypes = [c_ushort,  c_short]
        return libc.NMC_SHIOGateOn(devHandle ,  ch)

    """ 
    // 禁止GATE输出
    // 注：设置后立即禁止输出
    """
    def NMC_SHIOGateOff(devHandle , ch):
        libc.NMC_SHIOGateOff.argtypes = [c_ushort,  c_short]
        return libc.NMC_SHIOGateOff(devHandle ,  ch)

    """ 
    // 设置Trigger 输出,
    // triggerFreq : 设置triger 脉冲频率单位：HZ。
    // triggerWidth : 设置triger 脉冲宽度,单位：s（内部最小值：1/36us ）。默认0。
    // 注：设置后立即输出
    """
    def NMC_SHIOTriggerOn(devHandle, freq, width , ch):
        libc.NMC_SHIOTriggerOn.argtypes = [c_ushort,  c_double,  c_double,  c_short]
        return libc.NMC_SHIOTriggerOn(devHandle,  freq,  width ,  ch)

    """ 
    // 禁止GATE输出
    // 注：设置后马上输出
    """
    def NMC_SHIOTriggerOff(devHandle , ch):
        libc.NMC_SHIOTriggerOff.argtypes = [c_ushort,  c_short]
        return libc.NMC_SHIOTriggerOff(devHandle ,  ch)

    """ 
    // 允许GATE输出
    // 注：设置后根据模式输出
    """
    def NMC_BufSHIOGateOn(crdHandle,  segNo, ch):
        libc.NMC_BufSHIOGateOn.argtypes = [c_ushort,  c_long,  c_short]
        return libc.NMC_BufSHIOGateOn(crdHandle,  segNo,  ch)

    """
    // 禁止GATE输出
    //注：缓冲区执行到该指令后立即禁止输出
    """
    def NMC_BufSHIOGateOff(crdHandle,  segNo, ch):
        libc.NMC_BufSHIOGateOff.argtypes = [c_ushort,  c_long,  c_short]
        return libc.NMC_BufSHIOGateOff(crdHandle,  segNo,  ch)

    """ 
    // PWM映射到GATE引脚输出
    // pwmCh:pwm 通道号
    // gateCh:gate信号通道号
    // onOff: 0 -- 不映射，1 -- 映射 （默认为0）
    """
    def NMC_SetPwmToGate(devHandle,  pwmCh, gateCh, onOff):
        libc.NMC_SetPwmToGate.argtypes = [c_ushort,  c_short,  c_short,  c_short]
        return libc.NMC_SetPwmToGate(devHandle,  pwmCh,  gateCh,  onOff)

    """ 
    // 缓冲区SHIO点动出光，输出一段gate脉冲,注意：必须在激光SHIO控制模式下使用
    // gateTime:gate输出的脉宽，单位：微秒
    // gateFrq:gate输出的频率，单位：HZ
    // outCount:输出个数
    // ch:通道
    """
    def NMC_CrdBufSHIOGatePulse(crdHandle, segNo, gateTime, gateFrq, outCount, ch):
        libc.NMC_CrdBufSHIOGatePulse.argtypes = [c_ushort,  c_long,  c_double,  c_double,  c_long,  c_short]
        ret = libc.NMC_CrdBufSHIOGatePulse(crdHandle,  segNo,  gateTime,  gateFrq,  outCount,  ch)
        return ret

    """ 
    // SHIO点动出光，输出一段gate脉冲,注意：必须在激光SHIO控制模式下使用
    // gateTime:gate输出的脉宽，单位：微秒
    // gateFrq:gate输出的频率，单位：HZ
    // outCount:输出个数
    // ch:通道
    """
    def NMC_SHIOGatePulse(devHandle, gateTime,  gateFrq, outCount, ch):
        libc.NMC_SHIOGatePulse.argtypes = [c_ushort,  c_double,  c_double,  c_long,  c_short]
        ret = libc.NMC_SHIOGatePulse(devHandle,  gateTime,  gateFrq,  outCount,  ch)
        return ret

    """ 
    // 输出一段PWM脉冲,注意：必须在激光SHIO控制模式下使用
    // onTime:PWM输出的脉宽，单位：微秒
    // pwmFrq:PWM输出的频率，单位：HZ
    // outCount:输出个数
    // ch:通道
    """
    def NMC_PwmPulseOut(devHandle, onTime,  pwmFrq, outCount, ch):
        libc.NMC_PwmPulseOut.argtypes = [c_ushort,  c_double,  c_double,  c_long,  c_short]
        ret = libc.NMC_PwmPulseOut(devHandle,  onTime,  pwmFrq,  outCount,  ch)
        return ret

    """------------------------------------------------------------------------------------------------------------
    //
    //	9.龙门
    //
    //------------------------------------------------------------------------------------------------------------
    """
    """
    // 设置龙门主动轴
    // axisHandle: 龙门主动轴句柄
    // group     : 龙门组号,取值范围[0,n]
    """
    def NMC_SetGantryMaster(axisHandle,  group ):
        libc.NMC_SetGantryMaster.argtypes = [c_ushort,  c_short]
        return libc.NMC_SetGantryMaster(axisHandle,  group )

    """ 
    // 设置龙门从动轴
    // axisHandle  : 龙门从动轴句柄;
    // group       : 龙门组号,取值范围[0,n]
    // gantryErrLmt: 龙门保护误差,取值范围(0,...)
    """
    def NMC_SetGantrySlave(axisHandle ,  group,  gantryErrLmt ):
        libc.NMC_SetGantrySlave.argtypes = [c_ushort,  c_short,  c_long]
        return libc.NMC_SetGantrySlave(axisHandle ,  group,  gantryErrLmt )

    """ 
    // 龙门功能关闭
    // group :       龙门组号,取值范围[0,n]
    """
    def NMC_DelGantryGroup(axisHandle,  group ):
        libc.NMC_DelGantryGroup.argtypes = [c_ushort,  c_short]
        return libc.NMC_DelGantryGroup(axisHandle,  group )

    """------------------------------------------------------------------------------------------------------------
    //
    //	10.通讯扩展等其他
    //
    //------------------------------------------------------------------------------------------------------------
    """

    """ 
    # "devHandle" > 控制器句柄
    # "sendBuffer" > 写入数据 
    # "sendLen" > 写入长度 
    # "recBuffer" > 读出数据 
    # "waitLen" > 读出长度 
    """
    """
    // 通讯扩展
    // 用户指令传输,只写
    """
    def NMC_UserCmdWrite(devHandle, sendBuffer, sendLen):
        sendBuffer_tmp = (c_ubyte * sendLen)(*sendBuffer)
        libc.NMC_UserCmdWrite.argtypes = [c_ushort,  POINTER(c_ubyte),  c_ulong]
        ret = libc.NMC_UserCmdWrite(devHandle,  sendBuffer_tmp,  sendLen )
        return ret

    """
    // 用户指令传输,只读
    """
    def NMC_UserCmdRead(devHandle, sendBuffer, sendLen, recBuffer, waitLen):
        libc.NMC_UserCmdRead.argtypes = [c_ushort, POINTER(c_uint8), c_uint32, POINTER(c_uint8), c_uint32]
        libc.NMC_UserCmdRead.restype = c_short
        ret = libc.NMC_UserCmdRead(devHandle, sendBuffer, sendLen, recBuffer, waitLen)
        return ret

    """ 
    // 批量数据传输,只写
    """
    def NMC_DataTransfer(devHandle, sendBuffer, sendLen):
        sendBuffer_tmp = (c_ubyte * sendLen)(*sendBuffer)
        libc.NMC_DataTransfer.argtypes = [c_ushort, POINTER(c_ubyte),  c_ulong]
        ret = libc.NMC_DataTransfer(devHandle,  sendBuffer_tmp,  sendLen)
        return ret

    """ 
    // 禁止用户程序运行
    """
    def NMC_SysSetUserApp(devHandle,  mode):
        libc.NMC_SysSetUserApp.argtypes = [c_ushort,  c_ubyte]
        return libc.NMC_SysSetUserApp(devHandle,  mode )

    """ 
    // 升级
    """
    def NMC_SysUpgrade(devHandle ):
        libc.NMC_SysUpgrade.argtypes = [c_ushort]
        return libc.NMC_SysUpgrade(devHandle)

    """ 
    // 升级固件
    """
    def NMC_SysUpgradeEx(devHandle, cmd, sendBuffer, sendLen, recvedLen):
        sendBuffer_tmp = (c_ubyte * len(sendBuffer))(*sendBuffer)
        recBuffer_tmp = (c_ubyte * recvedLen)()
        libc.NMC_SysUpgradeEx.argtypes = [c_ushort,  c_ubyte,  POINTER(c_ubyte),  c_ulong,  POINTER(c_ubyte),  c_ulong]
        ret = libc.NMC_SysUpgradeEx(devHandle,  cmd,  sendBuffer_tmp,  sendLen,  recBuffer_tmp,  recvedLen )
        return ret

    """ 
    // 设置调试信息
    """
    def NMC_SetDebugErrorEn(devHandle, debugErrEn ):
        libc.NMC_SetDebugErrorEn.argtypes = [c_ushort,  c_short]
        return libc.NMC_SetDebugErrorEn(devHandle,  debugErrEn)

    """ 
    // 读取最后一次的错误代码
    // 返回值：错误代码
    """
    def NMC_GetLastErr():
        libc.NMC_GetLastErr.argtypes = []
        return libc.NMC_GetLastErr()

    """ 
    // 设置指令错误返回值模式
    // mode:0-标准模式,将返回详细的错误代码(默认)；1--简洁模式,只返回错误代码类别
    """
    def NMC_SetErrCodeMode(mode):
        libc.NMC_SetErrCodeMode.argtypes = [c_short]
        return libc.NMC_SetErrCodeMode(mode)

    """ 
    // 设置指令通讯看门狗
    // timeout:看门狗超时时间,单位毫秒,小于等于0代表关闭看门狗功能
    // stopMode:超时停止模式,1:马上停止,0:缓冲区执行完毕后停止
    // groupID:超时输出do的组号
    // doValue:超时输出do状态
    """
    def NMC_SetWatchDog(devHandle, timeout, stopMode, groupID, doValue):
        libc.NMC_SetWatchDog.argtypes = [c_ushort,  c_long,  c_short,  c_short,  c_long]
        return libc.NMC_SetWatchDog(devHandle,  timeout,  stopMode,  groupID,  doValue)

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

        def __init__(self):
            super().__init__()
            self.timeOut = 0
            self.stopMode = 0
            self.stopModeVar = 0
            self.stopModeGpo = 0
            self.gpoGroupID = 0
            self.gpoOutMask = 0
            self.gpoOutValue = 0
            for i in range(8):
                self.reserved[i] = 0

    def NMC_SetWatchDogEx(devHandle, Prm):
        libc.NMC_SetWatchDogEx.argtypes = [c_ushort, POINTER(pymtn.TWatchDogEx)]
        return libc.NMC_SetWatchDogEx(devHandle, byref(Prm))

    """------------------------------------------------------------------------------------------------------------
    //
    //	11.手轮
    //
    //------------------------------------------------------------------------------------------------------------
    """
    """
    // 退出手轮
    """
    def NMC_ClrHandWheel(devHandle):
        libc.NMC_ClrHandWheel.argtypes = [c_ushort]
        return libc.NMC_ClrHandWheel(devHandle)

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

    """ 
    // 选择手轮跟随的编码器通道
    // index:编码器通道编号,如果是轴通道,取值范围[0,n]
    //                    如果是扩展编码器通道,则256表示第一个扩展编码器通道,257表示第二个,以此类推
    """
    def NMC_SetHandWheelInput(devHandle, index):
        libc.NMC_SetHandWheelInput.argtypes = [c_ushort,  c_short]
        return libc.NMC_SetHandWheelInput(devHandle,  index)

    """ 
    // 设置手轮跟随的倍率
    // ratio:跟随倍率,取值范围(0,..]
    """
    def NMC_SetHandWheelRatio(devHandle, ratio):
        libc.NMC_SetHandWheelRatio.argtypes = [c_ushort,  c_double]
        return libc.NMC_SetHandWheelRatio(devHandle,  ratio)

    """------------------------------------------------------------------------------------------------------------
    //
    //	12.PT
    //
    //------------------------------------------------------------------------------------------------------------
    """
    """
    // onOff:		1：数据驻存模式   0：数据刷新模式(默认模式)
    // loopCount:	循环次数 ：仅数据驻存模式下有效
    """
    def NMC_MtPtSetStatic(axisHandle, onOff, loopCount):
        libc.NMC_MtPtSetStatic.argtypes = [c_ushort,  c_short,  c_long]
        return libc.NMC_MtPtSetStatic(axisHandle,  onOff,  loopCount)

    """ 
    // onOff:		1：数据驻存模式   0：数据刷新模式(默认模式)
    // loopCount:	循环次数 ：仅数据驻存模式下有效
    """
    def NMC_MtPtGetStatic(axisHandle):
        OnOff_tmp = c_short()
        LoopCount_tmp = c_long()
        libc.NMC_MtPtGetStatic.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_long)]
        ret = libc.NMC_MtPtGetStatic(axisHandle,  byref(OnOff_tmp),  byref(LoopCount_tmp))
        return OnOff_tmp, LoopCount_tmp, ret

    """ 
    // 查询PT数据剩余空间大小
    // pSpace:返回的剩余空间大小
    // pUsed: 已使用的空间段数
    """
    def NMC_MtPtGetSpace(axisHandle):
        Space_tmp = c_short()
        Used_tmp = c_short()
        libc.NMC_MtPtGetSpace.argtypes = [c_ushort, POINTER(c_short),  POINTER(c_short)]
        ret = libc.NMC_MtPtGetSpace(axisHandle,  byref(Space_tmp),  byref(Used_tmp))
        return Space_tmp, Used_tmp, ret

    # PT数据段类型
    MT_PT_NORMAL	= 0 # 普通段，第 1 段的起点速度为 0，从第 2 段起每段的起点速度等上一段的终点速度。
    MT_PT_STOP		= 1 # 停止段，该段的终点速度为 0，起点速度根据段内位移和段内时间计算得到，和上一段的终点速度无关。
    MT_PT_EVEN		= 2 # 匀速段，该段的段内速度保持不变，段内速度=段内位移/段内时间
    """ 
    // 向Pt运动缓存区中压运动数据段
    // count:压入的数据段数
    // pPosArray:段运行距离
    // pTimeArray:段运行时间
    // pTypeArray:段类型,见宏定义
    """
    def NMC_MtPtPush(axisHandle, count, PosArray, TimeArray, TypeArray):
        PosArray_tmp = (c_double * count)(*PosArray)
        TimeArray_tmp = (c_long * count)(*TimeArray)
        TypeArray_tmp = (c_short * count)(*TypeArray)
        libc.NMC_MtPtPush.argtypes = [c_ushort,  c_short,  POINTER(c_double),  POINTER(c_long),  POINTER(c_short)]
        ret = libc.NMC_MtPtPush(axisHandle,  count,  PosArray_tmp,  TimeArray_tmp,  TypeArray_tmp)
        return ret

    """ 
    // 清空PT数据
    """
    def NMC_MtPtBufClr(axisHandle):
        libc.NMC_MtPtBufClr.argtypes = [c_ushort]
        return libc.NMC_MtPtBufClr(axisHandle)

    """ 
    // 启动Pt运动
    // otherSynAxCnts： 不包括axisHandle 的其他同步启动轴数量
    // pOtherSynAxArray: 其他同步启动轴的序号：0~N	
    // 注：同步的轴必须属于同一个控制器
    """
    def NMC_MtPtStartMtn(axisHandle, otherSynAxCnts, OtherSynAxArray):
        OtherSynAxArray_tmp = (c_short * otherSynAxCnts)(*OtherSynAxArray)
        libc.NMC_MtPtStartMtn.argtypes = [c_ushort,  c_short,  POINTER(c_short)]
        ret = libc.NMC_MtPtStartMtn(axisHandle,  otherSynAxCnts,  OtherSynAxArray_tmp)
        return ret


    """-------------------------------------------------------------------------------
    // 13.线性距离位置比较
    //-------------------------------------------------------------------------------
    """
    #   精确输出结构体
    class TLinearCmpPara(Structure):
        _fields_ = [
            ("dimens", c_short),  # 维度
            ("compMode", c_short),  # 比较模式
            ("axMask", c_short),  # 轴掩码
            ("src", c_short),  # 源
            ("gateTime", c_double)  # 门时间
        ]

        def __init__(self):
            super().__init__()
            self.dimens = 0
            self.compMode = 0
            self.axMask = 0
            self.src = 0
            self.gateTime = 0.0
    """
    // 功能：设置精确位置比较的参数，并清除线性位置比较位置数据
    // dimens:比较的维数 1或者2
    // axisMask：选比较的轴号,按bit选择:不能超过2个bit同时为1
    // src：比较源：1:编码器位置  0：规划位置
    // cmpMode：比较的模式：0 按输出数组位置比较,1 线性比较,按interval间距比较
    // gateTime:输出的脉冲宽度
    // chn：输出通道 目前只支持0
    """
    def NMC_LinearCompSetParam(devHandle, dimens,  axisMask, src, cmpMode, gateTime, chn):
        libc.NMC_LinearCompSetParam.argtypes = [c_ushort,  c_short,  c_short,  c_short,  c_short,  c_double,  c_short]
        ret = libc.NMC_LinearCompSetParam(devHandle,  dimens,  axisMask,  src,  cmpMode,  gateTime,  chn)
        return ret

    """ 
    // 获取配置参数
    """
    def NMC_LinearCompGetParam(devHandle,LinearCmpPara, chn):
        libc.NMC_LinearCompGetParam.argtypes = [c_ushort,  POINTER(pymtn.TLinearCmpPara),  c_short]
        ret = libc.NMC_LinearCompGetParam(devHandle,  byref(LinearCmpPara),  chn)
        return LinearCmpPara, ret

    """ 
    // 功能：设置精确比较位置数据
    // pStartPos：起始比较位置，注意：暂时没用
    // pPos :比较的位置数组地址。
    //		 注意：这里为相对距离，第一点为相对于NMC_LinearCompOnOff调用时的位置的距离，第二点为相对第一点的距离
    // count：比较的位置个数，最大不能超过250，如果比较数据过多，可以通过多次调用的方式下压数据，缓冲区长度
    // chn：输出通道 目前只支持0
    """
    def NMC_LinearCompSetData(devHandle, Pos, count, chn):
        StartPos_tmp = c_long()
        Pos_tmp = (c_long * count)(*Pos)
        libc.NMC_LinearCompSetData.argtypes = [c_ushort,  POINTER(c_long),  POINTER(c_long),  c_long,  c_short]
        ret = libc.NMC_LinearCompSetData(devHandle,  byref(StartPos_tmp),  Pos_tmp,  count,  chn)
        return ret

    """ 
    // 功能：线性比较输出
    // pStartPos：起始比较位置
    // interval:线性比较间距（小于32767）
    // count: 线性比较次数
    """
    def NMC_LinearCompInterval(devHandle, StartPos, interval, count,  chn):
        StartPos_tmp = c_long(StartPos)
        libc.NMC_LinearCompInterval.argtypes = [c_ushort,  POINTER(c_long),  c_long,  c_long,  c_short]
        ret = libc.NMC_LinearCompInterval(devHandle,  byref(StartPos_tmp),  interval,  count,  chn)
        return ret
    """ 
    // 功能：精确位置比较使能
    // onOff： 0 停止,1输出
    // chn：输出通道 目前只支持0
    """
    def NMC_LinearCompOnOff(devHandle, onOff,  chn):
        libc.NMC_LinearCompOnOff.argtypes = [c_ushort,  c_short,  c_short]
        return libc.NMC_LinearCompOnOff(devHandle,  onOff,  chn)

    """ 
    // 功能：比较的输出状态
    // pStatus: 0 未启动比较 1 比较输出中
    // pOutCount：输出的个数,对于数组输出模式，输出计数计算请咨询我们
    // chn：输出通道 目前只支持0
    """
    def NMC_LinearCompStatus(devHandle, chn):
        Status_tmp = c_short()
        OutCount_tmp = c_short()
        libc.NMC_LinearCompStatus.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_short),  c_short]
        ret = libc.NMC_LinearCompStatus(devHandle,  byref(Status_tmp),  byref(OutCount_tmp),  chn)
        return Status_tmp, OutCount_tmp, ret

    """-------------------------------------------------------------------------------
    //14.二维位置点比较
    //-------------------------------------------------------------------------------
    """

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

    """
    // 功能：设置2维位置比较的参数
    // param: 二维比较参数
    // group:组号,0 或者1
    // chn:保留,设为0
    """
    def NMC_Comp2DimensSetParam(devHandle, group, param, chn):
        libc.NMC_Comp2DimensSetParam.argtypes = [c_ushort,  c_short,  POINTER(pymtn.TComp2DimensParam),  c_short]
        ret = libc.NMC_Comp2DimensSetParam(devHandle,  group,  byref(param),  chn)
        return ret

    """ 
    //功能：获取2维位置比较的参数
    // param: 二维比较参数
    // group:组号,0 或者1
    // chn:保留,设为0
    """
    def NMC_Comp2DimensGetParam(devHandle, group,param, chn):
        libc.NMC_Comp2DimensGetParam.argtypes = [c_ushort,  c_short,  POINTER(pymtn.TComp2DimensParam),  c_short]
        ret = libc.NMC_Comp2DimensGetParam(devHandle,  group,  byref(param),  chn)
        return param, ret

    """ 
    // 功能：设置二维比较数据
    // pArrayPos:比较数组地址
    // count:位置点数
    // group:组号,0 或者1
    // chn:保留,设为0
    """
    def NMC_Comp2DimensSetData(devHandle, group, ArrayPos, count, chn):
        ArrayPos_tmp = (c_long * len(ArrayPos))(*ArrayPos)
        libc.NMC_Comp2DimensSetData.argtypes = [c_ushort,  c_short,  POINTER(c_long),  c_short,  c_short]
        ret = libc.NMC_Comp2DimensSetData(devHandle,  group,  ArrayPos_tmp,  count,  chn)
        return ret

    """ 
    // 功能：2维位置比较使能
    // onOff： 0 停止,1输出
    // group:组号,0 或者1
    // chn:保留,设为0
    """
    def NMC_Comp2DimensOnoff(devHandle, group, onOff, chn):
        libc.NMC_Comp2DimensOnoff.argtypes = [c_ushort,  c_short,  c_short,  c_short]
        return libc.NMC_Comp2DimensOnoff(devHandle,  group,  onOff,  chn)

    """ 
    // 功能：2维位置比较的输出状态
    // pStatus: 0 未启动比较 1 比较输出中
    // pOutCount：输出的个数
    // group:组号,0 或者1
    // chn:保留,设为0
    """
    def NMC_Comp2DimensStatus(devHandle, group,  chn):
        Status_tmp = c_short()
        OutCount_tmp = c_short()
        libc.NMC_Comp2DimensStatus.argtypes = [c_ushort,  c_short,  POINTER(c_short),  POINTER(c_short),  c_short]
        ret = libc.NMC_Comp2DimensStatus(devHandle,  group,  byref(Status_tmp),  byref(OutCount_tmp),  chn)
        return Status_tmp, OutCount_tmp, ret

    """
    //-------------------------------------------------------------------------------
    //15.多维位置比较输出通用接口
    //-------------------------------------------------------------------------------
    """
    # X维位置点比较结构体
    class TCompXDimensParam(Structure):
        _fields_ = [
            ("dimens", c_short),                           # 维度
            ("axMask", c_short),                           # 使用的轴掩码（按位）
            ("src", c_short),                              # 轴位置类型：0=规划，1=编码器
            ("outCnts", c_short),                          # 输出数量
            ("outType", c_short * CMP_OUTPUT_CHN_MAX),     # 输出方式：0=脉冲，1=电平
            ("outChnType", c_short * CMP_OUTPUT_CHN_MAX),  # 通道类型：0=GPO，1=GATE
            ("outIndex", c_short * CMP_OUTPUT_CHN_MAX),    # 通道索引（GPO:0-63, GATE:0）
            ("outStLevel", c_short * CMP_OUTPUT_CHN_MAX),  # 电平模式下的起始电平（0或1）
            ("outGateTime", c_short * CMP_OUTPUT_CHN_MAX), # 脉冲模式下的脉冲时间:单位ms
            ("errZone", c_short)                           # 进入比较点容差半径范围（pulse）
        ]

    """ 
    // 功能：设置X维位置比较的参数
    // param: X维比较参数
    // ch:组号,0~2
    """
    def NMC_CompXDimensSetParam(devHandle,param, chn):
        libc.NMC_CompXDimensSetParam.argtypes = [c_ushort,  POINTER(pymtn.TCompXDimensParam),  c_short]
        ret = libc.NMC_CompXDimensSetParam(devHandle,  byref(param),  chn)
        return ret
    """ 
    // 功能：获取X维位置比较的参数
    // param: 二维比较参数
    // chn:组号
    """
    def NMC_CompXDimensGetParam(devHandle,param, chn):
        libc.NMC_CompXDimensGetParam.argtypes = [c_ushort,  POINTER(pymtn.TCompXDimensParam),  c_short]
        ret = libc.NMC_CompXDimensGetParam(devHandle,  byref(param),  chn)
        return param, ret

    """ 
    // 功能：设置X维位置比较的输出模式
    // outMode: 输出模式 0：同时输出模式 1： 轮循输出模式
    // ch:组号,0~N
    """
    def NMC_CompXDimensSetCmpOutMode(devHandle, outMode , chn):
        libc.NMC_CompXDimensSetCmpOutMode.argtypes = [c_ushort,  c_short,  c_short]
        return libc.NMC_CompXDimensSetCmpOutMode(devHandle,  outMode ,  chn)

    """ 
    // 功能：设置X维比较数据
    // pArrayPos:比较数组地址,注：若是1维比较,则pPosArray传入一维数组地址,若是2维比较,则pPosArray应传入2维数组地址
    // outValue
    // count:位置点数,注：若为2维数组比较时,每两个数据为一个点数
    // ch:组号,0~N
    // 注：按结构体定义的IO,同时输出
    """
    def NMC_CompXDimensSetData(devHandle, PosArray, count,  chn):
        PosArray_tmp = (c_long * len(PosArray))(*PosArray)
        libc.NMC_CompXDimensSetData.argtypes = [c_ushort,  POINTER(c_long),  c_short,  c_short]
        ret = libc.NMC_CompXDimensSetData(devHandle,  PosArray_tmp,  count,  chn)
        return ret

    """ 
    // 功能：X维位置比较使能
    // onOff： 0 停止,1输出
    // chn： 组号
    """
    def NMC_CompXDimensOnoff(devHandle, onOff,  chn):
        libc.NMC_CompXDimensOnoff.argtypes = [c_ushort,  c_short,  c_short]
        return libc.NMC_CompXDimensOnoff(devHandle,  onOff,  chn)

    """ 
    // 功能：X维位置比较的输出状态
    // pStatus: 0 未启动比较 1 比较输出中
    // pOutCount：输出的个数
    // chn：组号
    """
    def NMC_CompXDimensStatus(devHandle, chn):
        Status_tmp = c_short()
        OutCount_tmp = c_short()
        libc.NMC_CompXDimensStatus.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_short),  c_short]
        ret = libc.NMC_CompXDimensStatus(devHandle,  byref(Status_tmp),  byref(OutCount_tmp),  chn)
        return Status_tmp, OutCount_tmp, ret

    """-------------------------------------------------------------------------------
    //16.坐标系输出转换（根据机械结构进行转换）
    //-------------------------------------------------------------------------------
    """
    """
    // 功能：使能旋转转换处理
    //       用户数据是按照直角坐标描述,实际加工在一个旋转面上加工,可以用此功能
    // rotAxisNo：旋转轴轴号
    // angleRadEqual：旋转轴脉冲转弧度系数
    // firstAxisInitPos：旋转中心,X轴的位置
    // secAxisInitPos：旋转中心,Y轴的位置
    """
    def NMC_CrdSetTransRotate(crdHandle, rotAxisNo, angleRadEqual, firstAxisInitPos, secAxisInitPos):
        libc.NMC_CrdSetTransRotate.argtypes = [c_ushort,  c_short,  c_double,  c_long,  c_long]
        return libc.NMC_CrdSetTransRotate(crdHandle,  rotAxisNo,  angleRadEqual,  firstAxisInitPos,  secAxisInitPos)

    """ 
    // 功能：关闭旋转转换处理
    """
    def NMC_CrdDelTransRotate(crdHandle):
        libc.NMC_CrdDelTransRotate.argtypes = [c_ushort]
        return libc.NMC_CrdDelTransRotate(crdHandle)

    """ 
    // 功能：使能极坐标转换处理
    //       用户数据是按照直角坐标描述,实际机械机构是一个旋转轴和一个进给轴
    //参数：	rotAxNo：旋转轴轴号
    //		transAxNo：平移轴轴号
    //		rotEquiv：旋转轴当量,2PI/电机一圈脉冲数
    """
    def NMC_CrdSetTransPolar(crdHandle,  rotAxNo, transAxNo,  rotEquiv):
        libc.NMC_CrdSetTransPolar.argtypes = [c_ushort,  c_short,  c_short,  c_double]
        return libc.NMC_CrdSetTransPolar(crdHandle,  rotAxNo,  transAxNo,  rotEquiv)

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

    """ 
    // 功能：运行至设定的极坐标角度位置（利用单轴PTP运行到指定位置）
    //参数：	theta:旋转轴目标角度
    //				vel:旋转速度
    //				clrRoundFlag:是否清除圈数
    """
    def NMC_CrdRunToPolarTheta(crdHandle, theta, vel, clrRoundFlag):
        libc.NMC_CrdRunToPolarTheta.argtypes = [c_ushort,  c_double,  c_double,  c_short]
        return libc.NMC_CrdRunToPolarTheta(crdHandle,  theta,  vel,  clrRoundFlag)

    """ 
    // 功能：销毁极坐标机型（只恢复直角坐标系）
    """
    def NMC_CrdDelTransPolar(crdHandle):
        libc.NMC_CrdDelTransPolar.argtypes = [c_ushort]
        return libc.NMC_CrdDelTransPolar(crdHandle)

    """ 
    // XYZA机型设置接口
    // 设置XYZA的映射轴号
    // pAxisMapArray[0]~[3]分别对应X、Y、Z和A
    """
    def NMC_CrdSetTransXYZA(crdHandle, AxisMapArray):
        AxisMapArray_tmp = (c_short * 4)(* AxisMapArray)
        libc.NMC_CrdSetTransXYZA.argtypes = [c_ushort,  POINTER(c_short)]
        ret = libc.NMC_CrdSetTransXYZA(crdHandle,  AxisMapArray_tmp)
        return ret

    """ 
    // 销毁XYZA机型，回归XYZ结构
    """
    def NMC_CrdDelTransXYZA(crdHandle):
        libc.NMC_CrdDelTransXYZA.argtypes = [c_ushort]
        return libc.NMC_CrdDelTransXYZA(crdHandle)

    """ 
    // 求工具参数
    // deltaTheta：从0°往正方向旋转过的角度值
    // deltaX：旋转deltaTheta角度后，重新校正到同一点位置后，X轴的相对移动量
    // deltaY：旋转deltaTheta角度后，重新校正到同一点位置后，Y轴的相对移动量
    // pToolX: 工具的X值
    // pToolY: 工具的Y值
    """
    def NMC_CrdSetXYZAToolCalc(crdHandle, deltaTheta, deltaX, deltaY ):
        ToolX_tmp = c_long()
        ToolY_tmp = c_long()
        libc.NMC_CrdSetXYZAToolCalc.argtypes = [c_ushort,  c_double,  c_long,  c_long,  POINTER(c_long),  POINTER(c_long)]
        ret = libc.NMC_CrdSetXYZAToolCalc(crdHandle,  deltaTheta,  deltaX,  deltaY,  ToolX_tmp,  ToolY_tmp )
        return (ToolX_tmp, ToolY_tmp, ret)

    """ 
    // 设置XYZA机型参数
    // pulse2Rad: A轴的每个脉冲对应的弧度值
    // toolX：工具的X值
    // toolY: 工具的Y值
    """
    def NMC_CrdSetXYZAPara(crdHandle, pulse2Rad, toolX, toolY):
        libc.NMC_CrdSetXYZAPara.argtypes = [c_ushort,  c_double,  c_long,  c_long]
        return libc.NMC_CrdSetXYZAPara(crdHandle,  pulse2Rad,  toolX,  toolY )

    """ 
    // 设置XYZA机型参数
    // pPulse2Rad:A轴的每个脉冲对应的弧度值
    // pToolX:工具的X值
    // pToolY:工具的Y值
    """
    def NMC_CrdGetXYZAPara(crdHandle):
        Pulse2Rad_tmp = c_double()
        ToolX_tmp = c_int32()
        ToolY_tmp = c_int32()
        libc.NMC_CrdGetXYZAPara.argtypes = [c_ushort,  POINTER(c_double),  POINTER(c_int32),  POINTER(c_int32)]
        ret = libc.NMC_CrdGetXYZAPara(crdHandle,  byref(Pulse2Rad_tmp),  byref(ToolX_tmp),  byref(ToolY_tmp))
        return Pulse2Rad_tmp, ToolX_tmp, ToolY_tmp, ret

    """ 设置压入插补数据的位置是否需要关节到笛卡尔的坐标转换
    """
    def NMC_CrdSetXYZAJointTransCrdPos(crdHandle,  isTrans):
        libc.NMC_CrdSetXYZAJointTransCrdPos.argtypes = [c_ushort,  c_short]
        ret = libc.NMC_CrdSetXYZAJointTransCrdPos(crdHandle,  isTrans )
        return ret

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

    def NMC_TSafeParaStructInit(devHandle, Para):
        libc.NMC_TSafeParaStructInit.argtypes = [c_ushort, POINTER(pymtn.TSafePara)]
        ret = libc.NMC_TSafeParaStructInit(devHandle, byref(Para))
        return ret

    def NMC_TCrdConfigStructInit(devHandle, Para):
        libc.NMC_TCrdConfigStructInit.argtypes = [c_ushort, POINTER(pymtn.TCrdConfig)]
        ret = libc.NMC_TCrdConfigStructInit(devHandle, byref(Para))
        return ret

    def NMC_TCrdSafeParaStructInit(devHandle, Para):
        libc.NMC_TCrdSafeParaStructInit.argtypes = [c_ushort, POINTER(pymtn.TCrdSafePara)]
        ret = libc.NMC_TCrdSafeParaStructInit(devHandle, byref(Para))
        return ret

    def NMC_THomeSettingStructInit(devHandle, Para):
        libc.NMC_THomeSettingStructInit.argtypes = [c_ushort, POINTER(pymtn.THomeSetting)]
        ret = libc.NMC_THomeSettingStructInit(devHandle, byref(Para))
        return ret

    def NMC_TArcSecSettingStructInit(devHandle, Para):
        libc.NMC_TArcSecSettingStructInit.argtypes = [c_ushort, POINTER(pymtn.TArcSecSetting)]
        ret = libc.NMC_TArcSecSettingStructInit(devHandle, byref(Para))
        return ret

    def NMC_TCrdParaStructInit(devHandle, Para):
        libc.NMC_TCrdParaStructInit.argtypes = [c_ushort, POINTER(pymtn.TCrdPara)]
        ret = libc.NMC_TCrdParaStructInit(devHandle, byref(Para))
        return ret

    def NMC_TCollectCfgStructInit(devHandle, Para):
        libc.NMC_TCollectCfgStructInit.argtypes = [c_ushort, POINTER(pymtn.TCollectCfg)]
        ret = libc.NMC_TCollectCfgStructInit(devHandle, byref(Para))
        return ret

    def NMC_TCollectTrigStructInit(devHandle, Para):
        libc.NMC_TCollectTrigStructInit.argtypes = [c_ushort, POINTER(pymtn.TCollectTrig)]
        ret = libc.NMC_TCollectTrigStructInit(devHandle, byref(Para))
        return ret

    def NMC_TTimeArrayParaStructInit(devHandle, Para):
        libc.NMC_TTimeArrayParaStructInit.argtypes = [c_ushort, POINTER(pymtn.TTimeArrayPara)]
        ret = libc.NMC_TTimeArrayParaStructInit(devHandle, byref(Para))
        return ret

    def NMC_TLaserPowerStructInit(devHandle, Para):
        libc.NMC_TLaserPowerStructInit.argtypes = [c_ushort, POINTER(pymtn.TLaserPower)]
        ret = libc.NMC_TLaserPowerStructInit(devHandle, byref(Para))
        return ret

    def NMC_TSHIOParaStructInit(devHandle, Para):
        libc.NMC_TSHIOParaStructInit.argtypes = [c_ushort, POINTER(pymtn.TSHIOPara)]
        ret = libc.NMC_TSHIOParaStructInit(devHandle, byref(Para))
        return ret

    def NMC_TLinearCmpParaStructInit(devHandle, Para):
        libc.NMC_TLinearCmpParaStructInit.argtypes = [c_ushort, POINTER(pymtn.TLinearCmpPara)]
        ret = libc.NMC_TLinearCmpParaStructInit(devHandle, byref(Para))
        return ret

    def NMC_TComp2DimensParamStructInit(devHandle, Para):
        libc.NMC_TComp2DimensParamStructInit.argtypes = [c_ushort, POINTER(pymtn.TComp2DimensParam)]
        ret = libc.NMC_TComp2DimensParamStructInit(devHandle, byref(Para))
        return ret

    def NMC_TPtpParaStructInit(devHandle, Para):
        libc.NMC_TPtpParaStructInit.argtypes = [c_ushort, POINTER(pymtn.TPtpPara)]
        ret = libc.NMC_TPtpParaStructInit(devHandle, byref(Para))
        return ret

    def NMC_TJogParaStructInit(devHandle, Para):
        libc.NMC_TJogParaStructInit.argtypes = [c_ushort, POINTER(pymtn.TJogPara)]
        ret = libc.NMC_TJogParaStructInit(devHandle, byref(Para))
        return ret

    def NMC_TNMCTimeStructInit(devHandle, Para):
        libc.NMC_TNMCTimeStructInit.argtypes = [c_ushort, POINTER(pymtn.TNMCTime)]
        ret = libc.NMC_TNMCTimeStructInit(devHandle, byref(Para))
        return ret

    """ 
    // 清除轴错误状态,同时多个
    """
    def NMC_MtClrErrorEx(axisHandle, count):
        libc.NMC_MtClrErrorEx.argtypes = [c_ushort,  c_short]
        return libc.NMC_MtClrErrorEx(axisHandle,  count)
    """ 输出DO,16位
    // bitsFlag,0:低16位,1：高16位
    """
    def NMC_SetDOGroupEx(devHandle, value,  groupID, bitsFlag):
        libc.NMC_SetDOGroupEx.argtypes = [c_ushort,  c_long, c_short,  c_short]
        return libc.NMC_SetDOGroupEx(devHandle, value,  groupID, bitsFlag)

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

    # PID参数结构体
    class TPidPara(Structure):
        _fields_ = [
            ("kp", c_float),  # 增益系数
            ("ki", c_float),  # 积分系数
            ("kd", c_float),  # 微分系数
            ("kvff", c_float),  # 速度前馈系数
            ("integralLimit", c_int32),  # 积分饱和极限
            ("derivativeLimit", c_int32),  # 微分饱和极限
            ("outLimit", c_int16)  # 输出饱和极限
        ]

        def __init__(self):

            super().__init__()
            self.kp = 0.0
            self.ki = 0.0
            self.kd = 0.0
            self.kvff = 0.0
            self.integralLimit = 100
            self.derivativeLimit = 100
            self.outLimit = 32767

    # Dac参数结构体
    class TDacMotor(Structure):
        _fields_ = [
            ("inverse", c_short),  # 电压是否取反
            ("bias", c_short),  # Dac零漂
            ("dacLmt", c_short)  # Dac输出极限值
        ]
    """
    // 设置单轴闭环控制的DA参数,轴与DA通道的对应
    """
    def NMC_MtSetCloseLoopDac (axisHandle,DacPara):
        libc.NMC_MtSetCloseLoopDac.argtypes = [c_ushort,  POINTER(pymtn.TDacMotor)]
        ret = libc.NMC_MtSetCloseLoopDac(axisHandle,  byref(DacPara))
        return ret

    """ 
    // 获取单轴闭环控制的DA参数
    """
    def NMC_MtGetCloseLoopDac (axisHandle,DacPara):
        libc.NMC_MtGetCloseLoopDac.argtypes = [c_ushort,  POINTER(pymtn.TDacMotor)]
        ret = libc.NMC_MtGetCloseLoopDac(axisHandle,  byref(DacPara))
        return DacPara, ret

    """ 
    // 设置单轴的控制模式：默认使用对应轴的编码器作为输入反馈,对应序号的DAC作为输出
    // 闭环模式下,先调用NMC_SetCloseLoopDac指令
    //mode: 0 脉冲控制  1 DA闭环控制，默认为脉冲控制
    """
    def NMC_MtSetCtrlMode(axisHandle, mode):
        libc.NMC_MtSetCtrlMode.argtypes = [c_ushort,  c_short]
        return libc.NMC_MtSetCtrlMode(axisHandle,  mode)

    """ 
    // 读取单轴的控制模式
    """
    def NMC_MtGetCtrlMode(axisHandle):
        Mode_tmp = c_short()
        libc.NMC_MtGetCtrlMode.argtypes = [c_ushort,  POINTER(c_short)]
        ret = libc.NMC_MtGetCtrlMode(axisHandle,  byref(Mode_tmp))
        return Mode_tmp, ret

    """
    // 设置对应组号的PID参数
    """
    def NMC_MtSetPIDPara(axisHandle, index, pidPara):
        libc.NMC_MtSetPIDPara.argtypes = [c_ushort,  c_short,  POINTER(pymtn.TPidPara)]
        ret = libc.NMC_MtSetPIDPara(axisHandle,  index,  byref(pidPara))
        return ret

    """ 
    // 获取对应组号的PID参数
    """
    def NMC_MtGetPIDPara(axisHandle, index, PidPara):
        libc.NMC_MtGetPIDPara.argtypes = [c_ushort,  c_short,  POINTER(pymtn.TPidPara)]
        ret = libc.NMC_MtGetPIDPara(axisHandle,  index,  byref(PidPara))
        return PidPara, ret

    """ 
    // 设置使用哪组PID
    """
    def NMC_MtSetPIDIndex(axisHandle, index):
        libc.NMC_MtSetPIDIndex.argtypes = [c_ushort,  c_short]
        return libc.NMC_MtSetPIDIndex(axisHandle,  index)

    """ 
    // 获取正使用的PID组号
    """
    def NMC_MtGetPIDIndex( axisHandle):
        Index_tmp = c_short()
        libc.NMC_MtGetPIDIndex.argtypes = [c_ushort,  POINTER(c_short)]
        ret = libc.NMC_MtGetPIDIndex(axisHandle,  byref(Index_tmp))
        return Index_tmp, ret

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

    class TAdvBufIoParam(Structure):
        _fields_ = [
            # 输出点配置
            ("outType", c_short),  # 输出类型，0：通用输出；1：Gate信号；其他保留
            ("outGroup", c_short),  # 输出组，取值范围[0,n]
            ("outIndex", c_short),  # 输出序号，取值范围[0,n]
            ("outSns", c_short),  # 有效电平, 0:低电平有效，1：高电平

            # 信号配置
            ("pulseMode", c_short),  # 0：电平输出，1：脉冲输出
            ("reserved1", c_short),  # 保留字段
            ("pulseOnTime", c_long),  # 有效电平时间（脉冲输出方式下有效），单位：微秒
            ("pulseOffTime", c_long),  # 无效电平时间（脉冲输出方式下有效），单位：微秒

            ("reserved", c_ubyte * 32)  # 保留
        ]

    """
    // 设置BufIo输出参数
    """
    def NMC_AdvBufIoSetParam(devHandle,Prm, ch):
        libc.NMC_AdvBufIoSetParam.argtypes = [c_ushort,  POINTER(pymtn.TAdvBufIoParam),  c_short]
        ret = libc.NMC_AdvBufIoSetParam(devHandle,  byref(Prm),  ch)
        return ret

    """ 
    // 读取BufIo输出参数
    """
    def NMC_AdvBufIoGetParam(devHandle,Prm, ch):
        libc.NMC_AdvBufIoGetParam.argtypes = [c_ushort, POINTER(pymtn.TAdvBufIoParam),  c_short]
        ret = libc.NMC_AdvBufIoGetParam(devHandle,  byref(Prm),  ch)
        return Prm, ret

    """ 
    // 缓冲区设置高级BufIo输出有效（运动一段距离后输出特定状态）
    // outLength:距离，单位：脉冲
    // value: 脉冲模式下输出脉冲个数，电平方式下无意义。
    // ch:输出组，取值范围：[0,MAX_ADV_BUFIO_GROUP)
    """
    def NMC_CrdAdvBufIoOnAfterLen(crdHandle, segNo,outLength, value, ch):
        libc.NMC_CrdAdvBufIoOnAfterLen.argtypes = [c_ushort,  c_long,  c_long,  c_long,  c_short]
        return libc.NMC_CrdAdvBufIoOnAfterLen(crdHandle,  segNo,  outLength,  value,  ch)

    """ 
    // 缓冲区设置高级BufIo关闭输出（缓冲区全部运动结束前提前一段距离输出特定状态）
    // outLength:距离，单位：脉冲
    // ch:输出组，取值范围：[0,MAX_ADV_BUFIO_GROUP)
    """
    def NMC_CrdAdvBufIoOffBeforeLen(crdHandle, segNo, outLength, ch ):
        libc.NMC_CrdAdvBufIoOffBeforeLen.argtypes = [c_ushort,  c_long,  c_long,  c_short]
        return libc.NMC_CrdAdvBufIoOffBeforeLen(crdHandle,  segNo,  outLength,  ch )

    """ 
    // 立即设置高级BufIo输出
    // value: 脉冲模式下输出脉冲个数，电平方式下0:关闭，1:打开。
    // ch:输出组，取值范围：[0,MAX_ADV_BUFIO_GROUP)
    """
    def NMC_AdvBufIoOut(devHandle, value, ch):
        libc.NMC_AdvBufIoOut.argtypes = [c_ushort,  c_long,  c_short]
        return libc.NMC_AdvBufIoOut(devHandle,  value,  ch)

    """ 
    // 读取BufIo的输出数量
    // pOutCout:输出脉冲个数
    // ch:输出组，取值范围：[0,MAX_ADV_BUFIO_GROUP)
    """
    def NMC_AdvBufIoGetPulseCnt(devHandle, ch):
        OutCout_tmp = c_long()
        libc.NMC_AdvBufIoGetPulseCnt.argtypes = [c_ushort,  POINTER(c_long),  c_short]
        ret = libc.NMC_AdvBufIoGetPulseCnt(devHandle,  byref(OutCout_tmp),  ch)
        return OutCout_tmp, ret

    # DO脉冲输出最大通道数
    MAX_NUM_DOBIT_PULSE		= 4
    """
    // DO脉冲输出
    // doType:DO类型,0：通用输出；其他保留
    // doIndex:DO序号，取值范围[0,n]
    // highLevelTime:高电平宽度，单位:us
    // lowLevelTime:低电平宽度，单位:us
    // outCount:输出脉冲个数
    // firstLevel:0：先输出低电平，1：先输出高电平
    // ch:输出脉冲通道号,取值范围:[0,MAX_NUM_DOBIT_PULSE-1]
    """
    def NMC_DoBitPulseEnable(devHandle, doType, doIndex,highLevelTime, lowLevelTime, outCount, initialLevel, ch):
        libc.NMC_DoBitPulseEnable.argtypes = [c_ushort,  c_short,  c_short,  c_long,  c_long,  c_long,  c_short,  c_short]
        ret = libc.NMC_DoBitPulseEnable(devHandle,  doType,  doIndex,  highLevelTime,  lowLevelTime,  outCount,  initialLevel,  ch)
        return ret

    """ 
    // 关闭DO脉冲输出
    """
    def NMC_DoBitPulseDisable(devHandle, ch):
        libc.NMC_DoBitPulseDisable.argtypes = [c_ushort,  c_short]
        return libc.NMC_DoBitPulseDisable(devHandle,  ch)

    """ 
    // DO脉冲输出 （缓冲区）
    """
    def NMC_CrdBufDoBitPulseEnable(crdHandle,  segNo, doType, doIndex, highLevelTime, lowLevelTime, outCount, initialLevel, ch):
        libc.NMC_CrdBufDoBitPulseEnable.argtypes = [c_ushort,  c_long,  c_short,  c_short,  c_long,  c_long,  c_long,  c_short,  c_short]
        ret = libc.NMC_CrdBufDoBitPulseEnable(crdHandle,  segNo,  doType,  doIndex,  highLevelTime,  lowLevelTime,  outCount,  initialLevel,  ch)
        return ret

    """ 
    // 关闭DO脉冲输出（缓冲区）
    """
    def NMC_CrdBufDoBitPulseDisable(crdHandle,  segNo, ch):
        libc.NMC_CrdBufDoBitPulseDisable.argtypes = [c_ushort,  c_long,  c_short]
        return libc.NMC_CrdBufDoBitPulseDisable(crdHandle,  segNo,  ch)

    """-------------------------------------------------------------------------------
    //20.模拟量控制
    //-------------------------------------------------------------------------------
    """
    """
    // 设置DAC（模拟量输出）通道的模式
    // ch:模拟量通道号,取值范围[0,n]
    // mode:模拟量输出范围,0:0~5V, 1:0~10V, 2: 0~10.8V, 3:+/-5V, 4:+/-10V, 5:+/-10.8V,其他无效，默认为4
    """
    def NMC_SetDacMode(devHandle, ch,  mode):
        libc.NMC_SetDacMode.argtypes = [c_ushort,  c_short,  c_short]
        return libc.NMC_SetDacMode(devHandle,  ch,  mode)

    """ 
    // 读取DAC（模拟量输出）通道的模式
    // ch:模拟量通道号,取值范围[0,n]
    // pMode:返回的模拟量输出范围设定值
    """
    def NMC_GetDacMode( devHandle, ch):
        Mode_tmp = c_short()
        libc.NMC_GetDacMode.argtypes = [c_ushort,  c_short,  POINTER(c_short)]
        ret = libc.NMC_GetDacMode(devHandle,  ch,  byref(Mode_tmp))
        return Mode_tmp, ret

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

    """ 
    // 读取Adc参数
    // ch:模拟量通道号,0~7表示轴通道上的AD，256：表示扩展AD
    // pMode:模拟量范围
    // pFilterCoe:滤波系数
    """
    def NMC_GetAdcMode(devHandle, ch):
        Range_tmp = c_short()
        FilterCoe_tmp = c_short()
        libc.NMC_GetAdcMode.argtypes = [c_ushort,  c_short,  POINTER(c_short),  POINTER(c_short)]
        ret = libc.NMC_GetAdcMode(devHandle,  ch,  byref(Range_tmp),  byref(FilterCoe_tmp))
        return Range_tmp, FilterCoe_tmp, ret

    """ 
    // 设置DAC（模拟量输出）输出值
    // ch:模拟量通道号,取值范围[0,n]
    // dacValue:模拟量输出值,取值范围[-32768,32767],对应DAC输出范围
    """
    def NMC_SetDac(devHandle, ch, dacValue):
        libc.NMC_SetDac.argtypes = [c_ushort,  c_short,  c_short]
        return libc.NMC_SetDac(devHandle,  ch,  dacValue)

    """ 
    // 读取DAC（模拟量输出）输出值
    // ch:模拟量通道号,取值范围[0,n]
    // pDacValue:返回模拟量输出值,取值范围[-32768,32767],对应DAC输出范围
    """
    def NMC_GetDac(devHandle, ch):
        DacValue_tmp = c_short()
        libc.NMC_GetDac.argtypes = [c_ushort,  c_short,  POINTER(c_short)]
        ret = libc.NMC_GetDac(devHandle,  ch,  byref(DacValue_tmp))
        return DacValue_tmp, ret

    """ 
    // 读取ADC（模拟量输入）值
    // ch:模拟量通道号,取值范围[0,n]
    // pAdcValue:返回模拟量输入值，取值范围[-32768,32767],对应Adc输入电压范围
    """
    def NMC_GetAdc( devHandle, ch):
        AdcValue_tmp = c_short()
        libc.NMC_GetAdc.argtypes = [c_ushort,  c_short,  POINTER(c_short)]
        ret = libc.NMC_GetAdc(devHandle,  ch,  byref(AdcValue_tmp))
        return AdcValue_tmp, ret

    """ 
    // 设置模拟量输出的偏移值
    // ch:模拟量通道号，[0,n]表示本地,[256,n]表示扩展模拟量通道
    // bias:DAC输出偏移值
    """
    def NMC_SetDacBias(devHandle, ch, bias):
        libc.NMC_SetDacBias.argtypes = [c_ushort,  c_short,  c_short]
        return libc.NMC_SetDacBias(devHandle,  ch,  bias)

    """ 
    // 读取模拟量输出的偏移值
    // ch:模拟量通道号，[0,n]表示本地,[256,n]表示扩展模拟量通道
    // pBias:DAC输出偏移值
    """
    def NMC_GetDacBias(devHandle, ch):
        Bias_tmp = c_short()
        libc.NMC_GetDacBias.argtypes = [c_ushort,  c_short,  POINTER(c_short)]
        ret = libc.NMC_GetDacBias(devHandle,  ch,  byref(Bias_tmp))
        return Bias_tmp, ret

    """ 
    // 设置模拟量输出的极限值
    // ch:模拟量通道号，[0,n]表示本地,[256,n]表示扩展模拟量通道
    // maxVal:输出最大值
    // minVal:输出最小值
    """
    def NMC_SetDacLmt(devHandle, ch, maxVal, minVal):
        libc.NMC_SetDacLmt.argtypes = [c_ushort,  c_short,  c_short,  c_short]
        return libc.NMC_SetDacLmt(devHandle,  ch,  maxVal,  minVal)

    """ 
    // 读取模拟量输出的极限值
    // ch:模拟量通道号，[0,n]表示本地,[256,n]表示扩展模拟量通道
    // pMaxVal:输出最大值
    // pMinVal:输出最小值
    """
    def NMC_GetDacLmt(devHandle, ch):
        MaxVal_tmp = c_short()
        MinVal_tmp = c_short()
        libc.NMC_GetDacLmt.argtypes = [c_ushort,  c_short,  POINTER(c_short),  POINTER(c_short)]
        ret = libc.NMC_GetDacLmt(devHandle,  ch,  byref(MaxVal_tmp),  byref(MinVal_tmp))
        return MaxVal_tmp, MinVal_tmp, ret

    """-------------------------------------------------------------------------------
    //21.scara
    //-------------------------------------------------------------------------------
    """
    # 相关结构体
    class TScaraMechPara(Structure):
        _fields_ = [
            ("arm1Len", c_double),      # 杆1长度（用户单位）
            ("arm2Len", c_double),      # 杆2长度（用户单位）
            ("pitch", c_double),        # Z轴丝杆节距（用户单位）
            ("reserved", c_double * 16) # 保留区域（初始化为0）
        ]

        def __init__(self):
            super().__init__()
            self.arm1Len = 0.0
            self.arm2Len = 0.0
            self.pitch = 0.0
            for i in range(16):
                self.reserved[i] = 0.0

    class TScaraJiontPara(Structure):
        _fields_ = [
            ("encBits", c_int32),       # 关节的电机一圈的脉冲数
            ("zeroPulsePos", c_int32),  # 关节零点位置的脉冲位置
            ("posLmt", c_float),       # 关节的正限位位置：单位 度
            ("negLmt", c_float),       # 关节的负限位位置：单位 度
            ("ratio", c_float),        # 减速比
            ("maxVel", c_float),       # 最大关节速度（°/s）
            ("maxAcc", c_float),       # 最大关节加速度（°/s²）
            ("reserved1", c_float),    # 保留，设置为0
            ("reserved", c_double * 8) # 保留，设置为0
        ]
        def __init__(self):
            super().__init__()
            self.encBits = 0
            self.zeroPulsePos = 0
            self.posLmt = 0.0
            self.negLmt = 0.0
            self.ratio = 0.0
            self.maxVel = 0.0
            self.maxAcc = 0.0
            self.reserved1 = 0.0
            for i in range(8):
                self.reserved[i] = 0.0

    """
    // 设置机械参数
    """
    def NMC_CrdSetScaraMechPara(crdHandle,ScaraMechPara):
        libc.NMC_CrdSetScaraMechPara.argtypes = [c_ushort,  POINTER(pymtn.TScaraMechPara)]
        ret = libc.NMC_CrdSetScaraMechPara(crdHandle,  byref(ScaraMechPara))
        return ret

    """ 
    // 读取机械参数
    """
    def NMC_CrdGetScaraMechPara(crdHandle,ScaraMechPara):
        libc.NMC_CrdGetScaraMechPara.argtypes = [c_ushort,  POINTER(pymtn.TScaraMechPara)]
        ret = libc.NMC_CrdGetScaraMechPara(crdHandle,  byref(ScaraMechPara))
        return ScaraMechPara, ret

    """ 
    // 设置关节参数
    """
    def NMC_CrdSetScaraJiontPara(crdHandle, jointNo,ScaraJiontPara):
        libc.NMC_CrdSetScaraJiontPara.argtypes = [c_ushort,  c_short,  POINTER(pymtn.TScaraJiontPara)]
        ret = libc.NMC_CrdSetScaraJiontPara(crdHandle,  jointNo,  byref(ScaraJiontPara))
        return ret

    """ 
    // 读取关节参数
    """
    def NMC_CrdGetScaraJiontPara(crdHandle, jointNo, ScaraJiontPara):
        libc.NMC_CrdGetScaraJiontPara.argtypes = [c_ushort,  c_short,  POINTER(pymtn.TScaraJiontPara)]
        ret = libc.NMC_CrdGetScaraJiontPara(crdHandle,  jointNo,  byref(ScaraJiontPara))
        return ScaraJiontPara, ret

    """ 
    // 设置crd类型为scara
    // jointNum: 2/3
    // jointAxNoArray 数组长度为4，不用的数据设置为0
    """
    def NMC_CrdSetTransScara(crdHandle,  jointNum, jointAxNoArray):
        jointAxNoArray_tmp = (c_short * 4)(*jointAxNoArray)
        libc.NMC_CrdSetTransScara.argtypes = [c_ushort,  c_short,  POINTER(c_short)]
        ret = libc.NMC_CrdSetTransScara(crdHandle,  jointNum,  jointAxNoArray_tmp )
        return list(jointAxNoArray_tmp), ret

    """ 
    // 销毁scara机型
    """
    def NMC_CrdDelTransScara(crdHandle):
        libc.NMC_CrdDelTransScara.argtypes = [c_ushort]
        return libc.NMC_CrdDelTransScara(crdHandle)

    class TFlyFollowPara(Structure):
        _fields_ = [
            ("masterAxNo", c_short),  # 传输带轴号，0~N
            ("useEnc", c_short),      # 使用编码器：0=规划，1=编码器
            ("dirReverse", c_short),  # 传输轴方向：0=不取反，1=取反
            ("followedAxNo", c_short),# 跟随轴号：0=X，1=Y
            ("posCoe", c_double),     # 传输轴当量和跟随轴的当量比例，跟随当量 / 传输轴当量
            ("reserved2", c_long * 16)  # 保留字段（初始化为0）
        ]
        def __init__(self):
            super().__init__()
            self.masterAxNo = 0
            self.useEnc = 0
            self.dirReverse = 0
            self.followedAxNo = 0
            self.posCoe = 0.0
            self.followAng = 0.0
            # 初始化保留字段为0
            for i in range(15):
                self.reserved2[i] = 0
    """ 
    // 设置crd启用飞行跟随模式
    // *pFlyFollowPara 模式参数
    """
    def NMC_CrdSetFlyFollow(crdHandle, FlyFollowPara):
        libc.NMC_CrdSetFlyFollow.argtypes = [c_ushort,  POINTER(pymtn.TFlyFollowPara)]
        ret = libc.NMC_CrdSetFlyFollow(crdHandle,  byref(FlyFollowPara))
        return ret

    """ 
    // 销毁飞行跟随
    """
    def NMC_CrdDelFlyFollow(crdHandle):
        libc.NMC_CrdDelFlyFollow.argtypes = [c_ushort]
        return libc.NMC_CrdDelFlyFollow(crdHandle)

    """ 
    // 查询是否在暂停后已经跟随上状态
    // sts : 1表示跟随上  0表示没有跟随上
    """
    def NMC_CrdGetFlyFollowUpSts(crdHandle):
        Sts_tmp = c_short()
        libc.NMC_CrdGetFlyFollowUpSts.argtypes = [c_ushort,  POINTER(c_short)]
        ret = libc.NMC_CrdGetFlyFollowUpSts(crdHandle,  byref(Sts_tmp))
        return Sts_tmp, ret

    """ 
    // 缓冲区设置飞行跟随功能的启动和关闭
    // enable:0:关闭跟随
    //        1:激活跟随
    //        2:暂停跟随
    """
    def NMC_CrdBufEnableFlyFollow(crdHandle,  segNo, enable):
        libc.NMC_CrdBufEnableFlyFollow.argtypes = [c_ushort,  c_long,  c_short]
        return libc.NMC_CrdBufEnableFlyFollow(crdHandle,  segNo,  enable)

    """ 
    // 缓冲区：飞行跟随情况下，移动到机械位置
    """
    def NMC_CrdBufFlyFollowLineXY( crdHandle, segNo, acc, vel):
        tgtPos_tmp = (c_long * 2)()
        libc.NMC_CrdBufFlyFollowLineXY.argtypes = [c_ushort,  c_long,  POINTER(c_long),  c_double,  c_double]
        ret = libc.NMC_CrdBufFlyFollowLineXY(crdHandle,  segNo,  tgtPos_tmp,  acc,  vel)
        return [tgtPos_tmp[0], tgtPos_tmp[1]], ret

    """ 
    // 缓冲区：等待缓冲区数据
    // usedSpace:等待缓冲区数据段数（大于等于usedSpace继续往下执行）
    """
    def NMC_CrdBufWaitData(crdHandle, segNo, usedSpace):
        libc.NMC_CrdBufWaitData.argtypes = [c_ushort,  c_long,  c_long]
        return libc.NMC_CrdBufWaitData(crdHandle,  segNo,  usedSpace)

    """ 
    // 缓冲区：坐标系内轴跟随
    // crdAxMaster:跟随的主轴，取值范围[0,n],为坐标系内的轴，0:X轴，1:Y轴，2:Z轴，3:A轴
    // axFllowMask:跟随的从轴掩码
    // onOff：启动跟随或者关闭跟随,1:启动跟随，0:关闭跟随，此时，crdAxMaster和axFllowMask忽略，可任意值
    """
    def NMC_CrdBufAxFollowOnOff(crdHandle,  segNo, crdAxMaster, axFllowMask, onOff):
        libc.NMC_CrdBufAxFollowOnOff.argtypes = [c_ushort,  c_long,  c_short,  c_short,  c_short]
        return libc.NMC_CrdBufAxFollowOnOff(crdHandle,  segNo,  crdAxMaster,  axFllowMask,  onOff)

    """-------------------------------------------------------------------------------
    //22.坐标系干涉保护指令
    //-------------------------------------------------------------------------------
    """
    CRD_INTERF_GROUP_MAX		= 2
    """
    // 启动坐标系的干涉保护
    // groupNo: 干涉坐标系组号（目前只有两个坐标系，所以该值为0）
    // mode:	0:基本模式，出现干涉，两坐标系均停止  1：激光模式，出现干涉，其中一个停止并离开
    """
    def NMC_SetMvProtect(devHandle, groupNo, mode):
        libc.NMC_SetMvProtect.argtypes = [c_ushort,  c_short,  c_short]
        return libc.NMC_SetMvProtect(devHandle,  groupNo,  mode)

    """ 取消坐标系的干涉保护
    // groupNo: 干涉坐标系组号（目前只有两个坐标系，所以该值为0）
    """
    def NMC_DelMvProtect(devHandle, groupNo):
        libc.NMC_DelMvProtect.argtypes = [c_ushort,  c_short]
        return libc.NMC_DelMvProtect(devHandle,  groupNo)

    """ 
    // 获取坐标系的干涉状态
    // groupNo: 干涉坐标系组号（目前只有两个坐标系，所以该值为0）
    // pSts:	0 没有启动干涉功能 1  没有出现干涉  2 干涉发生
    """
    def NMC_GetMvProtectSts(devHandle, groupNo):
        Sts_tmp = c_short()
        libc.NMC_GetMvProtectSts.argtypes = [c_ushort,  c_short,  POINTER(c_short)]
        ret = libc.NMC_GetMvProtectSts(devHandle,  groupNo,  byref(Sts_tmp))
        return Sts_tmp, ret

    class TMvProtectPara(Structure):
        _fields_ = [
            ("crdNo", c_short * 2),    # 需要干涉保护的两坐标系号
            ("crdAxNo", c_short * 2),  # 坐标系的干涉轴号,指XYZ中哪一个（X:0  Y:1    Z:2）
            ("moveDir", c_short * 2),  # 两干涉轴分别往距离减小时的运动方向，1：正向 -1：负向
            ("orgDis", c_long),        # 两坐标系的crdAxNo轴在原点时的距离
            ("mvProtectDis", c_long),  # 干涉的保护距离
            ("safeWaitPos", c_long),   # mode为激光模式时，干涉轴需要停止到的等待位置（mode为0时无效）
            ("mvToSafeAcc", c_double), # 运动到等待位置的移动加速度
            ("mvToSafeVel", c_double), # 运动到等待位置的移动速度
            ("stopCrdNo", c_short),    # mode为激光模式时，需要停止的坐标系号（mode为0时无效）
            ("reserved", c_short * 3)  # 保留参数
        ]
    """ 
    // 设置坐标系的干涉保护参数
    // groupNo:	干涉坐标系组号（目前只有两个坐标系，所以该值为0）
    // pCrdInterfProtectPara： 干涉参数
    """
    def NMC_SetMvProtectMode01Para(devHandle, groupNo,MvProtectPara):
        libc.NMC_SetMvProtectMode01Para.argtypes = [c_ushort,  c_short,  POINTER(pymtn.TMvProtectPara)]
        ret = libc.NMC_SetMvProtectMode01Para(devHandle,  groupNo,  byref(MvProtectPara))
        return ret

    """ 
    // 获取坐标系的干涉保护参数
    // groupNo:	干涉坐标系组号（目前只有两个坐标系，所以该值为0）
    // pCrdInterfProtectPara： 干涉参数
    """
    def NMC_GetMvProtectMode01Para(devHandle, groupNo,MvProtectPara):
        libc.NMC_GetMvProtectMode01Para.argtypes = [c_ushort,  c_short,  POINTER(pymtn.TMvProtectPara)]
        ret = libc.NMC_GetMvProtectMode01Para(devHandle,  groupNo,  byref(MvProtectPara))
        return MvProtectPara, ret

    """-------------------------------------------------------------------------------
    //23.不常用指令
    //-------------------------------------------------------------------------------
    """

    class TPackedCrdSts3(Structure):
        _fields_ = [
            ("crdSts", c_short),               # 坐标系状态
            ("axSts", c_short * 3),            # 坐标系里各轴状态
            ("prfPos", c_long * 3),            # 用户坐标系下的规划位置
            ("axisPos", c_long * 3),           # 机械坐标系下的规划位置
            ("encPos", c_long * 3),            # 编码器位置
            ("userSeg", c_long),               # 运行的缓冲区段号
            ("prfVel", c_double),              # 运动速度
            ("gpDi", c_long),                  # 通用输入0~31
            ("gpDo", c_long),                  # 通用输出0~31
            ("motDi", c_short * 3),            # 限位/原点/报警（参考BIT_AXMTIO_LMTN）
            ("reserved", c_short),             # 保留字段
            ("crdFreeSpace", c_long),          # 缓冲区剩余空间
            ("reserved2", c_long)              # 保留字段
        ]

    """
    // 坐标系运动模式下,打包读取控制器状态
    """
    def NMC_CrdGetStsPack3(crdHandle):
        PackSts = pymtn.TPackedCrdSts3()
        libc.NMC_CrdGetStsPack3.argtypes = [c_ushort,  POINTER(pymtn.TPackedCrdSts3)]
        ret = libc.NMC_CrdGetStsPack3(crdHandle,  byref(PackSts))
        return PackSts, ret

    """ 
    // 坐标系模式下,读取多个轴的机械坐标位置
    // cnts: 读取个数,1~N
    // pPos：返回坐标数组
    """
    def NMC_CrdGetAxisPos(crdHandle, cnts):
        PosArray_tmp = (c_long * cnts)()
        libc.NMC_CrdGetAxisPos.argtypes = [c_ushort,  c_short,  POINTER(c_long)]
        ret = libc.NMC_CrdGetAxisPos(crdHandle,  cnts,  PosArray_tmp)
        return list(PosArray_tmp), ret

    """ 
    // 读取规划位置XYZ
    // cnts: 读取个数,1~N
    // pPosArray：返回坐标数组
    """
    def NMC_CrdGetPrfPos(crdHandle,  cnts):
        PosArray_tmp = (c_long * cnts)()
        libc.NMC_CrdGetPrfPos.argtypes = [c_ushort,  c_short,  POINTER(c_long)]
        ret = libc.NMC_CrdGetPrfPos(crdHandle,  cnts,  PosArray_tmp )
        return list(PosArray_tmp), ret

    """ 
    // 读取编码器位置
    // cnts: 读取个数,1~N
    // pPos：返回坐标数组。
    """
    def NMC_CrdGetEncPos(crdHandle, cnts):
        PosArray_tmp = (c_long * cnts)()
        libc.NMC_CrdGetEncPos.argtypes = [c_ushort,  c_short,  POINTER(c_long)]
        ret = libc.NMC_CrdGetEncPos(crdHandle,  cnts,  PosArray_tmp)
        return list(PosArray_tmp), ret

    """ 获取坐标系合成速度
    // pVel：坐标系合成速度
    """
    def NMC_CrdGetVel(crdHandle):
        Vel_tmp = c_double()
        libc.NMC_CrdGetVel.argtypes = [c_ushort,  POINTER(c_double)]
        ret = libc.NMC_CrdGetVel(crdHandle,  byref(Vel_tmp))
        return Vel_tmp, ret

    """ 
    // 打开坐标系组
    // pCrdHandle：返回坐标系组句柄
    """
    def NMC_CrdOpen(devHandle):
        CrdHandle = c_ushort()
        libc.NMC_CrdOpen.argtypes = [c_ushort,  POINTER(c_ushort)]
        ret = libc.NMC_CrdOpen(devHandle,  CrdHandle)
        return CrdHandle, ret

    """ 单轴急停
    // 注：运动会按设定的急停加速度停止。如果没有设置,则会立即停止。
    """
    def NMC_MtEstp(axisHandle ):
        libc.NMC_MtEstp.argtypes = [c_ushort]
        return libc.NMC_MtEstp(axisHandle)

    # 读取打包轴状态（8轴）
    class TAxisStsPack8(Structure):
        _fields_ = [
            ("prfPos", c_long * 8),    # 规划位置（单位：脉冲）
            ("encPos", c_long * 8),    # 实际位置（单位：脉冲）
            ("prfVel", c_float * 8),   # 规划速度（单位：脉冲/秒）
            ("motionIO", c_long * 8),  # 轴专用IO（按位定义，如限位/报警等）
            ("sts", c_short * 8),      # 轴状态（bitmask状态字）
            ("gpo", c_long),          # 通用数字量输出状态（32位）
            ("gpi", c_long)           # 通用数字量输入状态（32位）
        ]
    """
    // 打包读取8个轴的状态,从第一个轴开始读取
    // axisFirstHandle : 第一个轴句柄
    // pPackSts: 打包的状态数据,参考结构体定义
    """
    def NMC_MtGetStsPack8(axisFirstHandle):
        PackSts = pymtn.TAxisStsPack8()
        libc.NMC_MtGetStsPack8.argtypes = [c_ushort,  POINTER(pymtn.TAxisStsPack8)]
        ret = libc.NMC_MtGetStsPack8(axisFirstHandle,  byref(PackSts))
        return PackSts, ret

    """ 
    // 直线插补
    // segNo:段号；endVel:终点速度;vel:最大速度;synAcc:合成加速度
    // crdAxMask:参与的轴,按位表示
    // pTgPosArray：目标位置数组,长度为3
    """
    def NMC_CrdLineXYZ(crdHandle, segNo,  crdAxMask, TgPosArray, endVel, vel, synAcc):
        TgPosArray_tmp = (c_long * 3)(*map(c_long, TgPosArray))
        libc.NMC_CrdLineXYZ.argtypes = [c_ushort,  c_long,  c_short,  POINTER(c_long),  c_double,  c_double,  c_double]
        ret = libc.NMC_CrdLineXYZ(crdHandle,  segNo,  crdAxMask,  TgPosArray_tmp,  endVel,  vel,  synAcc )
        return ret

    """ 
    // 读取通用输出(按通道,支持超过32位)
    // groupID:DO组,取值范围[0,n],,0: 本地DO31~DO0, 1: 本地DO63~DO32,其他指扩展IO模块
    // pDoValue: 设置通用数字量输出。1, 高电平,0,低电平
    """
    def NMC_GetDO(devHandle,  groupID):
        DoValue_tmp = c_long()
        libc.NMC_GetDO.argtypes = [c_ushort,  c_short,  POINTER(c_long)]
        ret = libc.NMC_GetDO(devHandle,  groupID,  byref(DoValue_tmp))
        return DoValue_tmp, ret
    """ 
    // 设置通用输出(按通道,支持超过32位)
    // groupID:DO组,取值范围[0,n],具体需要看控制器是否存在多组数字量输出
    // value: 设置通用数字量输出。1, 输出高电平,0,输出低电平 
    """

    def NMC_SetDO(devHandle,  groupID,  value):
        libc.NMC_SetDO.argtypes = [c_ushort,  c_short,  c_long]
        return libc.NMC_SetDO(devHandle,  groupID,  value)

    """ 
    // 设置限位开关输入是否停止运动
    // posEn：正向限位触发允许设置,1为允许,0为禁止
    // negEn: 负向限位触发允许设置
    """
    def NMC_MtLmtOnOff(axisHandle,  posSwt,  negSwt):
        libc.NMC_MtLmtOnOff.argtypes = [c_ushort,  c_short,  c_short]
        return libc.NMC_MtLmtOnOff(axisHandle,  posSwt,  negSwt)

    """ 
    // 设置限位开关触发电平
    // posSwt：正向限位触发电平设置,1为高电平触发,0为低电平触发
    // negSwt: 负向限位触发电平设置
    """
    def NMC_MtLmtSns(axisHandle, posSwt, negSwt):
        libc.NMC_MtLmtSns.argtypes = [c_ushort,  c_short,  c_short]
        return libc.NMC_MtLmtSns(axisHandle,  posSwt,  negSwt)

    """ 
    // 设置原点开关触发电平，注意：这里的电平设置不会影响捕获的电平
    // sns：原点电平设置,1为高电平触发,0为低电平触发
    """
    def NMC_MtHomeSns(axisHandle,  sns):
        libc.NMC_MtHomeSns.argtypes = [c_ushort,  c_short]
        return libc.NMC_MtHomeSns(axisHandle,  sns)

    """ 
    // 读取原点开关触发电平
    // pSns：当前的原点电平设置,1为高电平触发,0为低电平触发
    """
    def NMC_MtGetHomeSns(axisHandle):
        Sns_tmp = c_short()
        libc.NMC_MtGetHomeSns.argtypes = [c_ushort,  POINTER(c_short)]
        ret = libc.NMC_MtGetHomeSns(axisHandle,  byref(Sns_tmp))
        return Sns_tmp, ret

    """ 
    // 设置伺服报警开关是否停止运动
    // swt：伺服报警开关输入允许设置,1为允许,0为禁止。（默认为高电平触发）
    """
    def NMC_MtAlarmOnOff(axisHandle, swt):
        libc.NMC_MtAlarmOnOff.argtypes = [c_ushort, c_short]
        return libc.NMC_MtAlarmOnOff(axisHandle,  swt)

    """ 
    // 设置伺服报警开关电平
    // swt：伺服报警触发电平设置,1为高电平触发,0为低电平触发
    """
    def NMC_MtAlarmSns(axisHandle, swt):
        libc.NMC_MtAlarmSns.argtypes = [c_ushort,  c_short]
        return libc.NMC_MtAlarmSns(axisHandle,  swt)

    # 读取打包轴状态（12轴）
    class TAxisStsPack12(Structure):
        _fields_ = [
            ("prfPos", c_long * 12),     # 规划位置（单位：脉冲）
            ("encPos", c_long * 12),     # 实际位置（单位：脉冲）
            ("prfVel", c_float * 12),    # 规划速度（单位：脉冲/秒）
            ("motionIO", c_long * 12),   # 轴专用IO（按位定义）
            ("sts", c_short * 12),       # 轴状态（bitmask状态字）
            ("gpo", c_long),             # 通用数字量输出状态（32位）
            ("gpi", c_long)              # 通用数字量输入状态（32位）
        ]
    """
    // 打包读取12个轴的状态,从第一个轴开始读取
    // axisFirstHandle : 第一个轴句柄
    // pPackSts: 打包的状态数据,参考结构体定义
    """
    def NMC_MtGetStsPack12(axisFirstHandle):
        PackSts = pymtn.TAxisStsPack12()
        libc.NMC_MtGetStsPack12.argtypes = [c_ushort,  POINTER(pymtn.TAxisStsPack12)]
        ret = libc.NMC_MtGetStsPack12(axisFirstHandle,  byref(PackSts))
        return PackSts, ret

    """------------------------------------------------------------------------
    //                                                     
    //  24.自动状态返回
    //                                                   
    //------------------------------------------------------------------------
    """
    UTO_RTN_MAX_AXIS  = 12
    # 打包返回状态结构
    class TAutoRtnPackedSts(Structure):
        _fields_ = [
            ("mtSts", c_short * 12),       # 单轴状态
            ("mtMio", c_short * 12),       # 单轴专用IO
            ("mtPrfPos", c_long * 12),     # 单轴规划位置
            ("mtEncPos", c_long * 12),     # 单轴实际位置
            ("mtPrfVel", c_float * 12),    # 单轴规划速度）

            ("crdSts", c_short * 2),       # 坐标系状态
            ("crdPrfVel", c_float * 2),    # 坐标系运动速度
            ("crdUserSeg", c_long * 2),    # 坐标系运行的缓冲区段号
            ("crdFreeSpace", c_long * 2),  # 坐标系缓冲区剩余空间
            ("crdUsedSpace", c_long * 2),  # 坐标系缓冲区使用空间

            ("gpi", c_long),               # 通用输入
            ("gpo", c_long),               # 通用输出

            ("reserved", c_short * 32)     # 预留
        ]

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

    """ 
    // 设置禁用自动状态返回
    """
    def NMC_DevAutoRtnClr(devHandle):
        libc.NMC_DevAutoRtnClr.argtypes = [c_ushort]
        return libc.NMC_DevAutoRtnClr(devHandle)

    """ 
    // 同步，
    // 把之前的状态缓冲清除掉。以后读到的是同步指令发送后的状态
    // hostTag : 上位机标签，写0
    """
    def NMC_DevAutoRtnSyn(devHandle,  hostTag):
        libc.NMC_DevAutoRtnSyn.argtypes = [c_ushort,  c_long]
        ret = libc.NMC_DevAutoRtnSyn(devHandle,  hostTag)
        return ret

    """ 
    // 读状态
    // packedSts : 打包状态
    """
    def NMC_DevAutoRtnGet(devHandle):
        packedSts = pymtn.TAutoRtnPackedSts()
        Ready_tmp = c_short()
        libc.NMC_DevAutoRtnGet.argtypes = [c_ushort,  POINTER(pymtn.TAutoRtnPackedSts),  POINTER(c_short)]
        ret = libc.NMC_DevAutoRtnGet(devHandle,  byref(packedSts),  byref(Ready_tmp))
        return packedSts, Ready_tmp, ret

    """ 
    // 设置PTP位置比较输出
    // comparaPos： 目标位置，单位是 脉冲
    // upDateVel：比较后的更新速度 pulse/ms
    """
    def NMC_MtSetPtpComparePara(axisHandle, dir,  comparaPos,  upDateVel):
        libc.NMC_MtSetPtpComparePara.argtypes = [c_ushort,  c_short,  c_long,  c_double]
        return libc.NMC_MtSetPtpComparePara(axisHandle,  dir,  comparaPos,  upDateVel)

    """ 
    // 获取PTP比较输出状态
    """
    def NMC_MtGetPtpCompareSts(axisHandle):
        IsCompareActive_tmp = c_short()
        IsCompareOut_tmp = c_short()
        libc.NMC_MtGetPtpCompareSts.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_short)]
        ret = libc.NMC_MtGetPtpCompareSts(axisHandle,  byref(IsCompareActive_tmp),  byref(IsCompareOut_tmp))
        return IsCompareActive_tmp, IsCompareOut_tmp, ret

    """------------------------------------------------------------------------
    //                                                     
    //  Group 25 : 点位自动收发
    //                                                   
    //------------------------------------------------------------------------
    """
    """
    // 设置启用点位自动收发
    """
    def NMC_DevAsynCommSet(devHandle, delayInMs ):
        libc.NMC_DevAsynCommSet.argtypes = [c_ushort,  c_ulong]
        return libc.NMC_DevAsynCommSet(devHandle,  delayInMs)

    """ 
    // 设置关闭点位自动收发
    """
    def NMC_DevAsynCommClr(devHandle ):
        libc.NMC_DevAsynCommClr.argtypes = [c_ushort]
        return libc.NMC_DevAsynCommClr(devHandle)

    """ 
    // 设置启用自动状态返回
    """
    def NMC_DevAsynGetSts(devHandle):
        packedSts = pymtn.TAutoRtnPackedSts()
        Ready_tmp = c_short()
        libc.NMC_DevAsynGetSts.argtypes = [c_ushort,  POINTER(pymtn.TAutoRtnPackedSts),  POINTER(c_short)]
        ret = libc.NMC_DevAsynGetSts(devHandle,  byref(packedSts),  byref(Ready_tmp))
        return packedSts, Ready_tmp, ret

    """ 
    // 多轴点位运动     
    """
    def NMC_DevAsynAbsMoveType1(axisHandle,  acc, dec, vel, smooth, arrivalBand, stableTime, tgtPos):
        libc.NMC_DevAsynAbsMoveType1.argtypes = [c_ushort,  c_float,  c_float,  c_float,  c_short,  c_long,  c_long,  c_long]
        ret = libc.NMC_DevAsynAbsMoveType1(axisHandle,  acc,  dec,  vel,  smooth,  arrivalBand,  stableTime,  tgtPos)
        return ret

    """ 
    // 设置Do
    """
    def NMC_DevAsynSetDoBit(devHandle,  bitIdx, setValue):
        libc.NMC_DevAsynSetDoBit.argtypes = [c_ushort,  c_short,  c_short]
        return libc.NMC_DevAsynSetDoBit(devHandle,  bitIdx,  setValue)

    """------------------------------------------------------------------------
    //                                                     
    //  Group 26 : 一维高速位置比较
    //                                                   
    //------------------------------------------------------------------------
    """
    # 常量定义（对应C的#define）
    CMP_HS1DIMENS_CHN_MAX = 4  # 最大支持4个通道
    CMP_HS1DIMENS_POS_MAX = 8  # 每个通道最多8个位置点

    class TCompHs1DimensParam(Structure):
        _fields_ = [
            ("dirNo", c_short),         # 编码器源（0~7对应轴0~7）
            ("out1StLevel", c_short),   # OUT1起始电平（0/1）
            ("out2StLevel", c_short),   # OUT2起始电平（0/1）
            ("reserved", c_short),      # 保留
            ("out1Width", c_long),      # OUT1脉冲宽度（0-65535μs）
            ("out2Width", c_long),      # OUT2脉冲宽度（0-65535μs）
            ("out2Delay", c_long)       # OUT2延时时间（0-65535μs）
        ]
    """
    // 功能：设置高速1维位置比较的参数（比较编码器）
    // param: 一维比较参数
    // chn：通道号,范围0~3
    // 注：1)需要先设置编码器模式，可设置外部编码器或内部计数。
    //???? 2)比较输出引脚位置请参考硬件手册。
    //???? 3)out1比较位置到后马上输出, out2到位后延时输出。
    """
    def NMC_CompHs1DimensSetParam(devHandle, param, chn ):
        libc.NMC_CompHs1DimensSetParam.argtypes = [c_ushort,  POINTER(pymtn.TCompHs1DimensParam),  c_short]
        ret = libc.NMC_CompHs1DimensSetParam(devHandle,  byref(param),  chn )
        return ret

    """ 
    // 功能：读取高速1维位置比较的参数
    // param, chn：同上
    """
    def NMC_CompHs1DimensGetParam(devHandle, param, chn):
        libc.NMC_CompHs1DimensGetParam.argtypes = [c_ushort,  POINTER(pymtn.TCompHs1DimensParam),  c_short]
        ret = libc.NMC_CompHs1DimensGetParam(devHandle,  byref(param),  chn)
        return param, ret

    """ 
    // 功能：设置高速1维比较数据
    // pArrayPos:比较数组地址
    // count:位置点数
    // chn: 同上
    """
    def NMC_CompHs1DimensSetData(devHandle, ArrayPos, count, chn):
        ArrayPos_tmp = (c_long * count)(*ArrayPos)
        libc.NMC_CompHs1DimensSetData.argtypes = [c_ushort,  POINTER(c_long),  c_short,  c_short]
        ret = libc.NMC_CompHs1DimensSetData(devHandle,  ArrayPos_tmp,  count,  chn)
        return ret

    """ 
    // 功能：高速1维位置比较使能
    // onOff： 0:停止,1:输出,2:手动输出（必须在空闲状态下,也需要提前设置参数）
    // chn: 同上
    """
    def NMC_CompHs1DimensOnOff(devHandle,  onOff, chn):
        libc.NMC_CompHs1DimensOnOff.argtypes = [c_ushort,  c_short,  c_short]
        return libc.NMC_CompHs1DimensOnOff(devHandle,  onOff,  chn)

    """ 
    // 功能：高速1维位置比较的状态
    // pBusy: 0 未启动比较 1 比较输出中
    // pOutCount：输出的个数
    // pWaitCnts：等待比较的个数
    // pFreeCnts：缓冲区空闲的个数
    // chn: 同上
    """
    def NMC_CompHs1DimensStatus(devHandle, chn):
        Busy_tmp = c_short()
        OutCount_tmp = c_short()
        WaitCnts_tmp = c_short()
        FreeCnts_tmp = c_short()
        libc.NMC_CompHs1DimensStatus.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_short),  POINTER(c_short),  POINTER(c_short),  c_short]
        ret = libc.NMC_CompHs1DimensStatus(devHandle,  byref(Busy_tmp),  byref(OutCount_tmp),  byref(WaitCnts_tmp),  byref(FreeCnts_tmp),  chn)
        return Busy_tmp, OutCount_tmp, WaitCnts_tmp,  FreeCnts_tmp, ret

    """------------------------------------------------------------------------
    //                                                     
    //  Group 27 : 获取多轴信息
    //                                                   
    //------------------------------------------------------------------------
    """
    """
    // 读取计时时钟，控制器上电开始
    // pClock:计数值，单位:125us
    // pLoop: 循环周期计数
    """
    def NMC_GetClock(devHandle):
        Clock_tmp = c_ulong()
        Loop_tmp = c_ulong()
        libc.NMC_GetClock.argtypes = [c_ushort,  POINTER(c_ulong),  POINTER(c_ulong)]
        ret = libc.NMC_GetClock(devHandle,  byref(Clock_tmp),  byref(Loop_tmp))
        return Clock_tmp, Loop_tmp, ret

    """ 
    // 获取多轴状态
    // firstAxisHandle:第一个轴句柄
    // pSts:返回的状态数组
    // count:轴数量
    // pClock:返回当前控制器时钟，单位125us
    """
    def NMC_MtGetStsMulti(firstAxisHandle, count):
        StsArray_tmp = (c_short * count)()
        Clock_tmp = c_ulong()
        libc.NMC_MtGetStsMulti.argtypes = [c_ushort,  POINTER(c_short),  c_short,  POINTER(c_ulong)]
        ret = libc.NMC_MtGetStsMulti(firstAxisHandle,  StsArray_tmp,  count,  byref(Clock_tmp))
        return list(StsArray_tmp), Clock_tmp, ret

    """ 
    // 获取多轴规划模式
    // firstAxisHandle:第一个轴句柄
    // pModes:返回的数组
    // count:轴数量
    // pClock:返回当前控制器时钟
    """

    def NMC_MtGetPrfModeMulti( firstAxisHandle, count):
        ModeArray_tmp = (c_short * count)()
        Clock_tmp = c_ulong()
        libc.NMC_MtGetPrfModeMulti.argtypes = [c_ushort,  POINTER(c_short),  c_short,  POINTER(c_ulong)]
        ret = libc.NMC_MtGetPrfModeMulti(firstAxisHandle,  ModeArray_tmp,  count,  byref(Clock_tmp))
        return list(ModeArray_tmp), Clock_tmp, ret

    def NMC_MtGetAxisPrfPosMulti( firstAxisHandle, count):
        PosArray_tmp = (c_long * count)()
        Clock_tmp = c_ulong()
        libc.NMC_MtGetAxisPrfPosMulti.argtypes = [c_ushort,  POINTER(c_long),  c_short,  POINTER(c_ulong)]
        ret = libc.NMC_MtGetAxisPrfPosMulti(firstAxisHandle,  PosArray_tmp,  count,  byref(Clock_tmp))
        return list(PosArray_tmp), Clock_tmp, ret

    def NMC_MtGetAxisPrfVelMulti( firstAxisHandle, count):
        VelArray_tmp = (c_double * count)()
        Clock_tmp = c_ulong()
        libc.NMC_MtGetAxisPrfVelMulti.argtypes = [c_ushort,  POINTER(c_double),  c_short,  POINTER(c_ulong)]
        ret = libc.NMC_MtGetAxisPrfVelMulti(firstAxisHandle,  VelArray_tmp,  count,  byref(Clock_tmp))
        return list(VelArray_tmp), Clock_tmp, ret

    def NMC_MtGetAxisPrfAccMulti( firstAxisHandle, count):
        AccArray_tmp = (c_double * count)()
        Clock_tmp = c_ulong()
        libc.NMC_MtGetAxisPrfAccMulti.argtypes = [c_ushort,  POINTER(c_double),  c_short,  POINTER(c_ulong)]
        ret = libc.NMC_MtGetAxisPrfAccMulti(firstAxisHandle,  AccArray_tmp,  count,  byref(Clock_tmp))
        return list(AccArray_tmp), Clock_tmp, ret

    def NMC_MtGetAxisEncPosMulti( firstAxisHandle, count):
        PosArray_tmp = (c_long * count)()
        Clock_tmp = c_ulong()
        libc.NMC_MtGetAxisEncPosMulti.argtypes = [c_ushort,  POINTER(c_long),  c_short,  POINTER(c_ulong)]
        ret = libc.NMC_MtGetAxisEncPosMulti(firstAxisHandle,  PosArray_tmp,  count,  byref(Clock_tmp))
        return list(PosArray_tmp), Clock_tmp, ret

    def NMC_MtGetAxisEncVelMulti( firstAxisHandle, count):
        VelArray_tmp = (c_double * count)()
        Clock_tmp = c_ulong()
        libc.NMC_MtGetAxisEncVelMulti.argtypes = [c_ushort,  POINTER(c_double),  c_short,  POINTER(c_ulong)]
        ret = libc.NMC_MtGetAxisEncVelMulti(firstAxisHandle,  VelArray_tmp,  count,  byref(Clock_tmp))
        return list(VelArray_tmp), Clock_tmp, ret

    def NMC_MtGetAxisEncAccMulti(firstAxisHandle, count):
        AccArray_tmp = (c_double * count)()
        Clock_tmp = c_ulong()
        libc.NMC_MtGetAxisEncAccMulti.argtypes = [c_ushort,  POINTER(c_double),  c_short,  POINTER(c_ulong)]
        ret = libc.NMC_MtGetAxisEncAccMulti(firstAxisHandle,  AccArray_tmp,  count,  byref(Clock_tmp))
        return list(AccArray_tmp), Clock_tmp, ret

    def NMC_MtGetAxisErrorMulti(firstAxisHandle, count):
        ErrArray_tmp = (c_long * count)()
        Clock_tmp = c_ulong()
        libc.NMC_MtGetAxisErrorMulti.argtypes = [c_ushort,  POINTER(c_long),  c_short,  POINTER(c_ulong)]
        ret = libc.NMC_MtGetAxisErrorMulti(firstAxisHandle,  ErrArray_tmp,  count,  byref(Clock_tmp))
        return list(ErrArray_tmp), Clock_tmp, ret

    """
    // 读取数字量输入信号值
    // diType:DI类型,见DI type宏定义
    // groupID:DI组,取值范围[0,n],对于DI_TYPE_GPI，则0: 本地DI31~DI0, 1: 本地DI63~DI32,其他指扩展IO模块；对于其他DI类型，暂时保留
    // pDiValue:返回的输入值
    """
    def NMC_GetDIEx(devHandle, diType, groupID):
        DiValue_tmp = c_long()
        libc.NMC_GetDIEx.argtypes = [c_ushort,  c_short,  c_short,  POINTER(c_long)]
        ret = libc.NMC_GetDIEx(devHandle,  diType,  groupID,  byref(DiValue_tmp))
        return DiValue_tmp, ret

    """ 
    // 读取数字量输入信号值(原始值)
    // diType:DI类型,见DI type宏定义
    // groupID:DI组,取值范围[0,n],对于DI_TYPE_GPI，则0: 本地DI31~DI0, 1: 本地DI63~DI32,其他指扩展IO模块；对于其他DI类型，暂时保留
    // pDiValue:返回的输入值
    """
    def NMC_GetDIRaw(devHandle, diType, groupID):
        DiValue_tmp = c_long()
        libc.NMC_GetDIRaw.argtypes = [c_ushort,  c_short,  c_short,  POINTER(c_long)]
        ret = libc.NMC_GetDIRaw(devHandle,  diType,  groupID,  byref(DiValue_tmp))
        return DiValue_tmp, ret

    """ 
    // 设置数字量输入信号的翻转计数
    // diType:DI类型,见DI type宏定义
    // diIndex:DI序号，取值范围[0,n]，对于通用输入，只支持0~15，对于其他只支持0~7
    // pReverseCountArray:返回的翻转计数数组
    // count:同时获取的数量，取值范围[1,16]
    """
    def NMC_SetDiReverseCount(devHandle, diType, diIndex, ReverseCountArray, count):
        ReverseCountArray_tmp = (c_ulong * count)(* ReverseCountArray)
        libc.NMC_SetDiReverseCount.argtypes = [c_ushort,  c_short,  c_short,  POINTER(c_ulong),  c_short]
        ret = libc.NMC_SetDiReverseCount(devHandle,  diType,  diIndex,  ReverseCountArray_tmp,  count)
        return ret

    """ 
    // 获取数字量输入信号的翻转计数
    // diType:DI类型
    // diIndex:DI序号，取值范围[0,n]
    // pReverseCountArray:翻转计数数组
    // count:同时获取的数量，取值范围[1,16]
    """
    def NMC_GetDiReverseCount(devHandle, diType, diIndex, count):
        ReverseCountArray_tmp = (c_ulong * count)()
        libc.NMC_GetDiReverseCount.argtypes = [c_ushort,  c_short,  c_short,  POINTER(c_ulong),  c_short]
        ret = libc.NMC_GetDiReverseCount(devHandle,  diType,  diIndex,  ReverseCountArray_tmp,  count)
        return [ReverseCountArray_tmp[i] for i in range(count)], ret

    # DO type
    DO_TYPE_MOTOR_ENABLE = 1 # 电机使能
    DO_TYPE_MOTOR_CLEAR = 2  # 电机报警清除
    DO_TYPE_GPDO = 3         # 通用输出1
    """
    // 输出DO,按照掩码
    // doType:do类型
    // groupID:组号
    // outMask:按位输出掩码
    // outValue:按位输出数值
    """
    def NMC_SetDOMask(devHandle, outMask, outValue , doType, groupID):
        libc.NMC_SetDOMask.argtypes = [c_ushort,  c_long,  c_long,  c_short,  c_short]
        ret = libc.NMC_SetDOMask(devHandle,  outMask,  outValue ,  doType,  groupID)
        return ret

    """
    // 读取模拟量输入电压值
    // ch:通道号，[0,n]表示本地，256表示扩展模拟量通道
    // count:获取的通道数量,取值范围[1,8]
    // pAdcVolArray:获取的电压值数组
    """

    def NMC_GetAdcVoltageMulti(devHandle, ch, count):
        AdcVolArray_tmp = (c_double * count)()
        libc.NMC_GetAdcVoltageMulti.argtypes = [c_ushort, c_short, c_short, POINTER(c_double)]
        ret = libc.NMC_GetAdcVoltageMulti(devHandle, ch, count, AdcVolArray_tmp)
        voltages = [AdcVolArray_tmp[i] for i in range(count)]
        return voltages, ret

    """ 
    // 设置模拟量输出电压值
    // ch:通道号，[0,n]表示本地，256表示扩展模拟量通道
    // count:获取的通道数量,取值范围[1,8]
    // pDacVolArray:获取的电压值数组
    """
    def NMC_SetDacVoltageMulti(devHandle, ch, count, DacVolArray):
        DacVolArray_tmp = (c_double * count)(* DacVolArray)
        libc.NMC_SetDacVoltageMulti.argtypes = [c_ushort,  c_short,  c_short,  POINTER(c_double)]
        ret = libc.NMC_SetDacVoltageMulti(devHandle,  ch,  count,  DacVolArray_tmp)
        return ret

    """ 
    // 读取模拟量输出电压值
    // ch:通道号，[0,n]表示本地，256表示扩展模拟量通道
    // count:获取的通道数量,取值范围[1,8]
    // pDacVolArray:获取的电压值数组
    """
    def NMC_GetDacVoltageMulti(devHandle, ch, count):
        DacVolArray_tmp = (c_double * count)()
        libc.NMC_GetDacVoltageMulti.argtypes = [c_ushort,  c_short,  c_short,  POINTER(c_double)]
        ret = libc.NMC_GetDacVoltageMulti(devHandle,  ch,  count,  DacVolArray_tmp)
        return [DacVolArray_tmp[i] for i in range(count)], ret

    """ 
    // 设置重复捕获次数
    // count:重复捕获次数，取值范围[0,REPEAT_CAPT_MAX_NUM],0表示取消重复捕获
    // 注意:设置后将清除捕获数据
    """
    def NMC_MtSetCaptRepeat(axisHandle, count):
        libc.NMC_MtSetCaptRepeat.argtypes = [c_ushort,  c_short]
        return libc.NMC_MtSetCaptRepeat(axisHandle,  count)

    """ 
    // 读取重复捕获计数
    // pCount:已经捕获次数
    """
    def NMC_MtGetCaptRepeatStatus(axisHandle):
        Count_tmp = c_short()
        libc.NMC_MtGetCaptRepeatStatus.argtypes = [c_ushort,  POINTER(c_short)]
        ret = libc.NMC_MtGetCaptRepeatStatus(axisHandle,  byref(Count_tmp))
        return Count_tmp, ret

    """ 
    // 读取重复捕获位置值
    // pPosArray:返回的位置值数组
    // startNum:起始计数
    // count:重复捕获次数，取值范围[1,32],一次最多读32个
    """
    def NMC_MtGetCaptRepeatPosMulti(axisHandle, startNum, count):
        PosArray_tmp = (c_long * count)()
        libc.NMC_MtGetCaptRepeatPosMulti.argtypes = [c_ushort,  POINTER(c_long),  c_short,  c_short]
        ret = libc.NMC_MtGetCaptRepeatPosMulti(axisHandle,  PosArray_tmp,  startNum,  count)
        return [PosArray_tmp[i] for i in range(count)], ret

    """ 
    // 获取中断的执行时间
    // pServoRunTime:伺服周期当前值
    // pProfileRunTime:规划周期当前值
    """
    def NMC_GetInterruptTime(devHandle):
        ServoRunTime_tmp = c_double()
        ProfileRunTime_tmp = c_double()
        libc.NMC_GetInterruptTime.argtypes = [c_ushort,  POINTER(c_double),  POINTER(c_double)]
        ret = libc.NMC_GetInterruptTime(devHandle,  byref(ServoRunTime_tmp),  byref(ProfileRunTime_tmp))
        return ServoRunTime_tmp, ProfileRunTime_tmp, ret

    """ 
    // 获取中断的最大执行时间
    // pServoRunTimeMax:伺服周期最大值
    // pProfileRunTimeMax:规划周期最大值
    """
    def NMC_GetInterruptTimeMax(devHandle):
        ServoRunTime_tmp = c_double()
        ProfileRunTime_tmp = c_double()
        libc.NMC_GetInterruptTimeMax.argtypes = [c_ushort,  POINTER(c_double),  POINTER(c_double)]
        ret = libc.NMC_GetInterruptTimeMax(devHandle,  byref(ServoRunTime_tmp),  byref(ProfileRunTime_tmp))
        return ServoRunTime_tmp, ProfileRunTime_tmp, ret

    """ 
    // 缓冲区停止坐标系运动
    // crdIdx:停止坐标系序号，-1表示停止自身
    """
    def NMC_CrdBufStopMtn(crdHandle, segNo, crdIdx):
        libc.NMC_CrdBufStopMtn.argtypes = [c_ushort,  c_long,  c_short]
        return libc.NMC_CrdBufStopMtn(crdHandle,  segNo,  crdIdx)

    """ 
    // 使能或关闭输入整形功能
    // enable: 0:取消 1：使能
    // bufCount: 整形的宽度
    // kCoef: 整形的系数
    """
    def NMC_MtSetAxisInputShaping(axisHandle, enable, bufCount, kCoef):
        libc.NMC_MtSetAxisInputShaping.argtypes = [c_ushort,  c_short,  c_short,  c_double]
        return libc.NMC_MtSetAxisInputShaping(axisHandle,  enable,  bufCount,  kCoef)

    """ 
    // 获取输出DO
    // doType:do类型
    // groupID:组号
    // pOutValue:获取的数值
    """
    def NMC_GetDOEx(devHandle, doType, groupID):
        OutValue_tmp = c_long()
        libc.NMC_GetDOEx.argtypes = [c_ushort,  c_short,  c_short,  POINTER(c_long)]
        ret = libc.NMC_GetDOEx(devHandle,  doType,  groupID,  byref(OutValue_tmp))
        return OutValue_tmp, ret

    """ 
    // 获取坐标系状态
    // pSts：crd状态，按位表示
    // pUserSeg：当前的用户段号
    """
    def NMC_CrdGetStsEx(crdHandle):
        Sts_tmp = c_short()
        UserSeg_tmp = c_long()
        libc.NMC_CrdGetStsEx.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_long)]
        ret = libc.NMC_CrdGetStsEx(crdHandle,  byref(Sts_tmp),  byref(UserSeg_tmp))
        return Sts_tmp, UserSeg_tmp, ret

    """ 
    // 输入沿触发
    // diIndex:通用输入序号，只支持通用输入信号，取值范围[0,32]
    // diSns:触发沿，0为下降沿,1为上升沿
    """
    def NMC_MtPtStartMtnEx(axisHandle, diIndex, diSns):
        libc.NMC_MtPtStartMtnEx.argtypes = [c_ushort,  c_short,  c_short]
        return libc.NMC_MtPtStartMtnEx(axisHandle,  diIndex,  diSns)

    """ 
    Note :            1.结构体定义中所有的‘reservedxxx’的成员都是保留参数,为保持兼容性,请设置为0
    //                    2.无特别说明,所有API返回RTN_CMD_SUCCESS（即0值）表示执行成功,其他则表示错误代码
    //                    3.所有的API参数中,无特别说明,axisHandle表示操作轴的句柄,devHandle表示目标控制器的句柄,crdHandle表示目标坐标系组句柄
    //                  4.mtn_lib20中所有的结构体都是以四字节对齐方式编译，为了避免结构体对齐引起的问题，请将编译环境设置为四字节对齐
    // Modification History :
    ///******************************************************************
    """
    """
    // 设置PTP的高级参数
    // minEvenTime:最小匀速时间
    // param1:保留
    """
    def OEM_MtSetMinEventTime(axisHandle, minEvenTime, param1, param2, param3):
        libc.OEM_MtSetMinEventTime.argtypes = [c_ushort,  c_short,  c_short,  c_short,  c_short]
        ret = libc.OEM_MtSetMinEventTime(axisHandle,  minEvenTime,  param1,  param2,  param3)
        return ret

    """ 
    // 读取PTP的高级参数
    """
    def OEM_MtGetMinEventTime(axisHandle):
        minEvenTime_tmp = c_short()
        param1_tmp = c_short()
        param2_tmp = c_short()
        param3_tmp = c_short()
        libc.OEM_MtGetMinEventTime.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_short),  POINTER(c_short),  POINTER(c_short)]
        ret = libc.OEM_MtGetMinEventTime(axisHandle,  byref(minEvenTime_tmp),  byref(param1_tmp),  byref(param2_tmp),  byref(param3_tmp))
        return minEvenTime_tmp, param1_tmp, param2_tmp, param3_tmp, ret

    """ 
    // 多轴同步运动
    // mask:轴掩码
    // pPosArray:位置数组
    """
    def OEM_PtpSync(devHandle, mask, PosArray):
        PosArray_tmp = (c_int32 * len(PosArray))(*PosArray)
        libc.OEM_PtpSync.argtypes = [c_ushort,  c_short,  POINTER(c_int32)]
        ret = libc.OEM_PtpSync(devHandle,  mask,  PosArray_tmp)
        return ret

    """ 
    // 多轴同步运动
    // axCnt:参与的轴数量
    // pAxList:轴列表
    // pPosArray:位置数组
    """
    def OEM_PtpSyncEx(devHandle, axCnt, AxList, PosArray):
        AxList_tmp = (c_int8 * axCnt)(*AxList)
        PosArray_tmp = (c_int32 * axCnt)(*PosArray)
        libc.OEM_PtpSyncEx.argtypes = [c_ushort,  c_int8,  POINTER(c_int8),  POINTER(c_int32)]
        ret = libc.OEM_PtpSyncEx(devHandle,  axCnt,  AxList_tmp,  PosArray_tmp)
        return ret
    """ 
    // 设置PSP的高级参数
    // minEvenTime:最小匀速时间
    MTN_API Int16  __stdcall OEM_MtPspSetMinEventTime(HAND axisHandle,Int16 minEvenTime);
    """
    def OEM_MtPspSetMinEventTime(axisHandle, minEvenTime):
        libc.OEM_MtPspSetMinEventTime.argtypes = [c_ushort,  c_short]
        ret = libc.OEM_MtPspSetMinEventTime(axisHandle,  minEvenTime)
        return ret

    def OEM_MtPspGetMinEventTime(axisHandle):
        minEvenTime_tmp = c_short()
        libc.OEM_MtPspGetMinEventTime.argtypes = [c_ushort,  POINTER(c_short)]
        ret = libc.OEM_MtPspGetMinEventTime(axisHandle,   byref(minEvenTime_tmp))
        return minEvenTime_tmp, ret

    """ 
    // 启动带最小匀速时间的PSP运动
    """
    def OEM_MtPspStartEx(axisHandle, tgtPos):
        libc.OEM_MtPspStartEx.argtypes = [c_ushort,  c_int32]
        return libc.OEM_MtPspStartEx(axisHandle,  tgtPos)

    """ 
    // 多轴同步运动
    // mask:轴掩码
    // pPosArray:位置数组
    """
    def OEM_PspSync(devHandle, axMask, PosArray):
        PosArray_tmp = (c_int32 * len(PosArray))(*PosArray)
        libc.OEM_PspSync.argtypes = [c_ushort,  c_short,  POINTER(c_int32)]
        ret = libc.OEM_PspSync(devHandle,  axMask,  PosArray_tmp)
        return ret

    class TPrfMvParam(Structure):
        _fields_ = [
            ("prfMode", c_int16),   # 规划模式: 0=PTP, 1=PSP
            ("smooth", c_int16),    # 平滑时间(仅PTP有效)
            ("stVel", c_float),     # 起跳速度 (pulse/ms)
            ("endVel", c_float),    # 终点速度 (pulse/ms)
            ("tgtVel", c_float),    # 目标速度 (pulse/ms)
            ("acc", c_float),       # 加速度 (pulse/ms²)
            ("dec", c_float),       # 减速度 (pulse/ms²)
            ("jerkAcc", c_float),   # 加加速度 (pulse/ms³, 仅PSP)
            ("jerkDec", c_float),   # 减加速度 (pulse/ms³, 仅PSP)
            ("sRatio", c_float),    # S段占比 [0,1] (仅PSP)
            ("minEventTm", c_float),# 最小匀速段时间
            ("mvDistance", c_int32),# 运动距离 (pulse)
            ("reserved", c_float * 3)  # 保留字段
        ]

        def __init__(self):
            super().__init__()
            self.prfMode = 0     # PTP模式
            self.smooth = 0      # 无平滑
            self.mvDistance = 0  # 零距离
            self.stVel = 0.0     # 起跳速度0
            self.endVel = 0.0    # 终点速度0
            self.tgtVel = 1.0    # 默认目标速度1
            self.acc = 0.5       #默认加速度0.5
            self.dec = 0.5       # 默认减速度0.5
            self.jerkAcc = 0.0   # 默认加加速度0
            self.jerkDec = 0.0   # 默认减加速度0
            self.sRatio = 0.0     # 默认S段占比0
            self.minEventTm = 0.0  # 默认最小匀速时间0
            # 保留字段
            self.reserved = (c_float * 3)(0.0, 0.0, 0.0)


    """ 
    // 获取点到点运动的理论规划时间
    // pPrfMvParam:运动参数
    // pPrfTimeMs:计算得到的规划耗时，单位:毫秒
    """
    def OEM_MtGetPrfTime(axisHandle, PrfMvParam):
        PrfTimeMs_tmp = c_double()
        libc.OEM_MtGetPrfTime.argtypes = [c_ushort,  POINTER(pymtn.TPrfMvParam),  POINTER(c_double)]
        ret = libc.OEM_MtGetPrfTime(axisHandle,  byref(PrfMvParam),  byref(PrfTimeMs_tmp))
        return PrfTimeMs_tmp, ret

    class TComp2DimensDataGroup(Structure):
        _fields_ = [
            ("xStart", c_int32),  # X起点 (单位：脉冲)
            ("yStart", c_int32),  # Y起点 (单位：脉冲)
            ("xIntv", c_int32),   # X间距 (单位：脉冲)
            ("yIntv", c_int32),   # Y间距 (单位：脉冲)
            ("cnt", c_int32),     # 数量
            ("reserved", c_int32)  # 保留字段
        ]

        def __init__(self):
            super().__init__()
            self.xStart = 0
            self.yStart = 0
            self.xIntv = 0
            self.yIntv = 0
            self.cnt = 0
            self.reserved = 0
    """ 
    // 功能：设置二维比较数据
    // pArrayGroup:比较数组地址
    // count:位置点数,取值范围[0,n),count=0表示清除已经缓存的数据
    // group:组号,0 或者1
    // chn:保留,设为0
    """
    def OEM_Comp2DimensSetDataGroup( devHandle, group, ArrayGroup, count, chn):
        libc.OEM_Comp2DimensSetDataGroup.argtypes = [c_ushort, c_short, POINTER(pymtn.TComp2DimensDataGroup), c_short, c_short]
        ret = libc.OEM_Comp2DimensSetDataGroup(devHandle,  group,  byref(ArrayGroup),  count,  chn)
        return ret

    """ 
    // 功能：高速一维位置比较数据下载
    // pArrayPos:比较数组地址
    // count:数据数量，如果是大批量数据，一般要一次性压入大量数据，建议4096个数据
    // group:比较通道号，0 或者1
    """
    def OEM_Comp2DimensSetDataEx(devHandle, group, ArrayPos, count):
        ArrayPos_tmp = (c_int32 * count)(*ArrayPos)
        libc.OEM_Comp2DimensSetDataEx.argtypes = [c_ushort,  c_short,  POINTER(c_int32),  c_short]
        ret = libc.OEM_Comp2DimensSetDataEx(devHandle,  group,  ArrayPos_tmp,  count)
        return ret

    """ 
    // 功能：高速一维位置比较数据下载,带能量控制
    // pArrayPower:能量控制数组
    """
    def OEM_Comp2DimensSetDataPower(devHandle, group, ArrayPos, ArrayPower, count):
        ArrayPos_tmp = (c_int32 * count)(*ArrayPos)
        ArrayPower_tmp = (c_short * count)(*ArrayPower)
        libc.OEM_Comp2DimensSetDataPower.argtypes = [c_ushort,  c_short,  POINTER(c_int32),  POINTER(c_short),  c_short]
        ret = libc.OEM_Comp2DimensSetDataPower(devHandle,  group,  ArrayPos_tmp,  ArrayPower_tmp,  count)
        return ret

    """ 
    // 功能：设置双头运动中的第二个头相对第一个头的参数
    // 参数：offsetX:双头回原点后，在X方向，第2个头的原点相对第1个头的原点的偏置量
    //             offsetY:双头回原点后，在Y方向，第2个头的原点相对第1个头的原点的偏置量
    //             pAxisNo:[0]第二个头的X轴对应的轴号  [1]第二个头的Y轴对应的轴号
    """
    def NMC_CrdSetDoubleHeadPara(crdHandle, offsetX, offsetY, AxisNo):
        AxisNo_tmp = (c_short * 2)(*AxisNo)
        libc.NMC_CrdSetDoubleHeadPara.argtypes = [c_ushort,  c_int32,  c_int32,  POINTER(c_short)]
        ret = libc.NMC_CrdSetDoubleHeadPara(crdHandle,  offsetX,  offsetY,  AxisNo_tmp)
        return ret

    """ 
    // 功能：读取双头运动中的第二个头相对第一个头的参数
    // 参数：pOffsetX:双头回原点后，在X方向，第2个头的原点相对第1个头的原点的偏置量
    //             pOffsetY:双头回原点后，在Y方向，第2个头的原点相对第1个头的原点的偏置量
    //             pAxisNo:[0]第二个头的X轴对应的轴号  [1]第二个头的Y轴对应的轴号
    """
    def NMC_CrdGetDoubleHeadPara(crdHandle):
        OffsetX_tmp = c_int32()
        OffsetY_tmp = c_int32()
        AxisNo_tmp = (c_short * 2)()
        libc.NMC_CrdGetDoubleHeadPara.argtypes = [c_ushort,  POINTER(c_int32),  POINTER(c_int32),  POINTER(c_short)]
        ret = libc.NMC_CrdGetDoubleHeadPara(crdHandle,  byref(OffsetX_tmp),  byref(OffsetY_tmp),  AxisNo_tmp)
        return OffsetX_tmp, OffsetY_tmp, AxisNo_tmp[0], AxisNo_tmp[1], ret

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

    """ 
    // 功能：建立2号头的与1号头的同步运动关系
    """
    def NMC_CrdBufSecondHeadSyncMoveOn(crdHandle, segNo):
        libc.NMC_CrdBufSecondHeadSyncMoveOn.argtypes = [c_ushort,  c_int32]
        return libc.NMC_CrdBufSecondHeadSyncMoveOn(crdHandle,  segNo)

    """ 
    // 功能：结束2号头的与1号头的同步运动关系
    """
    def NMC_CrdBufSecondHeadSyncMoveOff(crdHandle, segNo):
        libc.NMC_CrdBufSecondHeadSyncMoveOff.argtypes = [c_ushort,  c_int32]
        return libc.NMC_CrdBufSecondHeadSyncMoveOff(crdHandle, segNo)

    """ 
    // 功能：设置多头运动中的第二个头相对第一个头的参数
    // 参数：offsetX:双头回原点后，在X方向，第2个头的原点相对第1个头的原点的偏置量
    //         offsetY:双头回原点后，在Y方向，第2个头的原点相对第1个头的原点的偏置量
    //         pAxisNo:[0]第二个头的X轴对应的轴号  [1]第二个头的Y轴对应的轴号
    //       chn:通道号，取值范围[0,MAX)
    """
    def NMC_CrdSetMultiHeadParaEx(crdHandle, offsetX, offsetY, AxisNo, chn):
        AxisNo_tmp = (c_short * 2)(*AxisNo)
        libc.NMC_CrdSetMultiHeadParaEx.argtypes = [c_ushort,  c_int32,  c_int32,  POINTER(c_short),  c_short]
        ret = libc.NMC_CrdSetMultiHeadParaEx(crdHandle,  offsetX,  offsetY,  AxisNo_tmp,  chn)
        return ret

    """ 
    // 功能：读取多头运动中的第二个头相对第一个头的参数
    // 参数：pOffsetX:双头回原点后，在X方向，第2个头的原点相对第1个头的原点的偏置量
    //         pOffsetY:双头回原点后，在Y方向，第2个头的原点相对第1个头的原点的偏置量
    //         pAxisNo:[0]第二个头的X轴对应的轴号  [1]第二个头的Y轴对应的轴号
    //       chn:通道号，取值范围[0,MAX)
    """
    def NMC_CrdGetMultiHeadParaEx( crdHandle, chn):
        OffsetX_tmp = c_int32()
        OffsetY_tmp = c_int32()
        AxisNo_tmp = (c_short * 2)()
        libc.NMC_CrdGetMultiHeadParaEx.argtypes = [c_ushort,  POINTER(c_int32),  POINTER(c_int32),  POINTER(c_short),  c_short]
        ret = libc.NMC_CrdGetMultiHeadParaEx(crdHandle,  byref(OffsetX_tmp),  byref(OffsetY_tmp),  AxisNo_tmp,  chn)
        return OffsetX_tmp, OffsetY_tmp, AxisNo_tmp[0], AxisNo_tmp[1], ret

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

    """ 
    // 启动跟随头的与主动头的同步运动
    // mask:通道掩码
    """
    def NMC_CrdBufMultiHeadSyncMoveOnEx(crdHandle,  segNo, mask):
        libc.NMC_CrdBufMultiHeadSyncMoveOnEx.argtypes = [c_ushort,  c_int32,  c_short]
        return libc.NMC_CrdBufMultiHeadSyncMoveOnEx(crdHandle,  segNo,  mask)

    """ 
    // 结束启动跟随头的与主动头的同步运动
    // mask:通道掩码
    """
    def NMC_CrdBufMultiHeadSyncMoveOffEx(crdHandle, segNo, mask):
        libc.NMC_CrdBufMultiHeadSyncMoveOffEx.argtypes = [c_ushort,  c_int32,  c_short]
        return libc.NMC_CrdBufMultiHeadSyncMoveOffEx(crdHandle,  segNo,  mask)

    """ 
    // 缓冲区设置激光输出的optionVal
    """
    def OEM_CrdBufLaserSetOptionVal(crdHandle, segNo, optionVal, laserCh):
        libc.OEM_CrdBufLaserSetOptionVal.argtypes = [c_ushort,  c_int32,  c_double,  c_short]
        return libc.OEM_CrdBufLaserSetOptionVal(crdHandle, segNo, optionVal, laserCh)

    def OEM_CrdBufLaserSetParamTableIdx(crdHandle, segNo, tableIdx, laserCh):
        libc.OEM_CrdBufLaserSetParamTableIdx.argtypes = [c_ushort,  c_int32,  c_short,  c_short]
        return libc.OEM_CrdBufLaserSetParamTableIdx(crdHandle, segNo, tableIdx, laserCh)

    def OEM_LaserSetParamTableIdx(devHandle, tableIdx, laserCh):
        libc.OEM_LaserSetParamTableIdx.argtypes = [c_ushort,  c_short,  c_short]
        return libc.OEM_LaserSetParamTableIdx(devHandle, tableIdx, laserCh)

    class TLaserParamTableUnit(Structure):
        _fields_ = [
            # SHIO模式下的参数
            ("gateTime", c_double),  # 设置gate 打开时间,单位：s（内部最小值：1/36us ）,取值范围(0,0.0009)
            ("minFrq", c_int32),  # 最低频率，单位HZ
            ("gateDistance", c_int16),  # 固定模式下的位置间隔 单位：pulse
            ("k", c_int16),  # 低频过渡系数
            ("startDot", c_int16),  # 启动时出光打点
            ("lowFrqRange", c_int16),  # 低频范围：0：100k，1：1M,2:9M
            ("accLowFrqOnVel", c_int16),  # 加速段低频功能的启用速度值
            ("decLowFrqOffVel", c_int16),  # 减速段低频功能的关闭速度值
            ("yCoe", c_int16),  # Y向补偿，取值范围[0,255],实际比例为0~2的比例，coe*256后设到这个变量
            ("yAng", c_int16),  # 光斑的旋转角度

            # 普通模式下的参数
            ("onDelay", c_int32),  # 开光延时,单位us,取值范围[0,65535]
            ("offDelay", c_int32),  # 关光延时,单位us,取值范围[0,65535]
            ("minValue", c_int32),  # 最小输出值，DA输出时，范围[0,32767],占空比输出时，范围[0,100],频率输出时，范围[0,2000000]
            ("maxValue", c_int32),  # 最大输出值，DA输出时，范围[0,32767],占空比输出时，范围[0,100],频率输出时，范围[0,2000000]
            ("standbyPower", c_int32),  # 待机能量,为0表示取消待机能量输出功能
            ("overRide", c_double),  # 跟随倍率,为0表示取消激光能量跟随
            ("followType", c_int16),  # 跟随类型,0：跟随规划速度,1：跟随实际速度
            ("optionVal", c_float),  # 当作为占空比输出时,该值为PWM的频率,单位HZ；
                                     # 当为LASER_PWM_FRQ时,该值作为占空比值,单位为百分比；
                                     # 当为LASER_PWM_FRQ_EXT时,该值为脉宽,单位为微秒,取值范围(0,~)
            ("reserved", c_int16 * 5)  # 保留
        ]

        def __init__(self):
            super().__init__()
            self.gateTime = 0.0
            self.minFrq = 0
            self.gateDistance = 0
            self.k = 0
            self.startDot = 0
            self.lowFrqRange = 0
            self.accLowFrqOnVel = 0
            self.decLowFrqOffVel = 0
            self.yCoe = 0
            self.yAng = 0
            self.onDelay = 0
            self.offDelay = 0
            self.minValue = 0
            self.maxValue = 32767
            self.standbyPower = 0
            self.overRide = 0.1
            self.followType = 0
            self.optionVal = 0.0
            self.reserved = (c_int16 * 5)(0, 0, 0, 0, 0)

    def OEM_LaserSetParamTableUnit(devHandle, tableIdx, ParamUnit):
        libc.OEM_LaserSetParamTableUnit.argtypes = [c_ushort,  c_short, POINTER(pymtn.TLaserParamTableUnit)]
        return libc.OEM_LaserSetParamTableUnit(devHandle, tableIdx, byref(ParamUnit))

    def OEM_LaserGetParamTableUnit(devHandle, tableIdx, ParamUnit):
        libc.OEM_LaserGetParamTableUnit.argtypes = [c_ushort,  c_short, POINTER(pymtn.TLaserParamTableUnit)]
        ret = libc.OEM_LaserGetParamTableUnit(devHandle, tableIdx, byref(ParamUnit))
        return ParamUnit, ret

    """------------------------------------------------------------------------------------------------------------
    //
    //         多段速运动
    //
    //------------------------------------------------------------------------------------------------------------
    """
    # 高速变低速
    class TPvtMoveHighToLow(Structure):
        _fields_ = [
            ("startVel", c_double),  # 第一段起跳速度
            ("highVel", c_double),  # 高速段最大速度
            ("highAcc", c_double),  # 高速段加速度
            ("highDec", c_double),  # 高速段减速度
            ("lowVel", c_double),  # 低速段最大速度
            ("lowDec", c_double),  # 低速段减速度
            ("highDist", c_int32),  # 高速段目标位置
            ("lowDist", c_int32),  # 低速段目标位置
            ("smooth", c_int16),  # 平滑系数(0-50)
            ("reserved", c_int16 * 3)  # 保留字段
        ]

        def __init__(self):
            super().__init__()
            self.startVel = 0.0
            self.highVel = 0.0
            self.highAcc = 0.0
            self.highDec = 0.0
            self.lowVel = 0.0
            self.lowDec = 0.0
            self.highDist = 0
            self.lowDist = 0
            self.smooth = 0
            self.reserved = (c_int16 * 3)(0, 0, 0)

    """
    // 多段速：高速变低速
    """
    def OEM_MtPvtMoveHighToLow(axisHandle, Prm):
        libc.OEM_MtPvtMoveHighToLow.argtypes = [c_ushort,  POINTER(pymtn.TPvtMoveHighToLow)]
        ret = libc.OEM_MtPvtMoveHighToLow(axisHandle,  byref(Prm))
        return ret

    class TPvtMoveLowToHigh(Structure):
        _fields_ = [
            ("startVel", c_double),  # 第一段起跳速度
            ("highVel", c_double),  # 高速段最大速度
            ("highAcc", c_double),  # 高速段加速度
            ("highDec", c_double),  # 高速段减速度
            ("lowVel", c_double),  # 低速段最大速度
            ("lowAcc", c_double),  # 低速段加速度
            ("highDist", c_int32),  # 高速段目标位置
            ("lowDist", c_int32),  # 低速段目标位置
            ("smooth", c_int16),  # 平滑系数，取值[0,50]
            ("reserved", c_int16 * 3)  # 保留字段
        ]

        def __init__(self):
            super().__init__()
            self.startVel = 0.0
            self.highVel = 0.0
            self.highAcc = 0.0
            self.highDec = 0.0
            self.lowVel = 0.0
            self.lowAcc = 0.0
            self.highDist = 0
            self.lowDist = 0
            self.smooth = 0
            self.reserved = (c_int16 * 3)(0, 0, 0)
    """
    // 多段速：低速变高速
    """
    def OEM_MtPvtMoveLowToHigh(axisHandle, Prm):
        libc.OEM_MtPvtMoveLowToHigh.argtypes = [c_ushort,  POINTER(pymtn.TPvtMoveLowToHigh)]
        ret = libc.OEM_MtPvtMoveLowToHigh(axisHandle,  byref(Prm))
        return ret

    # 三段速运动（高低高）
    class TPvtMove3Stage(Structure):
        _fields_ = [
            ("startVel", c_double),  # 起跳速度
            ("vel1", c_double),  # 第1段匀速运动的速度
            ("acc1", c_double),  # 第1段加速度
            ("dec1", c_double),  # 第1段减速度
            ("vel2", c_double),  # 第2段匀速运动的速度
            ("vel3", c_double),  # 第3段匀速运动速度
            ("acc3", c_double),  # 第3段加速到第3段的加速度
            ("dec3", c_double),  # 第3段减速度
            ("dist1", c_int32),  # 第1段行程
            ("dist2", c_int32),  # 第2段行程
            ("dist3", c_int32),  # 第3段行程
            ("reserved2", c_int32),  # 保留
            ("smooth", c_int16),  # 平滑系数，取值[0,50]
            ("reserved", c_int16 * 3)  # 保留字段
        ]

        def __init__(self):
            super().__init__()
            self.startVel = 0.0
            self.vel1 = 0.0
            self.acc1 = 0.0
            self.dec1 = 0.0
            self.vel2 = 0.0
            self.vel3 = 0.0
            self.acc3 = 0.0
            self.dec3 = 0.0
            self.dist1 = 0
            self.dist2 = 0
            self.dist3 = 0
            self.reserved2 = 0
            self.smooth = 0
            self.reserved = (c_int16 * 3)(0, 0, 0)

    """
    // 多段速：三段速运动（高低高）
    """
    def OEM_MtPvt3Stage(axisHandle, Prm):
        libc.OEM_MtPvt3Stage.argtypes = [c_ushort, POINTER(pymtn.TPvtMove3Stage)]
        ret = libc.OEM_MtPvt3Stage(axisHandle,  byref(Prm))
        return ret

    """ 
    // 更新目标位置
    """
    def OEM_MtUpdateTgtPos(axisHandle, tgtPos):
        libc.OEM_MtUpdateTgtPos.argtypes = [c_ushort,  c_int32]
        return libc.OEM_MtUpdateTgtPos(axisHandle,  tgtPos)

    """
    // 更新目标位置及目标速度
    """
    def OEM_MtUpdateTgtPosAndVel(axisHandle, tgtPos, maxVel):
        libc.OEM_MtUpdateTgtPosAndVel.argtypes = [c_ushort,  c_int32,  c_float]
        return libc.OEM_MtUpdateTgtPosAndVel(axisHandle, tgtPos, maxVel)

    """
    //------------------------------------------------------------------------------------------------------------
    //
    //         坐标系的速度，补偿激光
    //
    //------------------------------------------------------------------------------------------------------------
    """

    class TLaserCrdVelCompTable(Structure):
        _fields_ = [
            ("count", c_int16),   # 实际点数
            ("mode", c_int16),    # 补偿模式：0=option值, 1=输出能量, 2=能量跟随倍率
            ("src", c_int16),     # 跟随类型：0=编码器速度, 1=规划速度
            ("reserved", c_int16 * 5),  # 保留字段
            ("vel", c_float * LASER_CRDVELCOMP_PT_MAX),  # 速度表
            ("comp", c_float * LASER_CRDVELCOMP_PT_MAX)  # 补偿值表
        ]

        def __init__(self):
            super().__init__()
            self.count = 0
            self.mode = 0
            self.src = 0
            for i in range(LASER_CRDVELCOMP_PT_MAX):
                self.vel[i] = 0.0
                self.comp[i] = 0.0
            for i in range(5):
                self.reserved[i] = 0
    """ 
    // 配置坐标系速度补偿表
    // pCompTable：补偿表
    // group:补偿表格的序号，取值范围[0,LASER_CRDVELCOMP_GROUP_MAX)
    """
    def OEM_LaserSetCrdVelCompTable(devHandle, CompTable, group):
        libc.OEM_LaserSetCrdVelCompTable.argtypes = [c_ushort,  POINTER(pymtn.TLaserCrdVelCompTable),  c_short]
        ret = libc.OEM_LaserSetCrdVelCompTable(devHandle,  byref(CompTable),  group)
        return ret

    def OEM_LaserGetCrdVelCompTable(devHandle, CompTable, group):
        libc.OEM_LaserGetCrdVelCompTable.argtypes = [c_ushort,  POINTER(pymtn.TLaserCrdVelCompTable),  c_short]
        ret = libc.OEM_LaserGetCrdVelCompTable(devHandle,  byref(CompTable),  group)
        return CompTable, ret

    """ 
    // 启用或关闭速度补偿功能
    // crdNo: 坐标系编号，[0,1]
    // onOff：启用或关闭，0：关闭补偿功能，1：启用补偿功能
    // group:补偿表格的序号，取值范围[0,LASER_CRDVELCOMP_GROUP_MAX)
    // laserCh:激光通道号
    """
    def OEM_LaserCrdVelCompOnOff(devHandle, crdNo, onOff, group, laserCh):
        libc.OEM_LaserCrdVelCompOnOff.argtypes = [c_ushort,  c_short,  c_short,  c_short,  c_short]
        return libc.OEM_LaserCrdVelCompOnOff(devHandle,  crdNo, onOff,  group,  laserCh)

    """ 
    // 启用或关闭速度补偿功能,缓冲区指令
    // onOff：启用或关闭，0：关闭补偿功能，1：启用补偿功能
    // group:补偿表格的序号，取值范围[0,LASER_CRDVELCOMP_GROUP_MAX)
    // laserCh:激光通道号
    """
    def OEM_CrdBufLaserCrdVelCompOnOff(crdHandle, segNo, onOff, group, laserCh):
        libc.OEM_CrdBufLaserCrdVelCompOnOff.argtypes = [c_ushort,  c_int32,  c_short,  c_short,  c_short]
        return libc.OEM_CrdBufLaserCrdVelCompOnOff(crdHandle,  segNo,  onOff,  group,  laserCh)

    """ 
    // 读取单轴急停DI的触发状态
    // pTrigSts:是否触发，1表示已经触发。NMC_MtSetEstopDIMask/NMC_MtSetEstopDI指令会复位触发状态。
    // pTrigIndex:本次触发的di序号。NMC_MtSetEstopDIMask/NMC_MtSetEstopDI指令会复位触发状态。
    """
    def OEM_MtGetEstopDITrigSts(axisHandle):
        TrigSts_tmp = c_short()
        TrigIndex_tmp = c_short()
        libc.OEM_MtGetEstopDITrigSts.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_short)]
        ret = libc.OEM_MtGetEstopDITrigSts(axisHandle,  byref(TrigSts_tmp),  byref(TrigIndex_tmp))
        return TrigSts_tmp, TrigIndex_tmp, ret

    """ 
    // 缓冲区启动单轴PTP二段速运动
    // segNo:段号
    // axisNo：轴号，取值[0,n),非坐标系内轴
    // tgtPos：目标位置
    // blockEn:0:非阻塞非同步，1：阻塞
    // 二段速的参数参考TPtpTwoStagePrm定义
    """
    def OEM_CrdBufSetPtpTwoStage(crdHandle, segNo, axisNo, tgtPos, inType, inIndex, inTrigLevel, action, prm1, prm2, prm3, prm4, blockEn):
        libc.OEM_CrdBufSetPtpTwoStage.argtypes = [c_ushort,  c_int32,  c_short,  c_int32,  c_short,  c_short,  c_short,  c_short,  c_double,  c_double,  c_double,  c_double,  c_short]
        ret = libc.OEM_CrdBufSetPtpTwoStage(crdHandle,  segNo,  axisNo,  tgtPos,  inType,  inIndex,  inTrigLevel,  action,  prm1,  prm2,  prm3,  prm4,  blockEn)
        return ret

    """ 
    // 缓冲区单轴移动参数设置
    // segNo:段号
    // axisNo：轴号,[0,n]
    // vel:运动速度
    // acc:运动加速度
    // dec:运动减加速度
    // velS:运动启动速度
    // velE:运动终点速度
    // smoothCoef:平滑系数
    """
    def OEM_CrdBufSetPtpMoveParaEx(crdHandle, segNo, axisNo, vel, acc, dec, velS, velE, soomthCoef):
        libc.OEM_CrdBufSetPtpMoveParaEx.argtypes = [c_ushort,  c_int32,  c_short,  c_double,  c_double,  c_double,  c_double,  c_double,  c_short]
        return libc.OEM_CrdBufSetPtpMoveParaEx(crdHandle,  segNo,  axisNo,  vel,  acc,  dec,  velS,  velE,  soomthCoef)

    """ 
    // 缓冲区补偿激光偏移值
    // segNo:段号
    // compType:bias类型，0:能量 1:跟随系数 2:option值
    // bias:偏移值
    // ch:激光通道
    """
    def OEM_CrdBufSetLaserBias(crdHandle, segNo, biasType, bias, ch):
        libc.OEM_CrdBufSetLaserBias.argtypes = [c_ushort,  c_int32,  c_short,  c_double,  c_short]
        ret = libc.OEM_CrdBufSetLaserBias(crdHandle, segNo, biasType, bias, ch)
        return ret

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

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

    class TUartPara(Structure):
        _fields_ = [
            ("baudrate", c_int32),  # 波特率
            ("mode", c_int16),      # 端口的工作模式:0:默认，扩展模块工作模式，1:自由协议模式
            ("dataBits", c_int16),  # 数据位,取值范围[7,8]
            ("stopBits", c_int16),  # 停止位,取值范围[0,2]，参考宏定义，如UART_STOP_BITS_10等
            ("parity", c_int16),    # 校验方式，如UART_PARITY_N等
            ("rxBufLen", c_int16),  # 接收缓存长度，默认128
            ("txBufLen", c_int16),  # 发送缓存长度，默认128
            ("reserved", c_int16 * 4)  # 保留字段
        ]

        def __init__(self):
            super().__init__()
            self.baudrate = 19200
            self.mode = 0
            self.dataBits = 8
            self.stopBits = 0
            self.parity = 0
            self.rxBufLen = 128
            self.txBufLen = 128
            for i in range(4):
                self.reserved[i] = 0
    """
    // 配置Uart端口在自由模式下的通讯参数
    // pParam:参数
    // ch:保留，请写0
    """
    def OEM_DevUartSetPara(devHandle, Param, ch):
        libc.OEM_DevUartSetPara.argtypes = [c_ushort,  POINTER(pymtn.TUartPara),  c_short]
        ret = libc.OEM_DevUartSetPara(devHandle,  byref(Param),  ch)
        return ret

    """ 
    // 获取Uart端口的参数
    """
    def OEM_DevUartGetPara(devHandle, Param, ch):
        libc.OEM_DevUartGetPara.argtypes = [c_ushort, POINTER(pymtn.TUartPara),  c_short]
        ret = libc.OEM_DevUartGetPara(devHandle,  byref(Param),  ch)
        return Param, ret

    """ 
    // 打开或关闭UART
    // onOff:0：关闭，1：打开
    // ch:保留，请写0
    """
    def OEM_DevUartOnOff(devHandle, onOff, ch):
        libc.OEM_DevUartOnOff.argtypes = [c_ushort,  c_short,  c_short]
        return libc.OEM_DevUartOnOff(devHandle, onOff, ch)

    """ 
    // 读Uart端口
    // onOff:0：关闭，1：打开
    // pBuf:读数据接收缓存区
    // readLen:需要读取的数据长度，byte,一次最多读256字节
    // retLen:实际读到的数据长度，byte
    // ch:保留，请写0
    """
    def OEM_DevUartRead(devHandle, readLen, ch):
        Buf_tmp = (c_uint8 * readLen)()
        retLen_tmp = c_short()
        libc.OEM_DevUartRead.argtypes = [c_ushort,  POINTER(c_uint8),  c_short,  POINTER(c_short),  c_short]
        ret = libc.OEM_DevUartRead(devHandle,  Buf_tmp,  readLen,  byref(retLen_tmp),  ch)
        return list(Buf_tmp[:retLen_tmp.value]), retLen_tmp, ret

    """ 
    // 写Uart端口
    // onOff:0：关闭，1：打开
    // pBuf:写数据
    // writeLen:写的数据长度，byte,一次最多写256字节
    // writedLen:实际写出的数据长度，byte
    // ch:保留，请写0
    """
    def OEM_DevUartWrite(devHandle, Buf, writeLen, ch):
        Buf_tmp = (c_uint8 * len(Buf))(*Buf)
        writedLen_tmp = c_short()
        libc.OEM_DevUartWrite.argtypes = [c_ushort,  POINTER(c_uint8),  c_short,  POINTER(c_short),  c_short]
        ret = libc.OEM_DevUartWrite(devHandle,  Buf_tmp,  writeLen,  writedLen_tmp,  ch)
        return writedLen_tmp, ret

    """ 
    // 清除接收缓存
    """
    def OEM_DevUartClrRx(devHandle, ch):
        libc.OEM_DevUartClrRx.argtypes = [c_ushort,  c_short]
        return libc.OEM_DevUartClrRx(devHandle,  ch)

    """ 
    // 获取当前串口收到的数据长度
    // pOnOff:打开状态
    // pLen:缓存的数据长度
    // ch:保留，请写0
    """
    def OEM_DevUartGetRxLen(devHandle, ch):
        OnOff_tmp = c_short()
        Len_tmp = c_int32()
        libc.OEM_DevUartGetRxLen.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_int32),  c_short]
        ret = libc.OEM_DevUartGetRxLen(devHandle,  byref(OnOff_tmp),  byref(Len_tmp),  ch)
        return OnOff_tmp, Len_tmp, ret

    """ 
    // 带减速度的单轴停止功能,
    // dec:减速度,单位：pulse/ms^2
    // 注意：1.仅对PTP及Jog运动有效，对于其他运动模式，等同于NMC_MtStop
    //       2.如果指定的减速度太小，则自动按照合适的减速度减速为0
    """
    def OEM_MtStopEx(axisHandle, dec):
        libc.OEM_MtStopEx.argtypes = [c_ushort,  c_double]
        return libc.OEM_MtStopEx(axisHandle,  dec)

    """ 
    // 周期同步
    """
    def OEM_Sync(devHandle):
        libc.OEM_Sync.argtypes = [c_ushort]
        return libc.OEM_Sync(devHandle)

    class TRepeatCaptParamEx(Structure):
        _fields_ = [
            ("axMask", c_int16),    # 捕获的轴掩码（bit0-7对应轴0-7）
            ("captMode", c_int16),  # 捕获模式（参考NMC_MtSetCaptSns）
            ("captIoSrc", c_int16), # 捕获源（参考NMC_MtSetCaptSns）
            ("captLev", c_int16),   # 捕获电平（0=低电平，1=高电平）参考NMC_MtSetCaptSns的参数定义
            ("captMaxCnt", c_int32),  # 最大捕获数据量
            ("reserved", c_int16 * 2)  # 保留字段
        ]

        def __init__(self):
            super().__init__()
            self.axMask = 0     # 默认不捕获任何轴
            self.captMode = 0   # 默认捕获模式
            self.captIoSrc = 0  # 默认捕获源
            self.captLev = 0    # 默认低电平触发
            self.captMaxCnt = 0 # 默认不限制捕获数量
            self.reserved[0] = 0  # 保留字段清零
            self.reserved[1] = 0
    """ 
    // 设置重复捕获Ex的参数
    // pParam:重复捕获cans
    // ch:通道号，保留，请填0
    """
    def OEM_CaptRepeatSetParamEx(devHandle,Param, ch):
        libc.OEM_CaptRepeatSetParamEx.argtypes = [c_ushort,  POINTER(pymtn.TRepeatCaptParamEx),  c_short]
        ret = libc.OEM_CaptRepeatSetParamEx(devHandle,  byref(Param),  ch)
        return ret

    def OEM_CaptRepeatGetParamEx(devHandle, Param, ch):
        libc.OEM_CaptRepeatGetParamEx.argtypes = [c_ushort,  POINTER(pymtn.TRepeatCaptParamEx),  c_short]
        ret = libc.OEM_CaptRepeatGetParamEx(devHandle,  byref(Param),  ch)
        return Param, ret

    """ 
    // 启动或关闭重复捕获
    // onOff:1:开，0:关
    // ch:通道号，保留，请填0
    """
    def OEM_CaptRepeatOnOffEx(devHandle, onOff, ch):
        libc.OEM_CaptRepeatOnOffEx.argtypes = [c_ushort,  c_short,  c_short]
        return libc.OEM_CaptRepeatOnOffEx(devHandle,  onOff,  ch)

    """ 
    // 读取重复捕获计数
    // pOnOff:onOff状态
    // pLeftCount:剩余的捕获次数
    // pSumCnt:累计捕获次数
    // pGetCount:已经获取的次数
    // ch:通道号，保留，请填0
    """
    def OEM_CaptRepeatGetStatusEx(devHandle, ch):
        OnOff_tmp = c_short()
        LeftCount_tmp = c_int32()
        GetCount_tmp = c_int32()
        SumCnt_tmp = c_int32()
        libc.OEM_CaptRepeatGetStatusEx.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_int32),  POINTER(c_int32),  POINTER(c_int32),  c_short]
        ret = libc.OEM_CaptRepeatGetStatusEx(devHandle,  byref(OnOff_tmp),  byref(LeftCount_tmp),  byref(GetCount_tmp),  byref(SumCnt_tmp),  ch)
        return OnOff_tmp, LeftCount_tmp, GetCount_tmp, SumCnt_tmp, ret

    """ 
    // 读取重复捕获位置值
    // pPosArray:返回的位置值数组
    // count:要读取的触发位置组数，取值范围[1,32]
    //       注意：捕获每触发一次，会产生n个位置数据（多轴），比如同时捕获四个轴，则count=1表示拿回四个位置值
    // pGetCount:实际返回的数目
    // ch:通道号，保留，请填0
    """
    def OEM_CaptRepeatGetPosEx(devHandle, count, ch):
        param = pymtn.TRepeatCaptParamEx()
        param, ret = pymtn.OEM_CaptRepeatGetParamEx(devHandle, param, ch)  # 调用Python包装函数
        if ret != 0:
            return [], 0, ret
        ax_mask = param.axMask
        axis_count = bin(ax_mask).count('1')

        buffer_size = count * axis_count
        PosArray_tmp = (c_int32 * buffer_size)()
        GetCount_tmp = c_short()

        libc.OEM_CaptRepeatGetPosEx.argtypes = [c_ushort,  POINTER(c_int32),  c_short,  POINTER(c_short),  c_short]
        ret = libc.OEM_CaptRepeatGetPosEx(devHandle,  PosArray_tmp,  count,  GetCount_tmp,  ch)

        actual_size = GetCount_tmp * axis_count
        positions = list(PosArray_tmp[:actual_size])
        grouped_positions = [
            positions[i:i + axis_count]
            for i in range(0, actual_size, axis_count)
        ]
        return grouped_positions, GetCount_tmp, ret

    """
    //------------------------------------------------------------------------------------------------------------
    //
    //    Modbus
    //
    //------------------------------------------------------------------------------------------------------------
    """
    class TModbusParam(Structure):
        _fields_ = [
            ("mode", c_int16),       # 模式：-1=扩展模块, 0=RTU从站, 1=ASCII, 16=RTU主站
            ("slaveAddr", c_int16),  # 从站地址（从站模式有效）
            ("port", c_int16),       # 硬件端口（通常为2）
            ("parity", c_int16),     # 校验：0=无, 1=奇, 2=偶
            ("dataBit", c_int16),    # 数据位（通常7或8）
            ("stopBit", c_int16),    # 停止位（通常1或2）
            ("bautrate", c_int32),   # 波特率（如9600, 19200等）
            ("masterTimeout", c_int16),  # 主站超时（毫秒）
            ("reserved", c_int16 * 7)  # 保留字段
        ]

        def __init__(self):
            super().__init__()
            self.mode = 0       # 默认RTU从站模式
            self.slaveAddr = 1  # 默认从站地址1
            self.port = 2     # 默认端口2
            self.parity = 0   # 默认无校验
            self.dataBit = 8  # 默认8数据位
            self.stopBit = 1  # 默认1停止位
            self.bautrate = 0  # 默认波特率
            self.masterTimeout = 0  # 默认主站超时
            for i in range(7):
                self.reserved[i] = 0
    """ 
    // Modbus初始化
    // pParam:参数
    """
    def OEM_ModbusInit(devHandle, Param):
        libc.OEM_ModbusInit.argtypes = [c_ushort,  POINTER(pymtn.TModbusParam)]
        ret = libc.OEM_ModbusInit(devHandle,  byref(Param))
        return ret

    """ 
    // Modbus寄存器参数读取
    // regType:寄存器类型,0:din,bit;1:coil,bit;2:input word,4:holding,word
    // pRegCnt:寄存器个数
    // pStartAddr:寄存器起始地址
    """
    def OEM_ModbusGetRegParam(devHandle, regType):
        RegCnt_tmp = c_short()
        StartAddr_tmp = c_int32()
        libc.OEM_ModbusGetRegParam.argtypes = [c_ushort,  c_short,  POINTER(c_short),  POINTER(c_int32)]
        ret = libc.OEM_ModbusGetRegParam(devHandle,  regType,  byref(RegCnt_tmp),  byref(StartAddr_tmp))
        return (RegCnt_tmp, StartAddr_tmp, ret)

    """ 
    // Modbus寄存器参数设置
    // regType:寄存器类型,0:din,bit;1:coil,bit;2:input word,4:holding,word
    // regCnt:寄存器个数
    // startAddr:寄存器起始地址
    """
    def OEM_ModbusSetRegParam(devHandle, regType, regCnt, startAddr):
        libc.OEM_ModbusSetRegParam.argtypes = [c_ushort,  c_short,  c_short,  c_int32]
        ret = libc.OEM_ModbusSetRegParam(devHandle, regType, regCnt, startAddr)
        return ret

    """ 
    // Modbus参数读取
    // pParam:参数
    """
    def OEM_ModbusGetParam(devHandle,Param):
        libc.OEM_ModbusGetParam.argtypes = [c_ushort,  POINTER(pymtn.TModbusParam)]
        ret = libc.OEM_ModbusGetParam(devHandle,  byref(Param))
        return Param, ret

    """ 
    // 获取当前的modbus参数
    // pSts: 
        //0:unset
        //1:slave mode, unconnected
        //2:slave mode, connected
        //3:master mode, unconnected
        //4:master mode, connected
    """
    def OEM_ModbusGetSts(devHandle):
        Sts_tmp = c_int16()
        libc.OEM_ModbusGetSts.argtypes = [c_ushort,  POINTER(c_int16)]
        ret = libc.OEM_ModbusGetSts(devHandle,  byref(Sts_tmp))
        return (Sts_tmp, ret)

    """ 
    // Modbus关闭
    // flag:1表示切换回扩展模块模式，其他标志只关闭Modbus
    """
    def OEM_ModbusClose(devHandle, flag):
        libc.OEM_ModbusClose.argtypes = [c_ushort,  c_short]
        return libc.OEM_ModbusClose(devHandle,  flag)

    """ 
    // Modebus:读取开关输入
    // offset:地址偏移
    // count:数据数量
    // pBuff:返回的数据
    // slaveAddr:对于控制器作为从站，该参数可选或无效，控制器作为主站，表示从站地址[1~127]
    """
    def OEM_ModbusGetDin(devHandle, offset, count, slaveAddr):
        byte_count = (count + 7) // 8
        Buff_tmp =(c_uint8 * byte_count)()
        libc.OEM_ModbusGetDin.argtypes = [c_ushort,  c_short,  c_short,  POINTER(c_uint8),  c_short]
        ret = libc.OEM_ModbusGetDin(devHandle,  offset,  count,  Buff_tmp,  slaveAddr)
        return list(Buff_tmp), ret

    """ 
    // Modebus:读取线圈输入
    // offset:地址偏移
    // count:数据数量
    // pBuff:返回的数据
    // slaveAddr:对于控制器作为从站，该参数可选或无效，控制器作为主站，表示从站地址[1~127]
    """
    def OEM_ModbusGetCoil(devHandle, offset, count, slaveAddr):
        byte_count = (count + 7) // 8
        Buff_tmp =(c_uint8 * byte_count)()
        libc.OEM_ModbusGetCoil.argtypes = [c_ushort,  c_short,  c_short,  POINTER(c_uint8),  c_short]
        ret = libc.OEM_ModbusGetCoil(devHandle,  offset,  count,  Buff_tmp,  slaveAddr)
        return list(Buff_tmp), ret

    """ 
    // Modebus:读取保持寄存器
    // offset:地址偏移
    // count:数据数量
    // pBuff:返回的数据
    // slaveAddr:对于控制器作为从站，该参数可选或无效，控制器作为主站，表示从站地址[1~127]
    """
    def OEM_ModbusGetHolding(devHandle, offset, count, slaveAddr):
        Buff_tmp = (c_ushort * count)()
        libc.OEM_ModbusGetHolding.argtypes = [c_ushort,  c_short,  c_short,  POINTER(c_ushort),  c_short]
        ret = libc.OEM_ModbusGetHolding(devHandle,  offset,  count,  Buff_tmp,  slaveAddr)
        return list(Buff_tmp), ret

    """ 
    // Modebus:读取16位输入寄存器
    // offset:地址偏移
    // count:数据数量
    // pBuff:返回的数据
    // slaveAddr:对于控制器作为从站，该参数可选或无效，控制器作为主站，表示从站地址[1~127]
    """
    def OEM_ModbusGetInput(devHandle, offset, count, slaveAddr):
        Buff_tmp = (c_ushort * count)()
        libc.OEM_ModbusGetInput.argtypes = [c_ushort,  c_short,  c_short,  POINTER(c_ushort),  c_short]
        ret = libc.OEM_ModbusGetInput(devHandle,  offset,  count,  Buff_tmp,  slaveAddr)
        return list(Buff_tmp), ret

    """ 
    // Modebus:写开关输入
    // offset:地址偏移
    // count:数据数量
    // pBuff:数据
    // slaveAddr:对于控制器作为从站，该参数可选或无效，控制器作为主站，表示从站地址[1~127]
    """
    def OEM_ModbusSetDin(devHandle, offset, count, Buff, slaveAddr):
        Buff_tmp = (c_uint8 * count)(*Buff)
        libc.OEM_ModbusSetDin.argtypes = [c_ushort,  c_short,  c_short,  POINTER(c_uint8),  c_short]
        ret = libc.OEM_ModbusSetDin(devHandle,  offset,  count,  Buff_tmp,  slaveAddr)
        return ret

    """ 
    // Modebus:写线圈输入
    // offset:地址偏移
    // count:数据数量
    // pBuff:数据
    // slaveAddr:对于控制器作为从站，该参数可选或无效，控制器作为主站，表示从站地址[1~127]
    """
    def OEM_ModbusSetCoil(devHandle, offset, count, Buff, slaveAddr):
        Buff_tmp = (c_uint8 * count)(*Buff)
        libc.OEM_ModbusSetCoil.argtypes = [c_ushort,  c_short,  c_short,  POINTER(c_uint8),  c_short]
        ret = libc.OEM_ModbusSetCoil(devHandle,  offset,  count,  Buff_tmp,  slaveAddr)
        return ret

    """ 
    // Modebus:写保持寄存器
    // offset:地址偏移
    // count:数据数量
    // pBuff:数据
    // slaveAddr:对于控制器作为从站，该参数可选或无效，控制器作为主站，表示从站地址[1~127]
    """
    def OEM_ModbusSetHolding(devHandle, offset, count,Buff, slaveAddr):
        Buff_tmp = (c_ushort * count)(*Buff)
        libc.OEM_ModbusSetHolding.argtypes = [c_ushort,  c_short,  c_short,  POINTER(c_ushort),  c_short]
        ret = libc.OEM_ModbusSetHolding(devHandle,  offset,  count,  Buff_tmp,  slaveAddr)
        return ret

    """ 
    // Modebus:写16位输入寄存器
    // offset:地址偏移
    // count:数据数量
    // pBuff:数据
    // slaveAddr:对于控制器作为从站，该参数可选或无效，控制器作为主站，表示从站地址[1~127]
    """
    def OEM_ModbusSetInput(devHandle, offset, count, Buff, slaveAddr):
        Buff_tmp = (c_ushort * count)(*Buff)
        libc.OEM_ModbusSetInput.argtypes = [c_ushort,  c_short,  c_short,  POINTER(c_ushort),  c_short]
        ret = libc.OEM_ModbusSetInput(devHandle,  offset,  count,  Buff_tmp,  slaveAddr)
        return ret

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

    class TCrdSymmParam(Structure):
        _fields_ = [
            ("masterCent", c_int32 * 2),  # 主平面圆心坐标 [x, y]
            ("slaveCent", c_int32 * 2),   # 次平面圆心坐标 [x, y]
            ("masterStart", c_int32 * 2), # 主平面起点坐标 [x, y]
            ("slaveStart", c_int32 * 2),  # 次平面起点坐标 [x, y]
            ("slaveAxMask", c_int16),     # 从轴掩码，两个轴，非坐标系内
            ("reserved", c_int16 * 3)     # 保留参数
        ]

        def __init__(self):
            super().__init__()
            self.masterCent[:] = (c_int32 * 2)(0, 0)
            self.slaveCent[:] = (c_int32 * 2)(0, 0)
            self.masterStart[:] = (c_int32 * 2)(0, 0)
            self.slaveStart[:] = (c_int32 * 2)(0, 0)
            self.slaveAxMask = 0
            self.reserved[:] = (c_int16 * 3)(0, 0, 0)
    """
    // 设置对称运动参数
    """
    def OEM_CrdSetSymmParam(crdHandle, Param):
        libc.OEM_CrdSetSymmParam.argtypes = [c_ushort,  POINTER(pymtn.TCrdSymmParam)]
        ret = libc.OEM_CrdSetSymmParam(crdHandle,  byref(Param))
        return ret

    """ 
    // 启动或关闭对称跟随运动
    """
    def OEM_CrdBufSymmOnOff(crdHandle,  segNo, onOff):
        libc.OEM_CrdBufSymmOnOff.argtypes = [c_ushort,  c_int32,  c_short]
        return libc.OEM_CrdBufSymmOnOff(crdHandle,  segNo,  onOff)

    # 圆形限位
    class TCircleLimitPara(Structure):
        _fields_ = [
            ("axMask", c_int16),  # 关联的轴掩码
            ("mode", c_int16),  # 0:触发后停止关联轴运动，1：停止并置起急停标志位
            ("centPosX", c_int32),  # 圆形限位的圆心X，单位：pulse
            ("centPosY", c_int32),  # 圆形限位的圆心Y，单位：pulse
            ("radius", c_int32),  # 半径（0表示取消检查），单位：pulse
            ("yProp", c_float),  # Y方向当量/X方向当量的系数
            ("reserved2", c_float)  # 保留字段
        ]

        def __init__(self):
            super().__init__()
            self.axMask = 0
            self.mode = 0
            self.centPosX = 0
            self.centPosY = 0
            self.radius = 0
            self.yProp = 0.0
            self.reserved2 = 0.0
    """
    // 设置圆形限位区域 
    // pPara:参数
    // chn:通道号，可以设置多组
    """
    def OEM_SetCircleLimit(devHandle, Para, chn):
        libc.OEM_SetCircleLimit.argtypes = [c_ushort,  POINTER(pymtn.TCircleLimitPara),  c_short]
        ret = libc.OEM_SetCircleLimit(devHandle,  byref(Para),  chn)
        return ret

    def OEM_GetCircleLimit(devHandle, Para, chn):
        libc.OEM_GetCircleLimit.argtypes = [c_ushort,  POINTER(pymtn.TCircleLimitPara),  c_short]
        ret = libc.OEM_GetCircleLimit(devHandle,  byref(Para),  chn)
        return Para, ret

    """------------------------------------------------------------------------------------------------------------
    //
    //    Scan
    //
    //------------------------------------------------------------------------------------------------------------
    """
    # 振镜通道数量
    EM_SCAN_MAX_CHN        = 1
    """
    // 振镜控制功能开启关闭
    // 控制器默认振镜功能是关闭的。NMC_DevReset不会改变振镜的开关状态
    """
    def OEM_ScanEn(devHandle, onOff, chn):
        libc.OEM_ScanEn.argtypes = [c_ushort,  c_short,  c_short]
        return libc.OEM_ScanEn(devHandle,  onOff,  chn)

    """ 
    // 振镜控制数据清除
    """
    def OEM_ScanBufClr(devHandle, chn):
        libc.OEM_ScanBufClr.argtypes = [c_ushort,  c_short]
        return libc.OEM_ScanBufClr(devHandle,  chn)

    """ 
    // 振镜控制的启动及停止，0：停止，1:启动
    """
    def OEM_ScanOnOff(devHandle, onOff, chn):
        libc.OEM_ScanOnOff.argtypes = [c_ushort,  c_short,  c_short]
        return libc.OEM_ScanOnOff(devHandle,  onOff,  chn)

    """ 
    // 所有数据压完
    """
    def OEM_ScanEndList(devHandle, chn):
        libc.OEM_ScanEndList.argtypes = [c_ushort,  c_short]
        return libc.OEM_ScanEndList(devHandle,  chn)

    """ 
    // 振镜控制指令，运动指令,绝对运动
    // pXPosArray:x方向的位置数据
    // pYPosArray:y方向的位置数据
    // cnt:数组包含的数据个数
    """
    def OEM_ScanBufMoveAbs(devHandle, XPosArray, YPosArray, cnt, chn):
        XPosArray_tmp = (c_short * cnt)(*XPosArray)
        YPosArray_tmp = (c_short * cnt)(*YPosArray)
        libc.OEM_ScanBufMoveAbs.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_short),  c_short,  c_short]
        ret = libc.OEM_ScanBufMoveAbs(devHandle,  XPosArray_tmp,  YPosArray_tmp,  cnt,  chn)
        return ret

    """ 
    // 振镜控制指令，运动指令,相对运动
    // pXPosArray:x方向的位置数据
    // pYPosArray:y方向的位置数据
    // cnt:数组包含的数据个数
    """
    def OEM_ScanBufMoveRel(devHandle, XPosArray, YPosArray, cnt, chn):
        XPosArray_tmp = (c_short * cnt)(*XPosArray)
        YPosArray_tmp = (c_short * cnt)(*YPosArray)
        libc.OEM_ScanBufMoveRel.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_short),  c_short,  c_short]
        ret = libc.OEM_ScanBufMoveRel(devHandle,  XPosArray_tmp,  YPosArray_tmp,  cnt,  chn)
        return ret

    """ 
    // 振镜控制指令，运动指令,绝对运动
    // pXPosArray:x方向的位置数据
    // pYPosArray:y方向的位置数据
    // pZPosArray:z方向的位置数据
    // cnt:数组包含的数据个数
    """
    def OEM_ScanBufMoveAbsEx(devHandle, XPosArray, YPosArray, ZPosArray, cnt, chn):
        XPosArray_tmp = (c_short * cnt)(*XPosArray)
        YPosArray_tmp = (c_short * cnt)(*YPosArray)
        ZPosArray_tmp = (c_short * cnt)(*ZPosArray)
        libc.OEM_ScanBufMoveAbsEx.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_short),  POINTER(c_short),  c_short,  c_short]
        ret = libc.OEM_ScanBufMoveAbsEx(devHandle,  XPosArray_tmp,  YPosArray_tmp,  ZPosArray_tmp,  cnt,  chn)
        return ret

    """ 
    // 振镜控制指令，运动指令,相对运动
    // pXPosArray:x方向的位置数据
    // pYPosArray:y方向的位置数据
    // pZPosArray:z方向的位置数据
    // cnt:数组包含的数据个数
    """
    def OEM_ScanBufMoveRelEx(devHandle, XPosArray, YPosArray, ZPosArray, cnt, chn):
        XPosArray_tmp = (c_short * cnt)(* XPosArray)
        YPosArray_tmp = (c_short * cnt)(*YPosArray)
        ZPosArray_tmp = (c_short * cnt)(*ZPosArray)
        libc.OEM_ScanBufMoveRelEx.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_short),  POINTER(c_short),  c_short,  c_short]
        ret = libc.OEM_ScanBufMoveRelEx(devHandle,  XPosArray_tmp,  YPosArray_tmp,  ZPosArray_tmp,  cnt,  chn)
        return ret

    """ 
    // 振镜控制指令，设置位置模式
    // posMode:位置模式，0：绝对，默认，1：相对
    """
    def OEM_ScanBufSetPosMode(devHandle, posMode, chn):
        libc.OEM_ScanBufSetPosMode.argtypes = [c_ushort,  c_short,  c_short]
        return libc.OEM_ScanBufSetPosMode(devHandle,  posMode,  chn)

    """ 
    // 振镜控制指令，更新段号
    // segNo:段号
    """
    def OEM_ScanBufSetSegNo(devHandle, segNo, chn):
        libc.OEM_ScanBufSetSegNo.argtypes = [c_ushort,  c_int32,  c_short]
        return libc.OEM_ScanBufSetSegNo(devHandle,  segNo,  chn)

    """ 
    // 振镜控制指令，延时指令
    // delayUs:延时时间，单位us
    """
    def OEM_ScanBufDelay(devHandle, delayUs, chn):
        libc.OEM_ScanBufDelay.argtypes = [c_ushort,  c_int32,  c_short]
        return libc.OEM_ScanBufDelay(devHandle,  delayUs,  chn)

    """ 
    // 振镜控制指令，激光开关指令
    // laserOnOff:开关
    """
    def OEM_ScanBufLaserOnOff(devHandle, laserOnOff, chn):
        libc.OEM_ScanBufLaserOnOff.argtypes = [c_ushort,  c_short,  c_short]
        return libc.OEM_ScanBufLaserOnOff(devHandle,  laserOnOff,  chn)

    """ 
    // 振镜控制指令，激光开关光延时
    // onDelay:开光延时，单位us,取值范围[0,65535]
    // offDelay:关光延时，单位us,取值范围[0,65535]
    """
    def OEM_ScanBufLaserSetOnOffDelay(devHandle, onDelay, offDelay, chn):
        libc.OEM_ScanBufLaserSetOnOffDelay.argtypes = [c_ushort,  c_double,  c_double,  c_short]
        return libc.OEM_ScanBufLaserSetOnOffDelay(devHandle,  onDelay,  offDelay,  chn)

    """ 
    // 振镜控制指令，激光能量PWM设置
    // pulseWid:PWM宽度，单位us,取值范围[0.25,16000]
    // onTime:on时间，单位us,,取值范围[0.25,16000]
    """
    def OEM_ScanBufLaserSetPowerPwm(devHandle, pulseWid, onTime, chn):
        libc.OEM_ScanBufLaserSetPowerPwm.argtypes = [c_ushort,  c_double,  c_double,  c_short]
        ret = libc.OEM_ScanBufLaserSetPowerPwm(devHandle,  pulseWid,  onTime,  chn)
        return ret

    """ 
    // 振镜控制指令，激光能量DAC设置
    // dac:电压输出值
    """
    def OEM_ScanBufLaserSetPowerDac(devHandle, dac, chn):
        libc.OEM_ScanBufLaserSetPowerDac.argtypes = [c_ushort,  c_short,  c_short]
        return libc.OEM_ScanBufLaserSetPowerDac(devHandle,  dac,  chn)

    """ 
    // 振镜控制指令，激光能量DOut设置
    // doOutPower:输出能量，取值范围[0,255]
    // outCtrl:输出控制，0表示影响enable信号，1表示则表示不影响
    """
    def OEM_ScanBufSetPowerDOut(devHandle, dOutPower, outCtrl, chn):
        libc.OEM_ScanBufSetPowerDOut.argtypes = [c_ushort,  c_ushort,  c_short,  c_short]
        return libc.OEM_ScanBufSetPowerDOut(devHandle,  dOutPower,  outCtrl,  chn)

    """ 
    // 配置PWM的频率基频模式
    // mode:基频模式，0:4MHz基频固定，1:基频自动切换,有效频率范围[1,6M]
    // chn:保留
    MTN_API Int16 __stdcall OEM_ScanSetPWMBaseMode(HAND devHandle,Int16 mode,Int16 chn);
    """
    def OEM_ScanSetPWMBaseMode(devHandle, mode, chn):
        libc.OEM_ScanSetPWMBaseMode.argtypes = [c_ushort,  c_short,  c_short]
        return libc.OEM_ScanSetPWMBaseMode(devHandle,  mode,  chn)

    """ 
    // 配置PWM的自由运行模式，该模式下，PWM不受LaserOnOff指令的控制
    // onOff:开关，0:关闭自由运行模式，1:开启
    // pwmChn:PWM通道号，保留
    MTN_API Int16 __stdcall OEM_ScanSetPWMFreeRunMode(HAND devHandle,Int16 onOff,Int16 pwmChn);
    """
    def OEM_ScanSetPWMFreeRunMode(devHandle, onOff, pwmChn):
        libc.OEM_ScanSetPWMFreeRunMode.argtypes = [c_ushort,  c_short,  c_short]
        return libc.OEM_ScanSetPWMFreeRunMode(devHandle,  onOff,  pwmChn)


    # 状态位常量定义 (与C的 #define 对应)
    BIT_SCAN_EN = 0x00000001  # 使能标志位
    BIT_SCAN_RUN = 0x00000002  # 运动:1 ,静止 0
    BIT_SCAN_END = 0x00000004  # 是否End标志位
    BIT_SCAN_BUF_FULL = 0x00000008  # 数据满
    BIT_SCAN_BUF_EMPTY = 0x00000010  # 数据空
    BIT_SCAN_ERR_PUSH = 0x00001000  # 压数据错误
    BIT_SCAN_ERR_POP = 0x00002000  # 取数据错误
    BIT_SCAN_ERR_OTHER = 0x00004000  # 他错误，参考errCode


    class TOemScanSts(Structure):
        _fields_ = [
            ("sts", c_int32),  # 运行状态，按位表示
            ("userSeg", c_int32),  # 用户段号
            ("leftSpace", c_int32),  # 剩余空间
            ("usedSpace", c_int32),  # 使用空间
            ("cmdAllCnt", c_uint32),  # 全部指令的计数
            ("xPos", c_int16),  # x方向当前位置
            ("yPos", c_int16),  # y方向当前位置
            ("errCode", c_int16),  # 错误码
            ("reserved", c_int16 * 3)  # 保留字段
        ]

    def __init__(self):
        super().__init__()
        self.sts = 0
        self.userSeg = 0
        self.leftSpace = 0
        self.usedSpace = 0
        self.cmdAllCnt = 0
        self.xPos = 0
        self.yPos = 0
        self.errCode = 0
        self.reserved = (c_int16 * 3)(0, 0, 0)
    """
    // 获取振镜的运行状态
    """
    def OEM_ScanGetSts(devHandle,Sts, chn):
        libc.OEM_ScanGetSts.argtypes = [c_ushort,  POINTER(pymtn.TOemScanSts),  c_short]
        ret = libc.OEM_ScanGetSts(devHandle,  byref(Sts),  chn)
        return Sts, ret

    """ 
    // 获取振镜缓冲区剩余空间
    // pSts:状态 pLeftSpace:剩余空间
    """
    def OEM_ScanGetStsEx(devHandle,  chn):
        Sts_tmp = c_int32()
        LeftSpace_tmp = c_int32()
        libc.OEM_ScanGetStsEx.argtypes = [c_ushort,  POINTER(c_int32),  POINTER(c_int32),  c_short]
        ret = libc.OEM_ScanGetStsEx(devHandle,  byref(Sts_tmp),  byref(LeftSpace_tmp),  chn)
        return (Sts_tmp, LeftSpace_tmp, ret)

    """ 
    // 手动：运动到指定点
    """
    def OEM_ScanMoveAbs(devHandle, x, y, chn):
        libc.OEM_ScanMoveAbs.argtypes = [c_ushort,  c_short,  c_short,  c_short]
        return libc.OEM_ScanMoveAbs(devHandle,  x,  y,  chn)

    """ 
    // 手动：运动到指定点,带Z轴
    """
    def OEM_ScanMoveAbsEx(devHandle, x, y, z, chn):
        libc.OEM_ScanMoveAbsEx.argtypes = [c_ushort,  c_short,  c_short,  c_short,  c_short]
        return libc.OEM_ScanMoveAbsEx(devHandle,  x,  y,  z,  chn)

    """ 
    // 手动：开光
    """
    def OEM_ScanLaserOnOff(devHandle, onOff, chn):
        libc.OEM_ScanLaserOnOff.argtypes = [c_ushort,  c_short,  c_short]
        return libc.OEM_ScanLaserOnOff(devHandle,  onOff,  chn)

    """ 
    // 手动：输出PWM
    // pulseWid:PWM宽度，单位us,取值范围[0.5,16000]
    // onTime:on时间，单位us
    """
    def OEM_ScanLaserPowerPwm(devHandle, pulseWid, onTime, chn):
        libc.OEM_ScanLaserPowerPwm.argtypes = [c_ushort,  c_double,  c_double,  c_short]
        ret = libc.OEM_ScanLaserPowerPwm(devHandle,  pulseWid,  onTime,  chn)
        return ret

    """ 
    // 手动：输出DAC
    """
    def OEM_ScanLaserPowerDac(devHandle, dac, chn):
        libc.OEM_ScanLaserPowerDac.argtypes = [c_ushort,  c_short,  c_short]
        return libc.OEM_ScanLaserPowerDac(devHandle,  dac,  chn)

    """ 
    // 手动：输出能量DO
    // doOutPower:输出能量，取值范围[0,255]
    // outCtrl:输出控制，0表示影响enable信号，1表示则表示不影响
    """
    def OEM_ScanLaserPowerDOut(devHandle, doOutPower, outCtrl, chn):
        libc.OEM_ScanLaserPowerDOut.argtypes = [c_ushort,  c_short,  c_short,  c_short]
        return libc.OEM_ScanLaserPowerDOut(devHandle,  doOutPower,  outCtrl,  chn)

    """ 
    // 振镜控制指令：按位来输出
    // gpoIdx:gpo的序号，取值范围[0,31]
    // outSns:输出电平 0;低电平 1:高电平
    """
    def OEM_ScanBufSetDOBit(devHandle, gpoIdx, outSns, chn):
        libc.OEM_ScanBufSetDOBit.argtypes = [c_ushort,  c_short,  c_short,  c_short]
        return libc.OEM_ScanBufSetDOBit(devHandle,  gpoIdx,  outSns,  chn)

    """ 
    // 振镜控制指令：同时操作所有GPO
    // gpoValue:gpo输出值
    """
    def OEM_ScanBufSetDO(devHandle, gpoValue, chn):
        libc.OEM_ScanBufSetDO.argtypes = [c_ushort,  c_int32,  c_short]
        return libc.OEM_ScanBufSetDO(devHandle,  gpoValue,  chn)

    """ 
    // 振镜控制指令：缓存区等待DI
    // diType:保留，请输入DI_TYPE_GPI
    // diGroup:保留，请输入0
    // diIdxMask:输入序号的掩码
    // diValueMask:等待的电平
    // timeOutMs:超时时间，单位:ms,输入0表示无限等待
    """
    def OEM_ScanBufWaitDI(devHandle, diType, diGroup, diIdxMask, diValueMask, timeOutMs, chn):
        libc.OEM_ScanBufWaitDI.argtypes = [c_ushort,  c_short,  c_short,  c_short,  c_short,  c_ushort,  c_short]
        ret = libc.OEM_ScanBufWaitDI(devHandle,  diType,  diGroup,  diIdxMask,  diValueMask,  timeOutMs,  chn)
        return ret

    """ 
    // 振镜缓冲区指令:跳转
    // x,y:目标位置
    // vel:调整速度
    """
    def OEM_ScanBufJump(devHandle, x, y, vel, chn):
        libc.OEM_ScanBufJump.argtypes = [c_ushort,  c_short,  c_short,  c_short,  c_short]
        return libc.OEM_ScanBufJump(devHandle,  x,  y,  vel,  chn)

    """ 振镜立即指令:跳转
    // x,y:目标位置
    // vel:调整速度
    """
    def OEM_ScanJump(devHandle, x, y, vel, chn):
        libc.OEM_ScanJump.argtypes = [c_ushort,  c_short,  c_short,  c_short,  c_short]
        return libc.OEM_ScanJump(devHandle,  x,  y,  vel,  chn)

    """------------------------------------------------------------------------------------------------------------
    //
    //         事件
    //
    //------------------------------------------------------------------------------------------------------------
    """
    EVENT_MAX_CHN = 8

    # 事件源类型
    EVENT_SRC_PRFPOS = 0  # 规划位置
    EVENT_SRC_ENCPOS = 1  # 实际位置
    EVENT_SRC_ADC = 2  # ADC

    # 事件方向
    EVENT_DIR_BIGGER = 0  # 大于
    EVENT_DIR_SMALLER = 1  # 小于
    EVENT_DIR_EQUAL = 2  # 等于
    EVENT_DIR_NOT_BIGGER = 3  # 不大于
    EVENT_DIR_NOT_SMALLER = 4  # 不小于
    EVENT_DIR_NOT_EQUAL = 5  # 不等于
    EVENT_DIR_POS_PASS = 6  # 正向穿越
    EVENT_DIR_NEG_PASS = 7  # 负向穿越

    # 动作类型
    EVENT_ACTION_NONE = 0        # 不执行任何的动作
    EVENT_ACTION_SETDO = 1       # 设置DO（idx:组号，param1:输出位掩码，param2:输出值掩码
    EVENT_ACTION_PTP_VEL = 2     # 更新PTP的速度（idx:轴号，param1:速度，param2:保留
    EVENT_ACTION_PTP_START = 3   # 启动PTP的运动（idx:轴掩码，param1:保留，param2:保留
    EVENT_ACTION_PTP_STARTEX = 4 # 启动PTP的运动（idx:轴掩码，param1:目标位置，param2:保留
    EVENT_ACTION_CRDSTOP = 5     # 停止Crd运动（idx:坐标系掩码，param1:0缓停1急停，param2:保留
    EVENT_ACTION_AXSTOP = 6      # 停止轴运动（idx:轴掩码，param1:0缓停1急停，param2:保留

    class TEventConfig(Structure):
        _fields_ = [
            ("eventSrc", c_int16),  # 事件的源，如EVENT_SRC_PRFPOS
            ("eventIdx", c_int16),  # 事件的序号，比如当源为规划位置时，这里指哪个轴
            ("dir", c_int16),  # 方向,如EVENT_DIR_BIGGER等
            ("errZone", c_int16),  # 误差带
            ("trigCnt", c_int32),  # 触发次数，最多触发的次数，设为0，表示一直会触发
            ("eventReserved", c_int32 * 3),  # 保留字段
            ("compVal1", c_double),  # 比较值

            ("actionType", c_int16),  # 动作类型
            ("actionIdx", c_int16),  # 动作序号
            ("actionParam1", c_float),  # 动作参数1
            ("actionParam2", c_float),  # 动作参数2
            ("actionReserved", c_int16 * 6)  # 保留字段
        ]

        def __init__(self):
            super().__init__()
            # 零值初始化
            self.eventSrc = 0
            self.eventIdx = 0
            self.dir = 0
            self.errZone = 0
            self.trigCnt = 0
            self.eventReserved[:] = (c_int32 * 3)(0, 0, 0)
            self.compVal1 = 0.0

            self.actionType = 0
            self.actionIdx = 0
            self.actionParam1 = 0.0
            self.actionParam2 = 0.0
            self.actionReserved[:] = (c_int16 * 6)(0, 0, 0, 0, 0, 0)
    """
    // 事件配置
    // pEventCfg:配置参数，参见结构体定义
    // chn:通道号，取值范围[0,EVENT_MAX_CHN)
    """
    def OEM_DevEventSetConfig(devHandle, EventCfg, chn):
        libc.OEM_DevEventSetConfig.argtypes = [c_ushort,  POINTER(pymtn.TEventConfig),  c_short]
        ret = libc.OEM_DevEventSetConfig(devHandle,  byref(EventCfg),  chn)
        return ret

    """ 
    // 获取事件配置
    // pEventCfg:配置参数，参见结构体定义
    // chn:通道号，取值范围[0,EVENT_MAX_CHN)
    """
    def OEM_DevEventGetConfig(devHandle,EventCfg, chn):
        libc.OEM_DevEventGetConfig.argtypes = [c_ushort,  POINTER(pymtn.TEventConfig),  c_short]
        ret = libc.OEM_DevEventGetConfig(devHandle,  byref(EventCfg),  chn)
        return EventCfg, ret

    """ 
    // 设置事件开关
    // onOff:开关，0:关 1:开
    // chn:通道号，取值范围[0,EVENT_MAX_CHN)
    """
    def OEM_DevEventSetOnOff(devHandle, onOff, chn):
        libc.OEM_DevEventSetOnOff.argtypes = [c_ushort,  c_short,  c_short]
        return libc.OEM_DevEventSetOnOff(devHandle,  onOff,  chn)

    """ 
    // 获取状态
    // pOnOff:开关状态，0:关 1:开
    // pTrigCnt:触发计数
    // chn:通道号，取值范围[0,EVENT_MAX_CHN)
    """
    def OEM_DevEventGetSts(devHandle, chn):
        TrigCnt_tmp = c_short()
        OnOff_tmp = c_short()
        libc.OEM_DevEventGetSts.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_short),  c_short]
        ret = libc.OEM_DevEventGetSts(devHandle,  byref(TrigCnt_tmp),  byref(OnOff_tmp),  chn)
        return TrigCnt_tmp, OnOff_tmp, ret

    """ 
    // 缓冲区配置事件及开关
    // pEventCfg:配置信息
    // onOff:是否立即开启关闭
    // chn:通道号，取值范围[0,EVENT_MAX_CHN)
    """
    def OEM_CrdBufEventSetConfig(crdHandle, segNo, EventCfg, onOff, chn):
        libc.OEM_CrdBufEventSetConfig.argtypes = [c_ushort,  c_int32,  POINTER(pymtn.TEventConfig),  c_short,  c_short]
        ret = libc.OEM_CrdBufEventSetConfig(crdHandle,  segNo,   byref(EventCfg),  onOff,  chn)
        return ret

    """ 
    // 缓冲区事件开关
    // onOff:是否立即开启关闭
    // chn:通道号，取值范围[0,EVENT_MAX_CHN)
    """
    def OEM_CrdBufEventSetOnOff(crdHandle, segNo, onOff, chn):
        libc.OEM_CrdBufEventSetOnOff.argtypes = [c_ushort,  c_int32,  c_short,  c_short]
        return libc.OEM_CrdBufEventSetOnOff(crdHandle,  segNo,  onOff,  chn)

    """ 
    // 缓冲区等待事件触发
    // trigCnt:触发的事件计数
    // timeOut:超时 单位:ms
    // chn:通道号，取值范围[0,EVENT_MAX_CHN)
    """
    def OEM_CrdBufEventWait(crdHandle, segNo, trigCnt, timeOut, chn):
        libc.OEM_CrdBufEventWait.argtypes = [c_ushort,  c_int32,  c_short,  c_int32,  c_short]
        return libc.OEM_CrdBufEventWait(crdHandle,  segNo,  trigCnt,  timeOut,  chn)

    """ 
    // 机构示教开始
    // startPos:起始位置，单位:脉冲
    // interval:间隔，单位:脉冲
    // sectCount:示教的段数
    // pFileNameToSaveTechData:示教数据的存储文件
    """
    def OEM_MtLeadScrewTechRun(axisHandle, startPos, interval, sectCount, FileNameToSaveTechData):
        FileNameToSaveTechData_tmp = create_string_buffer(FileNameToSaveTechData.encode('utf-8'))
        libc.OEM_MtLeadScrewTechRun.argtypes = [c_ushort,  c_int32,  c_int32,  c_int32,  c_char_p]
        ret = libc.OEM_MtLeadScrewTechRun(axisHandle,  startPos,  interval,  sectCount,  FileNameToSaveTechData_tmp)
        return ret

    """ 
    // 机构示教过程状态查询
    // pRun:运行状态，0：停止中，1：正在运行，其他：错误代码
    // pPercent:运行的进度百分比
    """
    def OEM_MtLeadScrewTechSts(axisHandle):
        Run_tmp = c_short()
        Percent_tmp = c_short()
        libc.OEM_MtLeadScrewTechSts.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_short)]
        ret = libc.OEM_MtLeadScrewTechSts(axisHandle,  byref(Run_tmp),  byref(Percent_tmp))
        return Run_tmp, Percent_tmp, ret

    """ 
    // 机构示教强制终止
    """
    def OEM_MtLeadScrewTechBreak(axisHandle):
        libc.OEM_MtLeadScrewTechBreak.argtypes = [c_ushort]
        return libc.OEM_MtLeadScrewTechBreak(axisHandle)

    """ 
    // 加载机构示教数据
    // pFileNameTechData:数据文件名
    """
    def OEM_MtLeadScrewTechLoad(axisHandle, FileNameTechData):
        FileNameTechData_tmp = create_string_buffer(FileNameTechData.encode('utf-8'))
        libc.OEM_MtLeadScrewTechLoad.argtypes = [c_ushort,  c_char_p]
        ret = libc.OEM_MtLeadScrewTechLoad(axisHandle,  FileNameTechData_tmp)
        return ret

    # 单轴编码器的配置
    class TEncoderCfg(Structure):
        _fields_ = [
            ("encoderIdx", c_int16),   # 编码器编号，[0,n]或256(辅助编码器)
            ("encoderMode", c_int16),  # 编码器模式，请参考NMC_SetEncMode说明
            ("reserved", c_int16 * 6)  # 保留字段
        ]

        def __init__(self):
            super().__init__()
            self.encoderIdx = 0
            self.encoderMode = 0
            self.reserved[:] = (c_int16 * 6)(0, 0, 0, 0, 0, 0)
    """
    //设置单轴编码器的配置
    """
    def OEM_MtSetEncCfg (axisHandle, Para):
        libc.OEM_MtSetEncCfg.argtypes = [c_ushort,  POINTER(pymtn.TEncoderCfg)]
        ret = libc.OEM_MtSetEncCfg(axisHandle,  byref(Para))
        return ret

    """
    // 获取单轴编码器的配置
    """
    def OEM_MtGetEncCfg (axisHandle, Para):
        libc.OEM_MtGetEncCfg.argtypes = [c_ushort,  POINTER(pymtn.TEncoderCfg)]
        ret = libc.OEM_MtGetEncCfg(axisHandle,  byref(Para))
        return Para, ret

    """ 
    // 两段速PTP运动
    // pPrfTime:对于规划位置触发，返回整个规划需要的时间
    """
    def OEM_MtMovePtpAbsTwoStageEx(axisHandle, Prm):
        PrfTime_tmp = c_double()
        libc.OEM_MtMovePtpAbsTwoStageEx.argtypes = [c_ushort,  POINTER(pymtn.TPtpTwoStagePrm),  POINTER(c_double)]
        ret = libc.OEM_MtMovePtpAbsTwoStageEx(axisHandle,  byref(Prm),  byref(PrfTime_tmp))
        return PrfTime_tmp, ret

    """ 
    // 功能：2维位置比较自动连续输出
    // onOff： 0 停止,1输出 注意：NMC_Comp2DimensOnoff关闭也可以实现关闭连续输出
    // group:组号,0 或者1
    // outInteval:输出间隔，单位us
    // outCnt:输出次数
    // chn:保留,设为0
    """
    def OEM_Comp2DimensOutPulse(devHandle, group, onOff, outInteval, outCnt, chn):
        libc.OEM_Comp2DimensOutPulse.argtypes = [c_ushort,  c_short,  c_short,  c_int32,  c_int32,  c_short]
        return libc.OEM_Comp2DimensOutPulse(devHandle,  group,  onOff,  outInteval,  outCnt,  chn)

    """ 
    // 功能：2维位置比较自动连续输出,缓冲区指令
    // onOff： 0 停止,1输出 注意：NMC_Comp2DimensOnoff关闭也可以实现关闭连续输出
    // group:组号,0 或者1
    // outInteval:输出间隔，单位us
    // outCnt:输出次数
    // chn:保留,设为0
    """
    def OEM_CrdBufComp2DimensOutPulse(crdHandle, segNo, group, onOff, outInteval, outCnt, chn):
        libc.OEM_CrdBufComp2DimensOutPulse.argtypes = [c_ushort,  c_int32,  c_short,  c_short,  c_int32,  c_int32,  c_short]
        return libc.OEM_CrdBufComp2DimensOutPulse(crdHandle,  segNo,  group,  onOff,  outInteval,  outCnt,  chn)

    # DO输出PWM功能
    class TDoOutPWMParam(Structure):
        _fields_ = [
            ("doType", c_int16),   # 输出通道类型 (参考DO_TYPE)
            ("doGroup", c_int16),  # 输出通道组号
            ("doIdx", c_int16),    # 输出通道序号
            ("reserved", c_int16), # 保留字段
            ("pwmPeriod", c_int32),# PWM周期(us)
            ("pwmWidth", c_int32), # PWM脉宽(us)
            ("reserved2", c_int32 * 2)  # 保留
        ]

        def __init__(self):
            super().__init__()
            self.doType = 4
            self.doGroup = 0
            self.doIdx = 0
            self.reserved = 0
            self.pwmPeriod = 2000
            self.pwmWidth = 1000
            self.reserved2[:] = (0, 0)
    """
    // DO输出PWM：设置参数
    // pParam:参数
    // group:组号，取值范围[0,n)
    """
    def NMC_DoOutPWMSetParam(devHandle, Param,  group):
        libc.NMC_DoOutPWMSetParam.argtypes = [c_ushort,  POINTER(pymtn.TDoOutPWMParam),  c_short]
        ret = libc.NMC_DoOutPWMSetParam(devHandle,  byref(Param),  group)
        return ret

    def NMC_DoOutPWMGetParam(devHandle, Param,  group):
        libc.NMC_DoOutPWMGetParam.argtypes = [c_ushort,  POINTER(pymtn.TDoOutPWMParam),  c_short]
        ret = libc.NMC_DoOutPWMGetParam(devHandle,  byref(Param),  group)
        return Param, ret

    """ 
    // DO输出PWM：开关输出
    // group:组号，取值范围[0,n)
    // outCnt：输出计数
    // onOff:是否开始输出,0:关闭输出  1:开始输出
    """
    def NMC_DoOutPWMOnOff(devHandle,  onOff,  outCnt, group):
        libc.NMC_DoOutPWMOnOff.argtypes = [c_ushort,  c_short,  c_int32,  c_short]
        return libc.NMC_DoOutPWMOnOff(devHandle,  onOff,  outCnt,  group)

    """ 
    // DO输出PWM：获取状态
    // group:组号，取值范围[0,n)
    // pOnOff:开关状态
    // pOutCnt:当前的输出计数
    """
    def NMC_DoOutPWMGetSts(devHandle, group):
        OnOff_tmp = c_short()
        OutCnt_tmp = c_int32()
        libc.NMC_DoOutPWMGetSts.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_int32),  c_short]
        ret = libc.NMC_DoOutPWMGetSts(devHandle,  byref(OnOff_tmp),  byref(OutCnt_tmp),  group)
        return OnOff_tmp, OutCnt_tmp, ret

    """ 
    // PT及PVT OEM
    // 查询PT数据剩余空间大小
    // pSpace:返回的剩余空间大小
    // pUsed: 已使用的空间段数
    // fifo:在数据贮存模式下，使用的FIFO编号，取值范围[0,1]
    """
    def OEM_MtPtGetSpaceEx( axisHandle, fifo):
        Space_tmp = c_short()
        Used_tmp = c_short()
        libc.OEM_MtPtGetSpaceEx.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_short),  c_short]
        ret = libc.OEM_MtPtGetSpaceEx(axisHandle,  byref(Space_tmp),  byref(Used_tmp),  fifo)
        return Space_tmp, Used_tmp, ret

    """ 
    // 向Pt运动缓存区中压运动数据段
    // count:压入的数据段数
    // pPosArray:段运行距离
    // pTimeArray:段运行时间
    // pTypeArray:段类型,见宏定义
    // fifo:在数据贮存模式下，使用的FIFO编号，取值范围[0,1]
    """
    def OEM_MtPtPushEx(axisHandle, count, PosArray, TimeArray, TypeArray, fifo):
        PosArray_tmp = (c_double * count)(*PosArray)
        TimeArray_tmp = (c_int32 * count)(*TimeArray)
        TypeArray_tmp = (c_short * count)(*TypeArray)
        libc.OEM_MtPtPushEx.argtypes = [c_ushort,  c_short,  POINTER(c_double),  POINTER(c_int32),  POINTER(c_short),  c_short]
        ret = libc.OEM_MtPtPushEx(axisHandle,  count,  PosArray_tmp,  TimeArray_tmp,  TypeArray_tmp,  fifo)
        return ret

    """ 
    // 清空PT数据
    // fifo:在数据贮存模式下，使用的FIFO编号，取值范围[0,1]
    """
    def OEM_MtPtBufClrEx(axisHandle, fifo):
        libc.OEM_MtPtBufClrEx.argtypes = [c_ushort,  c_short]
        return libc.OEM_MtPtBufClrEx(axisHandle,  fifo)

    """ 
    // 启动Pt运动
    // otherSynAxCnts： 不包括axisHandle 的其他同步启动轴数量
    // pOtherSynAxArray: 其他同步启动轴的序号：0~N    
    // fifo:在数据贮存模式下，使用的FIFO编号，取值范围[0,1]
    """
    def OEM_MtPtStartMtnEx(axisHandle, otherSynAxCnts, OtherSynAxArray, fifo):
        OtherSynAxArray_tmp = (c_short * otherSynAxCnts)(*OtherSynAxArray)
        libc.OEM_MtPtStartMtnEx.argtypes = [c_ushort,  c_short,  POINTER(c_short),  c_short]
        ret = libc.OEM_MtPtStartMtnEx(axisHandle,  otherSynAxCnts,  OtherSynAxArray_tmp,  fifo)
        return ret

    """ 
    // 向PVT运动缓存区中压运动数据段
    // count:压入的数据段数：1~32
    // pPosArray:段运行距离
    // pTimeArray:段运行时间
    // pVelArray:段运行速度
    // fifo:在数据贮存模式下，使用的FIFO编号，取值范围[0,1]
    """
    def OEM_MtPvtDataEx(axisHandle, count, PosArray, TimeArray, VelArray, fifo):
        PosArray_tmp =(c_double * count)(*PosArray)
        TimeArray_tmp = (c_double * count)(*TimeArray)
        VelArray_tmp = (c_double * count)(*VelArray)
        libc.OEM_MtPvtDataEx.argtypes = [c_ushort,  c_short,  POINTER(c_double),  POINTER(c_double),  POINTER(c_double),  c_short]
        ret = libc.OEM_MtPvtDataEx(axisHandle,  count,  PosArray_tmp,  TimeArray_tmp,  VelArray_tmp,  fifo)
        return ret

    """ 
    // 查询PVT数据剩余空间大小
    // pFreeSpace:返回的剩余空间大小
    // pUsedSpace: 已使用的空间段数
    // fifo:在数据贮存模式下，使用的FIFO编号，取值范围[0,1]
    """
    def OEM_MtPvtBufGetSpaceEx(axisHandle, fifo):
        FreeSpace_tmp = c_short()
        UsedSpace_tmp = c_short()
        libc.OEM_MtPvtBufGetSpaceEx.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_short),  c_short]
        ret = libc.OEM_MtPvtBufGetSpaceEx(axisHandle,  byref(FreeSpace_tmp),  byref(UsedSpace_tmp),  fifo)
        return FreeSpace_tmp, UsedSpace_tmp, ret

    """ 
    // 清空PVT数据
    // fifo:在数据贮存模式下，使用的FIFO编号，取值范围[0,1]
    """
    def OEM_MtPvtBufClrEx(axisHandle, fifo):
        libc.OEM_MtPvtBufClrEx.argtypes = [c_ushort,  c_short]
        return libc.OEM_MtPvtBufClrEx(axisHandle,  fifo)

    """ 
    // 启动Pvt运动
    // otherSynAxCnts： 不包括axisHandle 的其他同步启动轴数量
    // pOtherSynAxArray: 其他同步启动轴的序号：0~N    
    // fifo:在数据贮存模式下，使用的FIFO编号，取值范围[0,1]
    // 注：同步的轴必须属于同一个控制器
    """
    def OEM_MtPvtStartMtnEx(axisHandle, otherSynAxCnts, OtherSynAxArray, fifo):
        OtherSynAxArray_tmp = (c_short * otherSynAxCnts)(*OtherSynAxArray)
        libc.OEM_MtPvtStartMtnEx.argtypes = [c_ushort,  c_short,  POINTER(c_short),  c_short]
        ret = libc.OEM_MtPvtStartMtnEx(axisHandle,  otherSynAxCnts,  OtherSynAxArray_tmp,  fifo)
        return ret

    """ 
    // 获取编码器位置（补偿前）
    // pEncPosEx:补偿前的编码器位置
    """
    def OEM_MtGetEncPosEx(axisHandle):
        EncPosEx_tmp = c_int32()
        libc.OEM_MtGetEncPosEx.argtypes = [c_ushort,  POINTER(c_int32)]
        ret = libc.OEM_MtGetEncPosEx(axisHandle,  byref(EncPosEx_tmp))
        return EncPosEx_tmp, ret

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

    # Ptp运动单元
    class TPtpBufMvUnit(Structure):
        _fields_ = [
            ("acc", c_float),  # 加速度
            ("dec", c_float),  # 减速度
            ("velS", c_float),  # 起始速度
            ("velE", c_float),  # 结束速度
            ("velMax", c_float),  # 最大速度
            ("tgtPos", c_int32),  # 目标位置
            ("smooth", c_int16),  # 平滑系数
            ("setDelay", c_int16),  # 设置延迟
            ("reserved", c_int16 * 4)  # 保留字段
        ]

        def __init__(self):
            super().__init__()
            self.acc = 0.5
            self.dec = 0.5
            self.velS = 0.0
            self.velE = 0.0
            self.velMax = 1.0
            self.tgtPos = 0
            self.smooth = 0
            self.setDelay = 0
            self.reserved[:] = (0, 0, 0, 0)

    class TPtpBufMvSts(Structure):
        _fields_ = [
            ("run", c_int16),          # 0:停止 1:运行中 2:错误
            ("errCode", c_int16),      # 错误代码
            ("curUnitIdx", c_int16),   # 当前执行单元序号
            ("reserved", c_int16 * 3)  # 保留字段
        ]

        # class TPtpBufMvUnit(Structure):
        #     _fields_ = [
        #         ("acc", c_float),  # 加速度
        #         ("dec", c_float),  # 减速度
        #         ("velS", c_float),  # 起始速度
        #         ("velE", c_float),  # 结束速度
        #         ("velMax", c_float),  # 最大速度
        #         ("tgtPos", c_int32),  # 目标位置
        #         ("smooth", c_int16),  # 平滑系数
        #         ("setDelay", c_int16),  # 设置延迟
        #         ("twoStageNewVel", c_float),  # 二段速新速度（0表示禁用）
        #         ("twoStageChgPos", c_int32)  # 二段速切换位置（0表示禁用）
        #     ]
        #
        #     def __init__(self):
        #         super().__init__()
        #         self.acc = 0.5
        #         self.dec = 0.5
        #         self.velMax = 1.0
        #         self.tgtPos = 0
        #         self.smooth = 0
        #         self.setDelay = 0
        #         self.twoStageNewVel = 0.0  # 默认禁用二段速
        #         self.twoStageChgPos = 0  # 默认禁用二段速
    """
    // 压入Ptp多轴运动参数
    // axisCnt:参与的轴数量，取值范围[1,4]
    // pAxisList:参与的轴列表数组
    // unitCnt:运动的段数量，取值范围[1,4]
    // pMvUnitList:运动的段数组列表，数组长度为axisCnt*unitCnt
    // group:组号，取值范围[0,1]
    """
    def OEM_PtpBufMvPushData(devHandle, axisCnt, AxisList, unitCnt, MvUnitList, group):
        AxisList_tmp = (c_short * axisCnt)(*AxisList)
        libc.OEM_PtpBufMvPushData.argtypes = [c_ushort,  c_short,  POINTER(c_short),  c_short,  POINTER(pymtn.TPtpBufMvUnit),  c_short]
        ret = libc.OEM_PtpBufMvPushData(devHandle,  axisCnt,  AxisList_tmp,  unitCnt,  MvUnitList,  group)
        return ret

    """ 
    // 设置PtpBuf指定轴及工作单元的目标位置
    // axisIdx:参与的轴序号,取值:[0,axisCnt)
    // unitIdx:单元序号，取值:[0,n]
    // unitCnt:运动的段数量，取值范围[1,unitCnt)
    // tgtPos:新的目标位置
    // group:组号，取值范围[0,1]
    """
    def OEM_PtpBufSetDataTgtPos(devHandle, axisIdx, unitIdx, tgtPos, group):
        libc.OEM_PtpBufSetDataTgtPos.argtypes = [c_ushort,  c_short,  c_short,  c_int32,  c_short]
        return libc.OEM_PtpBufSetDataTgtPos(devHandle,  axisIdx,  unitIdx,  tgtPos,  group)

    """ 
    // 获取PtpBuf某个工作单元数据
    // pMvUnit:运动的段数据
    """
    def OEM_PtpBufGetDataUnit(devHandle, axisIdx, unitIdx, MvUnit, group):
        libc.OEM_PtpBufGetDataUnit.argtypes = [c_ushort,  c_short,  c_short,  POINTER(pymtn.TPtpBufMvUnit),  c_short]
        ret = libc.OEM_PtpBufGetDataUnit(devHandle,  axisIdx,  unitIdx,  byref(MvUnit),  group)
        return MvUnit, ret

    """ 
    // 启动Ptp多轴运动
    // group:组号，取值范围[0,1]
    """
    def OEM_PtpBufMvStart(devHandle, group):
        libc.OEM_PtpBufMvStart.argtypes = [c_ushort,  c_short]
        return libc.OEM_PtpBufMvStart(devHandle,  group)

    """ 
    // 启动Ptp多轴运动
    // group:组号，取值范围[0,1]
    // startDelay:启动前的延时
    """
    def OEM_PtpBufMvStartEx(devHandle, startDelay, group):
        libc.OEM_PtpBufMvStartEx.argtypes = [c_ushort,  c_short,  c_short]
        return libc.OEM_PtpBufMvStartEx(devHandle,  startDelay,  group)

    """ 
    // 停止Ptp多轴运动
    // group:组号，取值范围[0,1]
    """
    def OEM_PtpBufMvStop(devHandle, group):
        libc.OEM_PtpBufMvStop.argtypes = [c_ushort,  c_short]
        return libc.OEM_PtpBufMvStop(devHandle,  group)

    # 运行状态
    PTPBUFMV_STS_STOP		= 0		# 停止，未运行或者被停止
    PTPBUFMV_STS_RUN		= 1		# 运行
    PTPBUFMV_STS_DONE		= 2		# 运行完成
    PTPBUFMV_STS_ERR		= 3		# 错误，错误代码可查看
    """
    // 查询Ptp多轴运动状态
    // group:组号，取值范围[0,1]
    // pSts:状态
    """
    def OEM_PtpBufMvSts(devHandle,Sts, group):
        libc.OEM_PtpBufMvSts.argtypes = [c_ushort,  POINTER(pymtn.TPtpBufMvSts),  c_short]
        ret = libc.OEM_PtpBufMvSts(devHandle,  Sts,  group)
        return ret

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

        def __init__(self):
            super().__init__()
            self.axCnt = 0
            self.axList = (c_int16 * COMPXDIMENSEX_MAX_AX)(*([0] * COMPXDIMENSEX_MAX_AX))
            self.outType = 0
            self.outChnType = 0
            self.outChnIdx = 0
            self.posSrc = 0
            self.stLevel = 0
            self.gateTime = 0
            self.errZone = 0
            self.directOutZone = 0
            self.reserved = (c_int32 * 7)(*([0] * 7))

    """ 
    // 设置多维位置比较
    // pParam:参数  group:组号，取值[0,n]
    """
    def OEM_CompXDimensExSetParam(devHandle, Param, group):
        libc.OEM_CompXDimensExSetParam.argtypes = [c_ushort,  POINTER(pymtn.TCompXDimensExParam),  c_short]
        ret = libc.OEM_CompXDimensExSetParam(devHandle,  byref(Param),  group)
        return ret

    def OEM_CompXDimensExGetParam(devHandle, Param, group):
        libc.OEM_CompXDimensExGetParam.argtypes = [c_ushort,  POINTER(pymtn.TCompXDimensExParam),  c_short]
        ret = libc.OEM_CompXDimensExGetParam(devHandle,  byref(Param),  group)
        return  ret

    """ 
    // 功能：设置多维位置比较数据
    // pArrayPos:比较数据位置值
    // count:位置点数,count=0表示清除已经缓存的数据。一次性最多压入128组数据
    // group:组号,0 或者1
    """
    def OEM_CompXDimensExSetData(devHandle, ArrayPos, count, group):
        ArrayPos_tmp = (c_int32 * count)(*ArrayPos)
        libc.OEM_CompXDimensExSetData.argtypes = [c_ushort,  POINTER(c_int32),  c_short,  c_short]
        ret = libc.OEM_CompXDimensExSetData(devHandle,  ArrayPos_tmp,  count,  group)
        return ret

    """ 
    // 功能：清除多维位置比较数据
    """
    def OEM_CompXDimensExClrData(devHandle, group):
        libc.OEM_CompXDimensExClrData.argtypes = [c_ushort,  c_short]
        return libc.OEM_CompXDimensExClrData(devHandle,  group)

    """ 
    // 功能：多维位置比较使能
    // onOff： 0 停止,1输出  
    """
    def OEM_CompXDimensExOnoff(devHandle, onOff, group):
        libc.OEM_CompXDimensExOnoff.argtypes = [c_ushort,  c_short,  c_short]
        return libc.OEM_CompXDimensExOnoff(devHandle,  onOff,  group)

    """ 
    // 功能：多维位置比较手动输出
    """
    def OEM_CompXDimensExManual(devHandle, outCnt, group):
        libc.OEM_CompXDimensExManual.argtypes = [c_ushort,  c_short,  c_short]
        return libc.OEM_CompXDimensExManual(devHandle,  outCnt,  group)

    class TCompXDimensExSts(Structure):
        _fields_ = [
            ("sts", c_int16),  # 运行状态，0 空闲 1 忙
            ("reserved1", c_int16),  # 保留
            ("freeSpace", c_int32),  # 控制器剩余空间
            ("usedSpace", c_int32),  # 剩余位置比较点
            ("outCount", c_int32),  # 已经输出的个数
            ("reserved2", c_int32 * 4)  # 保留
        ]
    """ 
    // 功能：多维位置比较的输出状态
    // pStatus: 状态结构体
    // group:组号,0 或者1
    """
    def OEM_CompXDimensExGetSts(devHandle, Status, group):
        libc.OEM_CompXDimensExGetSts.argtypes = [c_ushort,  POINTER(pymtn.TCompXDimensExSts),  c_short]
        ret = libc.OEM_CompXDimensExGetSts(devHandle,  byref(Status),  group)
        return Status, ret

    """ 计算PVT各个数据点的时间
    // count:数据点个数
    // pPosArray:位置数组
    // pVelArray:速度数组
    // pPercentArray:数据点百分比数组，[0,100]
    // pVelMaxArray:最大速度数组
    // pAccArray:加速度数组
    // pDecArray:减速度数组
    // pTimeArray:返回的时间数组
    """
    def OEM_PvtContinuousCalc(count, PosArray, VelArray, PercentArray, VelMaxArray, AccArray,  ecArray, TimeArray):
        PosArray_tmp = (c_double * count)(*PosArray)
        VelArray_tmp = (c_double * count)(*VelArray)
        PercentArray_tmp = (c_double * count)(*PercentArray)
        VelMaxArray_tmp = (c_double * count)(*VelMaxArray)
        AccArray_tmp = (c_double * count)(*AccArray)
        DecArray_tmp = (c_double * count)(*ecArray)
        TimeArray_tmp = (c_double * count)()
        libc.OEM_PvtContinuousCalc.argtypes = [c_int32,  POINTER(c_double),  POINTER(c_double),  POINTER(c_double),  POINTER(c_double),  POINTER(c_double),  POINTER(c_double),  POINTER(c_double)]
        ret = libc.OEM_PvtContinuousCalc(count,  PosArray_tmp,  VelArray_tmp,  PercentArray_tmp,  VelMaxArray_tmp,  AccArray_tmp,  DecArray_tmp,  TimeArray_tmp)
        time_list = [TimeArray_tmp[i] for i in range(count)]
        return time_list, ret

    class TCrdStopExParam(Structure):
        _fields_ = [
            ("stopSrcType", c_int16),  # 检查的信号类型，0:激光开关，1:GPO
            ("stopSrcChn", c_int16),  # 检查的信号通道号，取值范围[0,n]
            ("stopOnSns", c_int16),  # 停止位置的开关状态,对于激光，0表示激光关闭；对于GPO，0表示低电平
            ("reserved", c_int16 * 5)  # 保留
        ]

        def __init__(self):
            super().__init__()
            self.stopSrcType = 0
            self.stopSrcChn = 0
            self.stopOnSns = 0
            self.reserved = (c_int16 * 5)(0, 0, 0, 0, 0)

    """ 
    // 坐标系停止，停止在特定位置
    // pParam:参数，参考结构体定义
    """
    def OEM_CrdStopMtnEx(crdHandle, Param):
        libc.OEM_CrdStopMtnEx.argtypes = [c_ushort,  POINTER(pymtn.TCrdStopExParam)]
        ret = libc.OEM_CrdStopMtnEx(crdHandle,  Param)
        return ret

    class TPtpMoveCmpPara(Structure):
        _fields_ = [
            ("acc", c_float),  # 运动参数:加速度
            ("dec", c_float),  # 运动参数:减加速度
            ("maxVel", c_float),  # 运动参数:最大速度
            ("sVel", c_float),  # 运动参数:起点速度
            ("eVel", c_float),  # 运动参数:终止速度
            ("smooth", c_int32),  # 运动参数:平滑系数
            ("tgtPos", c_int32),  # 运动参数:目标位置

            ("outMode", c_int16),  # 比较输出:输出模式:0:匀速段等间距输出 1:指定位置输出
            ("posSrc", c_int16),  # 比较输出:比较轴位置类型 ：0:规划  1：编码器
            ("cmpInterval", c_int16),  # 比较输出:输出模式outMode=0下的比较间隔，单位:脉冲
            ("outChnType", c_int16),  # 比较输出:输出信号的通道类型：0 GPO, 1 GATE通道
            ("outChnIdx", c_int16),  # 比较输出:输出信号的通道号，取值[0,n]
            ("reserved1", c_int16),  # 比较输出:保留1，默认值 0（不使用）
            ("gateTime", c_int32),  # 比较输出:脉冲方式脉冲时间,单位us
            ("reserved", c_int32 * 7)  # 比较输出:保留，默认值 0（不使用）
        ]

        def __init__(self):
            super().__init__()
            self.acc = 0.5
            self.dec = 0.5
            self.maxVel = 1.0
            self.sVel = 0.0
            self.eVel = 0.0
            self.smooth = 0
            self.tgtPos = 0
            self.outMode = 0
            self.posSrc = 0
            self.cmpInterval = 0
            self.outChnType = 0
            self.outChnIdx = 0
            self.reserved1 = 0
            self.gateTime = 0
            self.reserved = (c_int32 * 7)(0, 0, 0, 0, 0, 0, 0)

    """ 单轴运动位置比较输出
    // axisHandle:运动轴号
    // pParam:单轴运动位置比较输出参数
    // outMode1PosCnt:位置比较点数量，仅当outMode=1时有效
    // pPosArray:位置比较点的位置数组，仅当outMode=1时有效
    // pActlOutCnt:返回实际的输出计数
    // chn:位置比较通道号，取值范围[0,1]
    """
    def OEM_MtMovePtpCmpOut(axisHandle, Param, outMode1PosCnt, PosArray, chn):
        PosArray_tmp = (c_int32 * outMode1PosCnt)(*PosArray)
        ActlOutCnt_tmp = c_int32()
        libc.OEM_MtMovePtpCmpOut.argtypes = [c_ushort,  POINTER(pymtn.TPtpMoveCmpPara),  c_int32,  POINTER(c_int32),  POINTER(c_int32),  c_short]
        ret = libc.OEM_MtMovePtpCmpOut(axisHandle,  byref(Param),  outMode1PosCnt,  PosArray_tmp,  byref(ActlOutCnt_tmp),  chn)
        return ActlOutCnt_tmp, ret

    """ 
    // 单轴点位运动时间计算,仅计算规划时间，不启动任何运动
    // acc:加速度,dec：减速度,startVel:起跳速度,endVel:终止速度,smoothCoef:平滑系数
    // maxVel：最大速度
    // pos:相对运动位置,单位：脉冲
    // isAbsPos:0:表示pos为相对位置，1:表示pos为绝对位置
    // pPrfTimeMs:运动消耗的时间，单位:毫秒
    """
    def OEM_MtGetPtpRelTime(axisHandle, acc, dec, velS, velE, velMax, smoothCoef, pos, isAbsPos):
        PrfTimeMs_tmp = c_double()
        libc.OEM_MtGetPtpRelTime.argtypes = [c_ushort,  c_double,  c_double,  c_double,  c_double,  c_double,  c_short,  c_int32,  c_short,  POINTER(c_double)]
        ret = libc.OEM_MtGetPtpRelTime(axisHandle,  acc,  dec,  velS,  velE,  velMax,  smoothCoef,  pos,  isAbsPos,  PrfTimeMs_tmp)
        return ret

    """ 
    // 设置DO的上电默认输出值
    // doType:do类型，只支持GPO，设为DO_TYPE_GPDO
    // group:组号，只支持GPO0
    // doInitValue:do的上电默认输出值
    """
    def OEM_SetDOInitState(devHandle, doType, group, doInitValue):
        libc.OEM_SetDOInitState.argtypes = [c_ushort,  c_short,  c_short,  c_int32]
        ret = libc.OEM_SetDOInitState(devHandle,  doType,  group,  doInitValue)
        return ret

    """ 
    // 点位平滑
    // acc:加速度
    // dec:减加速度
    // velS,velE,velMax:起跳速度,终止速度,最大速度,单位:pulse/ms
    // tgtPos:目标位置
    // smoothPercentAcc:加速段的S曲线段在整个加速阶段的百分比,取值范围[0,100]
    // smoothPercentDec:减速段的S曲线段在整个减速阶段的百分比,取值范围[0,100]
    """
    def OEM_MtPtpSmoothPercent(axisHandle, acc, dec, velS, velE, velMax, tgtPos, smoothPercentAcc, smoothPercentDec):
        libc.OEM_MtPtpSmoothPercent.argtypes = [c_ushort,  c_float,  c_float,  c_float,  c_float,  c_float,  c_int32,  c_float,  c_float]
        return libc.OEM_MtPtpSmoothPercent(axisHandle,  acc,  dec,  velS,  velE,  velMax,  tgtPos,  smoothPercentAcc,  smoothPercentDec)

    class TCrdSPrfPara(Structure):
        _fields_ = [
            ("maxJerk", c_float),    # 最大加加速度
            ("ratio", c_float),      # S平滑段在整个加减速过程所占的比例,取值范围[0,1],0表示没有S段，1表示全部为S段（无匀加速段）
            ("minCrvLen", c_float),  # 启用平滑的最小的曲线长度，大于该设定值，则使用S曲线规划，单位:脉冲
            ("usePtpTimeFlag", c_int16),  # 是否保持规划时间，1：保持，则最大加速度可能会大于设定的合成加速度；0:不保持
            ("reserved2", c_int16),    # 保留
            ("reserved", c_float * 2)  # 保留
        ]

        def __init__(self):
            super().__init__()
            self.maxJerk = 0.3
            self.ratio = 0.3
            self.minCrvLen = 1000.0
            self.usePtpTimeFlag = 1
            self.reserved2 = 0
            self.reserved = (c_float * 2)(0.0, 0.0)

    """ 
    // 设置坐标系S曲线规划参数
    // onOff:是否打开功能，0:取消 1:打开
    """
    def OEM_CrdSetSPrfPara(crdHandle, Param, onOff):
        libc.OEM_CrdSetSPrfPara.argtypes = [c_ushort,  POINTER(pymtn.TCrdSPrfPara),  c_short]
        ret = libc.OEM_CrdSetSPrfPara(crdHandle,  byref(Param),  onOff)
        return ret

    def OEM_CrdGetSPrfPara(crdHandle, Param):
        onOff_tmp = c_short()
        libc.OEM_CrdGetSPrfPara.argtypes = [c_ushort,  POINTER(pymtn.TCrdSPrfPara),  POINTER(c_short)]
        ret = libc.OEM_CrdGetSPrfPara(crdHandle,  byref(Param),  byref(onOff_tmp))
        return Param, onOff_tmp, ret

    """ 
    // 获取当前的编码器位置，64位
    // encId:编码器序号，取值范围[0,n]
    // pEncPos:编码器位置，64位整形,单位:脉冲
    """
    def OEM_GetEncPos64(devHandle, encId):
        EncPos_tmp = c_longlong()
        libc.OEM_GetEncPos64.argtypes = [c_ushort,  c_short,  POINTER(c_longlong)]
        ret = libc.OEM_GetEncPos64(devHandle,  encId,  byref(EncPos_tmp))
        return EncPos_tmp, ret

    """ 
    // 读捕获位置，64位整数
    // pCaptPos : 捕获位置,单位:脉冲
    """
    def OEM_MtGetCaptPos64  (axisHandle):
        CaptPos_tmp = c_longlong()
        libc.OEM_MtGetCaptPos64.argtypes = [c_ushort,  POINTER(c_longlong)]
        ret = libc.OEM_MtGetCaptPos64(axisHandle,  byref(CaptPos_tmp))
        return CaptPos_tmp, ret

    """ 
    // 启动运动
    // acc,dec,startVel,endVel,maxVel,smoothCoef,tgtPos: 运动参数
    """
    def OEM_MtPtpSectionMoveAbs(axisHandle, acc, dec, startVel, endVel, maxVel, smoothCoef, tgtPos):
        libc.OEM_MtPtpSectionMoveAbs.argtypes = [c_ushort,  c_double,  c_double,  c_double,  c_double,  c_double,  c_short,  c_int32]
        return libc.OEM_MtPtpSectionMoveAbs(axisHandle,  acc,  dec,  startVel,  endVel,  maxVel,  smoothCoef,  tgtPos)

    """ 
    // 获取指定位置的螺距补偿数据
    // prfPos:计算的规划位置
    // pPosCompPos:正向补偿位置
    // pNegCompPos:负向补偿位置
    """
    def OEM_MtGetLeadScrewCompPos(axisHandle, prfPos):
        PosCompPos_tmp = c_int32()
        NegCompPos_tmp = c_int32()
        libc.OEM_MtGetLeadScrewCompPos.argtypes = [c_ushort,  c_int32,  POINTER(c_int32),  POINTER(c_int32)]
        ret = libc.OEM_MtGetLeadScrewCompPos(axisHandle,  prfPos,  byref(PosCompPos_tmp),  byref(NegCompPos_tmp))
        return (PosCompPos_tmp, NegCompPos_tmp, ret)

    """ 
    // 坐标系增加叠加补偿
    // pCompDistList:各轴的补偿值，单位pulse
    // axMask:补偿的轴掩码
    // syncAcc,syncDec:加速度及减速度2
    // syncVel:最大合成速度
    // eventChnToOff:执行成功后关闭事件通道号
    """
    def OEM_CrdMvCompensate(crdHandle, CompDistList, axMask, syncAcc, syncDec, syncVel, eventChnToOff):
        CompDistList_tmp = (c_int32 * len(CompDistList))(*CompDistList)
        libc.OEM_CrdMvCompensate.argtypes = [c_ushort,  POINTER(c_int32),  c_short,  c_float,  c_float,  c_float,  c_short]
        ret = libc.OEM_CrdMvCompensate(crdHandle,  CompDistList_tmp,  axMask,  syncAcc,  syncDec,  syncVel,  eventChnToOff)
        return ret

    """ 
    // 设置辅助轴的传动比系数
    // axIdx:轴号，取值范围[0,n]
    // axProp:轴的传动比系数，默认为1
    """
    def OEM_CrdSetBufMvAxProp(crdHandle, axIdx, axProp):
        libc.OEM_CrdSetBufMvAxProp.argtypes = [c_ushort,  c_short,  c_double]
        return libc.OEM_CrdSetBufMvAxProp(crdHandle,  axIdx,  axProp)

    """ 
    // 缓冲区单轴移动(带参数)
    // segNo:段号
    // axisMask:参与的轴
    // pTgPos：目标位置
    // vel:速度
    // acc:加速度
    // blockEn:是否为阻塞模式
    // synEn：是否为同步模式,如果synEn和blockEn同时为1,则同步优先
    """
    def OEM_CrdBufAxMoveExDb(crdHandle, segNo, axisMask, TgPos, vel, acc, blockEn , synEn):
        TgPos_tmp = (c_double * len(TgPos))(*TgPos)
        libc.OEM_CrdBufAxMoveExDb.argtypes = [c_ushort,  c_int32,  c_short,  POINTER(c_double),  c_double,  c_double,  c_short,  c_short]
        ret = libc.OEM_CrdBufAxMoveExDb(crdHandle,  segNo,  axisMask,  TgPos_tmp,  vel,  acc,  blockEn ,  synEn)
        return ret

    """ 
    // 功能:缓冲区设置位置
    // posType:位置类型,bit0:编码器  bit1:轴编码器  bit2:规划位置，要求停止状态
    // posIdx:位置序号，取值[0,n]
    // setValue:设定值
    // flag:标志位，保留
    """
    def OEM_CrdBufSetPos(crdHandle, segNo, posType, posIdx, setValue, flag):
        libc.OEM_CrdBufSetPos.argtypes = [c_ushort,  c_int32,  c_short,  c_short,  c_int32,  c_int32]
        ret = libc.OEM_CrdBufSetPos(crdHandle,  segNo,  posType,  posIdx,  setValue,  flag)
        return ret

    """ 
    // 功能:缓冲区保存变量到内部变量
    // varType:需要保存的变量类型，0:编码器位置
    // varIdx:需要保存的变量通道号
    // saveToVarIdx:保存到内部变量的编号,如VAR_INNNER_VAR1
    """
    def OEM_CrdBufSaveVar(crdHandle, segNo, varType, varIdx, saveToVarIdx):
        libc.OEM_CrdBufSaveVar.argtypes = [c_ushort,  c_int32,  c_short,  c_short,  c_short]
        ret = libc.OEM_CrdBufSaveVar(crdHandle,  segNo,  varType,  varIdx,  saveToVarIdx)
        return ret

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

    """ 
    // 功能：获取状态
    // pRunSts:工作状态 1正在工作 0没有工作
    // pErrCode:错误代码
    // pSetCnt:工作计数
    """
    def OEM_Comp2DimensGetAutoOnSts(devHandle, group):
        RunSts_tmp = c_short()
        ErrCode_tmp = c_short()
        SetCnt_tmp = c_int32()
        libc.OEM_Comp2DimensGetAutoOnSts.argtypes = [c_ushort,  c_short,  POINTER(c_short),  POINTER(c_short),  POINTER(c_int32)]
        ret = libc.OEM_Comp2DimensGetAutoOnSts(devHandle,  group,  byref(RunSts_tmp),  byref(ErrCode_tmp),  byref(SetCnt_tmp))
        return RunSts_tmp, ErrCode_tmp, SetCnt_tmp, ret


    class TSHIOAheadParam(Structure):
        _fields_ = [
            ("outputChn", c_int16),   # 比较输出的通道号，取值[0,n]
            ("outputType", c_int16),  # 输出方式0：脉冲1：电平
            ("chnType", c_int16),     # 通道类型：0 GPO, 1 GATE通道
            ("dir1No", c_int16),      # 方向1 的位置源轴号（0~11）
            ("dir2No", c_int16),      # 方向2 的位置源轴号（0~11）
            ("posSrc", c_int16),      # 轴位置类型 ：0规划1：编码器
            ("stLevel", c_int16),     # 电平模式下的起始电平（0或1）
            ("errZone", c_int16),     # 进入比较点容差半径范围（pulse）
            ("directOutZone", c_int16),  # 近距离直接触发范围
            ("vibrateRange", c_int16),   # 抖动滤波范围
            ("gateTime", c_int32),       # 脉冲方式脉冲时间,单位us
            ("minIntervalTime", c_int32),  # 最小触发时间间隔,单位us
            ("aheadTime", c_int32),    # 提前时间，单位us
            ("reserved", c_int32 * 8)  # 保留
        ]

        def __init__(self):
            super().__init__()
            self.outputChn = 0
            self.outputType = 0
            self.chnType = 0
            self.dir1No = 0
            self.dir2No = 0
            self.posSrc = 0
            self.stLevel = 0
            self.errZone = 0
            self.directOutZone = 0
            self.vibrateRange = 0
            self.gateTime = 0
            self.minIntervalTime = 0
            self.aheadTime = 0
            self.reserved = (c_int32 * 8)(*([0] * 8))
    """ 
    // 设置提前输出参数
    // aheadTime：提前输出信号的时间，单位us,小于等于0表示不启用
    // chn:位置比较通道
    """
    def OEM_CrdSHIOAheadSetParam(crdHandle,Param, chn):
        libc.OEM_CrdSHIOAheadSetParam.argtypes = [c_ushort,  POINTER(pymtn.TSHIOAheadParam),  c_short]
        ret = libc.OEM_CrdSHIOAheadSetParam(crdHandle,  Param,  chn)
        return ret

    """ 
    // 下载输出点位置
    // pPosX:X方向的位置
    // pPosY:Y方向的位置
    // dataCnt:下载的数据点长度，取值范围[0,128]
    """
    def OEM_CrdBufSHIOAheadSetData(crdHandle, segNo, PosX, PosY, dataCnt, chn):
        PosX_tmp = (c_int32 * dataCnt)(*PosX)
        PosY_tmp = (c_int32 * dataCnt)(*PosY)
        libc.OEM_CrdBufSHIOAheadSetData.argtypes = [c_ushort,  c_int32,  POINTER(c_int32),  POINTER(c_int32),  c_int32,  c_short]
        ret = libc.OEM_CrdBufSHIOAheadSetData(crdHandle,  segNo,  PosX_tmp,  PosY_tmp,  dataCnt,  chn)
        return ret

    """------------------------------------------------------------------------------------------------------------
    //    矩形区域限位
    //------------------------------------------------------------------------------------------------------------
    """
    # 矩形区域限位参数
    class TRectLimitPara(Structure):
        _fields_ = [
            ("axX", c_int16),  # X轴序号 [-1,n), -1表示不包含X轴
            ("axY", c_int16),  # Y轴序号 [-1,n), -1表示不包含Y轴
            ("diType", c_int16),  # DI输入类型 (参考DI_TYPE)
            ("diIdx", c_int16),  # DI序号 [0,n)
            ("diSns", c_int16),  # 触发电平 (0:低电平 1:高电平)
            ("reserved1", c_int16),  # 保留字段
            ("xMinPos", c_int32),  # X方向最小位置
            ("xMaxPos", c_int32),  # X方向最大位置
            ("yMinPos", c_int32),  # Y方向最小位置
            ("yMaxPos", c_int32),  # Y方向最大位置
            ("reserved", c_int32 * 3)  # 保留字段
        ]

        def __init__(self):
            super().__init__()
            self.axX = 0
            self.axY = 0
            self.diType = 0
            self.diIdx = 0
            self.diSns = 0
            self.reserved1 = 0
            self.xMinPos = 0
            self.xMaxPos = 0
            self.yMinPos = 0
            self.yMaxPos = 0
            self.reserved[:] = (0, 0, 0)
    # 支持的最大组数
    RECTLIMIT_MAX_GROUP = 2
    """
    // 设置矩形限位区域 
    // pPara:参数
    // chn:通道号，可以设置多组，取值范围[0,MAX)
    """
    def OEM_RectLimitSetPara(devHandle, Para, chn):
        libc.OEM_RectLimitSetPara.argtypes = [c_ushort,  POINTER(pymtn.TRectLimitPara),  c_short]
        ret = libc.OEM_RectLimitSetPara(devHandle,  byref(Para),  chn)
        return ret

    def OEM_RectLimitGetPara(devHandle,Para, chn):
        libc.OEM_RectLimitGetPara.argtypes = [c_ushort,  POINTER(pymtn.TRectLimitPara),  c_short]
        ret = libc.OEM_RectLimitGetPara(devHandle,  byref(Para),  chn)
        return Para, ret

    # 触发状态
    RECT_LMT_STS_WAIT    = 0           # 状态:等待di触发或者手动开启
    RECT_LMT_STS_CHECK   = 1           # 状态:进入检查状态
    RECT_LMT_STS_TRIG    = 2           # 状态:限位触发
    """
    // 获取矩形限位区域的状态
    // pOnOff:是否被激活 1-激活
    // pTrigSts:触发状态
    // chn:通道号，可以设置多组，取值范围[0,MAX)
    """
    def OEM_RectLimitGetSts(devHandle, chn):
        OnOff_tmp = c_short()
        TrigSts_tmp = c_short()
        libc.OEM_RectLimitGetSts.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_short),  c_short]
        ret = libc.OEM_RectLimitGetSts(devHandle,  byref(OnOff_tmp),  byref(TrigSts_tmp),  chn)
        return OnOff_tmp, TrigSts_tmp, ret

    """ 
    // 手动开启或关闭矩形限位区域
    // onOff:激活或关闭
    // 说明：只有手动开启的，才能被手动关闭
    """
    def OEM_RectLimitSetOnOff(devHandle, onOff, chn):
        libc.OEM_RectLimitSetOnOff.argtypes = [c_ushort,  c_short,  c_short]
        return libc.OEM_RectLimitSetOnOff(devHandle,  onOff,  chn)
    """
    // ------------------------------------------------------------------------------------------------------------
    // 2D平面修正补偿
    // ------------------------------------------------------------------------------------------------------------
    """

    class T2DCompExPara(Structure):
        _fields_ = [
            ("axSrcIdx", c_int16),     # 参考轴序号 [0,n)
            ("posSrc", c_int16),       # 参考位置类型 (0:规划 1:编码器)
            ("maxCompVel", c_int16),   # 每毫秒叠加的最大补偿值,单位pulse/ms,非正值自动设为32767
            ("compAxPosCnt", c_int16), # 补偿轴有效通道数量
            ("compAxPos", c_int32 * COMPEX2D_MAX_COMP_CHN_NUM),  # 补偿轴各通道的对应位置值
            ("startPos", c_int32),     # 补偿起始位置
            ("posInterval", c_int32),  # 补偿间隔，单位:pulse
            ("posNum", c_int32),       # 补偿区间数量，取值范围[2,1024],注意补偿点数比补偿区数间大1
            ("reserved", c_int16 * 4)  # 保留字段
        ]

        def __init__(self):
            super().__init__()
            self.axSrcIdx = 0
            self.posSrc = 0
            self.maxCompVel = 0
            self.compAxPosCnt = 0
            for i in range(COMPEX2D_MAX_COMP_CHN_NUM):
                self.compAxPos[i] = 0
            self.startPos = 0
            self.posInterval = 0
            self.posNum = 0
            for i in range(4):
                self.reserved[i] = 0
    """ 
    // 设置2D平面修正补偿参数
    """
    def OEM_Mt2DCompExSetPara(axisHandle, Para):
        libc.OEM_Mt2DCompExSetPara.argtypes = [c_ushort,  POINTER(pymtn.T2DCompExPara)]
        ret = libc.OEM_Mt2DCompExSetPara(axisHandle,  byref(Para))
        return ret

    def OEM_Mt2DCompExGetPara(axisHandle, Para):
        libc.OEM_Mt2DCompExGetPara.argtypes = [c_ushort,  POINTER(pymtn.T2DCompExPara)]
        ret = libc.OEM_Mt2DCompExGetPara(axisHandle,  byref(Para))
        return Para, ret

    """ 
    // 设置2D平面修正补偿 补偿数据
    // pData:补偿数据数组
    // startIdx:补偿数据的起始序号
    // dataCnt:设置的补偿数据的数量，取值范围[1,512]
    """
    def OEM_Mt2DCompExSetData(axisHandle, Data, startIdx, dataCnt, compChn):
        Data_tmp = (c_short * dataCnt)(*Data)
        libc.OEM_Mt2DCompExSetData.argtypes = [c_ushort,  POINTER(c_short),  c_short,  c_short,  c_short]
        ret = libc.OEM_Mt2DCompExSetData(axisHandle,  Data_tmp,  startIdx,  dataCnt,  compChn)
        return ret

    def OEM_Mt2DCompExGetData(axisHandle, startIdx, dataCnt, compChn):
        Data_tmp = (c_short * dataCnt)()
        libc.OEM_Mt2DCompExGetData.argtypes = [c_ushort,  POINTER(c_short),  c_short,  c_short,  c_short]
        ret = libc.OEM_Mt2DCompExGetData(axisHandle,  Data_tmp,  startIdx,  dataCnt,  compChn)
        data_list = [elem for elem in Data_tmp]
        return data_list, ret

    """ 
    // 设置2D平面修正补偿 开启或者关闭补偿
    """
    def OEM_Mt2DCompExSetOnOff(axisHandle, onOff):
        libc.OEM_Mt2DCompExSetOnOff.argtypes = [c_ushort,  c_short]
        return libc.OEM_Mt2DCompExSetOnOff(axisHandle,  onOff)

    """ 
    // 获取 2D平面修正补偿 状态
    // pCompPos:当前的补偿值
    """
    def OEM_Mt2DCompExGetSts(axisHandle):
        OnOff_tmp = c_short()
        CompPos_tmp = c_int32()
        libc.OEM_Mt2DCompExGetSts.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_int32)]
        ret = libc.OEM_Mt2DCompExGetSts(axisHandle,  byref(OnOff_tmp),  byref(CompPos_tmp))
        return OnOff_tmp, CompPos_tmp, ret

    """------------------------------------------------------------------------------------------------------------
    //    用户直接补偿
    //------------------------------------------------------------------------------------------------------------
    """
    """
    // 设置直接补偿，补偿值直接叠加到对应轴上
    // compValue:补偿值
    // maxCompVel:每毫秒叠加的最大补偿值,单位pulse/ms,非正值自动设为32767
    """
    def OEM_MtSetUserCompValue(axisHandle, compValue, maxCompVel):
        libc.OEM_MtSetUserCompValue.argtypes = [c_ushort,  c_short,  c_short]
        return libc.OEM_MtSetUserCompValue(axisHandle,  compValue,  maxCompVel)

    """
    // 设置直接补偿开关
    // onOff:开关直接补偿
    """
    def OEM_MtSetUserCompOnOff(axisHandle, onOff):
        libc.OEM_MtSetUserCompOnOff.argtypes = [c_ushort,  c_short]
        return libc.OEM_MtSetUserCompOnOff(axisHandle,  onOff)
    """ 
    // 获取直接补偿设定值及状态
    // pCompValue:补偿设定值
    // pMaxCompVel:设定的最大补偿速度
    // pOnOff:onOff状态
    // pCurCompValue:当前的补偿值
    """
    def OEM_MtGetUserCompSts(axisHandle):
        CompValue_tmp = c_short()
        MaxCompVel_tmp = c_short()
        OnOff_tmp = c_short()
        CurCompValue_tmp = c_short()
        libc.OEM_MtGetUserCompSts.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_short),  POINTER(c_short),  POINTER(c_short)]
        ret = libc.OEM_MtGetUserCompSts(axisHandle,  byref(CompValue_tmp),  byref(MaxCompVel_tmp),  byref(OnOff_tmp),  byref(CurCompValue_tmp))
        return CompValue_tmp, MaxCompVel_tmp, OnOff_tmp, CurCompValue_tmp, ret

    """ 
    // 缓冲区设置用户补偿
    // axIdx:轴号，取值范围[0,n)
    // onOff:0:关闭  1:开启 2:开启后自动消除
    """
    def OEM_CrdBufSetUserCompValue(crdHandle,  segNo, axIdx, compValue,  maxCompVel, onOff):
        libc.OEM_CrdBufSetUserCompValue.argtypes = [c_ushort,  c_int32,  c_short,  c_short,  c_short,  c_short]
        return libc.OEM_CrdBufSetUserCompValue(crdHandle,  segNo,  axIdx,  compValue,  maxCompVel,  onOff)

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

    # 停止类型
    AX_STOP_TYPE_SOOMTH  = 0      # 停止类型：缓慢停止
    AX_STOP_TYPE_ABRUPT  = 1      # 停止类型：急停，不会置起急停标志位
    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).通道之间同时作用，不同停止类型以数值大的为准
    """
    def NMC_MtSetStopDIEx(axisHandle,  diType, diGroup, diIndex, diSense, stopType, chn):
        libc.NMC_MtSetStopDIEx.argtypes = [c_ushort,  c_short,  c_short,  c_short,  c_short,  c_short,  c_short]
        ret = libc.NMC_MtSetStopDIEx(axisHandle,  diType,  diGroup,  diIndex,  diSense,  stopType,  chn)
        return ret

    def NMC_MtGetStopDIEx(axisHandle, chn):
        diType_tmp = c_short()
        diGroup_tmp = c_short()
        diIndex_tmp = c_short()
        diSense_tmp = c_short()
        stopType_tmp = c_short()
        libc.NMC_MtGetStopDIEx.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_short),  POINTER(c_short),  POINTER(c_short),  POINTER(c_short),  c_short]
        ret = libc.NMC_MtGetStopDIEx(axisHandle,  byref(diType_tmp),  byref(diGroup_tmp),  byref(diIndex_tmp),  byref(diSense_tmp),  byref(stopType_tmp),  chn)
        return (diType_tmp, diGroup_tmp, diIndex_tmp, diSense_tmp, stopType_tmp, ret)

    def NMC_MtGetStopDIExSts(axisHandle, chn):
        Active_tmp = c_short()
        trigCnt_tmp = c_short()
        libc.NMC_MtGetStopDIExSts.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_short), c_short]
        ret = libc.NMC_MtGetStopDIExSts(axisHandle,  byref(Active_tmp),  byref(trigCnt_tmp),  chn)
        return Active_tmp, trigCnt_tmp, ret

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

    def NMC_GetEncFilt(devHandle, encIdx):
        encFilt_tmp = c_short()
        filtMode_tmp = c_short()
        libc.NMC_GetEncFilt.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_short),  c_short]
        ret = libc.NMC_GetEncFilt(devHandle, byref(encFilt_tmp), byref(filtMode_tmp), encIdx)
        return (encFilt_tmp, filtMode_tmp, ret)

    """------------------------------------------------------------------------
    //                                                     
    //  分频                                              
    //------------------------------------------------------------------------
    """
    class TLinearCmpDivPara(Structure):
        _fields_ = [
            ("axMask", c_int16),        # 选比较的轴号,按bit选择:不能超过2个bit同时为1
            ("src", c_int16),           # 比较源 (0:规划位置 1:编码器位置)
            ("startAxMsk", c_int16),    # 启动位置轴掩码 (只支持一维)
            ("startPosErrZone", c_int16), # 启动位置误差带 (脉冲)
            ("endAxMsk", c_int16),      # 保留字段
            ("dirEn", c_int16),         # 比较方向使能 (0:双向 1:启用)
            ("dir", c_int16 * 2),       # 比较方向 (1:正向 2:负向)
            ("startPos", c_int32 * 2),  # 启动位置 (只支持一维)
            ("endPos", c_int32 * 2),    # 保留字段
            ("gateDistance", c_int32),  # 位置间隔
            ("gateTime", c_int32),      # 输出脉冲宽度 (us)
            ("reserved", c_float * 4)   # 保留字段
        ]

        # def __init__(self):
        #     super().__init__()
        #     self.axMask = 0
        #     self.src = 0
        #     self.startAxMsk = 0
        #     self.startPosErrZone = 0
        #     self.endAxMsk = 0
        #     self.dirEn = 0
        #     self.dir[:] = (0, 0)
        #     self.startPos[:] = (0, 0)
        #     self.endPos[:] = (0, 0)
        #     self.gateDistance = 0
        #     self.gateTime = 0
        #     self.reserved[:] = (0.0, 0.0, 0.0, 0.0)
    """
    // 功能：设置精确位置比较的参数，并清除线性位置比较位置数据
    // pLinearCmpPara:位置比较参数
    // ch：输出通道 目前只支持0
    """
    def OEM_LinearCompSetConfig(devHandle, LinearCmpPara, ch):
        libc.OEM_LinearCompSetConfig.argtypes = [c_ushort,  POINTER(pymtn.TLinearCmpDivPara),  c_short]
        ret = libc.OEM_LinearCompSetConfig(devHandle,  byref(LinearCmpPara),  ch)
        return ret

    """ 
    // 功能：精确位置比较使能
    // onOff： 0 停止,1输出
    // ch：输出通道 目前只支持0
    """
    def OEM_LinearCompOnOff(devHandle, onOff,  ch):
        libc.OEM_LinearCompOnOff.argtypes = [c_ushort,  c_short,  c_short]
        return libc.OEM_LinearCompOnOff(devHandle,  onOff,  ch)

    """ 
    // 功能：比较的输出状态
    // pStatus: 0 未启动比较 1 比较输出中
    // ch：输出通道 目前只支持0
    """
    def OEM_LinearCompStatus(devHandle, ch):
        Status_tmp = c_int32()
        OutCnt_tmp = c_int32()
        libc.OEM_LinearCompStatus.argtypes = [c_ushort,  POINTER(c_int32),  POINTER(c_int32),  c_short]
        ret = libc.OEM_LinearCompStatus(devHandle,  byref(Status_tmp),  byref(OutCnt_tmp),  ch)
        return Status_tmp, OutCnt_tmp, ret

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

    """ 
    // 高速版本的MoveAbs，需要特定固件支持
    """
    def OEM_MtMovePtpAbsEx(axisHandle, acc, dec, startVel, endVel, maxVel, smoothCoef, tgtPos):
        libc.OEM_MtMovePtpAbsEx.argtypes = [c_ushort,  c_double,  c_double,  c_double,  c_double,  c_double,  c_short,  c_int32]
        return libc.OEM_MtMovePtpAbsEx(axisHandle,  acc,  dec,  startVel,  endVel,  maxVel,  smoothCoef,  tgtPos)

    """ 
    // 获取驱动版本
    """
    def NMC_GetDriverVer(devHandle):
        VerMain_tmp = c_short()
        VerSlv_tmp = c_short()
        libc.NMC_GetDriverVer.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_short)]
        ret = libc.NMC_GetDriverVer(devHandle,  byref(VerMain_tmp),  byref(VerSlv_tmp))
        return VerMain_tmp, VerSlv_tmp, ret

    """ 
    // 坐标系缓冲运动重新启动
    """
    def OEM_CrdReStartMtn(crdHandle ):
        libc.OEM_CrdReStartMtn.argtypes = [c_ushort]
        return libc.OEM_CrdReStartMtn(crdHandle)

    class TOemPidCalcPara(Structure):
        _fields_ = [
            ("dacChn", c_int16),    # 模拟量输出的通道号,轴模拟量取值[0,n),扩展模拟量从256开始
            ("encChn", c_int16),    # 编码器通道的通道号,轴编码器通道取值[0,n),扩展模拟量从256开始
            ("ctrlMode", c_int16),  # 控制模式
            ("reseved0", c_int16),  # 保留字段

            # 前馈参数
            ("ratio", c_double),    # 传动比
            ("targetVe", c_double), # 目标速度
            ("k", c_double),        # 前馈刚度k
            ("c", c_double),        # 阻尼c

            # PID参数
            ("kp", c_double),  # 比例系数
            ("ki", c_double),  # 积分系数
            ("kd", c_double),  # 微分系数

            # ADRC参数
            ("b0", c_double),  # ADRC参数b0
            ("Wc", c_double),  # 控制器带宽
            ("Wo", c_double),  # 观测器带宽
            ("h", c_double),  # 采样周期
            ("u", c_double),  # 控制量
            ("u0", c_double),  # 初始控制量
            ("t", c_double),  # 时间参数

            # 状态变量
            ("Z1", c_double),  # 状态观测器变量1
            ("Z2", c_double),  # 状态观测器变量2
            ("Z3", c_double),  # 状态观测器变量3

            # TD参数
            ("fh", c_double),  # 滤波参数
            ("r", c_double),  # 快速因子
            ("v1", c_double),  # 跟踪信号1
            ("v2", c_double)  # 跟踪信号2
        ]

        def __init__(self):
            super().__init__()
            self.dacChn = 0
            self.encChn = 0
            self.ctrlMode = 0
            self.reseved0 = 0

            self.ratio = 0.0
            self.targetVe = 0.0
            self.k = 0.0
            self.c = 0.0

            self.kp = 0.0
            self.ki = 0.0
            self.kd = 0.0

            self.b0 = 0.0
            self.Wc = 0.0
            self.Wo = 0.0
            self.h = 0.0
            self.u = 0.0
            self.u0 = 0.0
            self.t = 0.0

            self.Z1 = 0.0
            self.Z2 = 0.0
            self.Z3 = 0.0

            self.fh = 0.0
            self.r = 0.0
            self.v1 = 0.0
            self.v2 = 0.0
    """ 
    // OEM PID计算：启动或关闭闭环控制
    // onOff:启动或者关闭闭环控制
    // tgtPos:目标位置，单位:mm
    // chn:控制通道号，取值范围[0,n)
    // pPidPara:参数
    """
    def OEM_PIDCalc(devHandle, tgtPos, PidPara, onOff , chn):
        libc.OEM_PIDCalc.argtypes = [c_ushort,  c_double, POINTER(pymtn.TOemPidCalcPara),  c_short,  c_short]
        ret = libc.OEM_PIDCalc(devHandle, tgtPos, byref(PidPara), onOff , chn)
        return ret

    class TOemPosMapToDac(Structure):
        _fields_ = [
            ("dacChn", c_int16),   # 模拟量输出的通道号,轴模拟量取值[0,n),扩展模拟量从256开始
            ("axIdx", c_int16),    # 轴号 [0,n)
            ("posType", c_int16),  # 位置类型 (0:规划 1:编码器)
            ("reseved0", c_int16), # 保留字段

            ("posMin", c_int32),   # 位置最小值
            ("posMax", c_int32),   # 位置最大值
            ("dacMaxVal", c_int32),# DAC输出最大值 [-32768,32767]
            ("dacMinVal", c_int32),# DAC输出最小值 [-32768,32767]
            ("reseved1", c_int32 * 4)  # 保留字段
        ]

        def __init__(self):
            super().__init__()
            self.dacChn = 0
            self.axIdx = 0
            self.posType = 0
            self.reseved0 = 0

            self.posMin = 0
            self.posMax = 0
            self.dacMaxVal = 0
            self.dacMinVal = 0
            self.reseved1[:] = (0, 0, 0, 0)
    """ 
    // OEM 轴位置关联模拟量输出：指定的轴位置范围对应指定范围的模拟量输出
    // pPara:参数 如上
    // onOff:是否开启关联，1：开启 0：关闭
    // chn:控制通道号，取值范围[0,n)
    """
    def OEM_AxisPosMapToDac(devHandle, Para, onOff , chn):
        libc.OEM_AxisPosMapToDac.argtypes = [c_ushort,  POINTER(pymtn.TOemPosMapToDac),  c_short,  c_short]
        ret = libc.OEM_AxisPosMapToDac(devHandle, byref(Para), onOff, chn)
        return ret

    def NMC_IntStsGetSts(devHandle):
        Sts_tmp = c_short()
        Clk_tmp = c_uint32()
        libc.NMC_IntStsGetSts.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_uint32)]
        ret = libc.NMC_IntStsGetSts(devHandle,  byref(Sts_tmp),  byref(Clk_tmp))
        return Sts_tmp, Clk_tmp, ret

    def NMC_IntStsSetCfg(devHandle, onOff, varCnt, VarTypeList, VarIdxList):
        VarTypeList_tmp =(c_short * varCnt)(*VarTypeList)
        VarIdxList_tmp = (c_short * varCnt)(*VarIdxList)
        libc.NMC_IntStsSetCfg.argtypes = [c_ushort,  c_short, c_short,  POINTER(c_short), POINTER(c_short)]
        ret = libc.NMC_IntStsSetCfg(devHandle,  onOff,  varCnt, VarTypeList_tmp ,  VarIdxList_tmp)
        return ret
    """ 
    // 旋转转换合成速度计算
    // dx，dy:阀与旋转中心的偏差,单位:pulse
    // pathRadius:刀尖轨迹的圆弧半径
    // followSide:跟随侧，0:外侧 1:内侧
    // pathVel:刀尖的工作速度，单位:pulse/ms
    // pSyncVel:计算返回的旋转中心的工作速度，单位:pulse/ms
    // pIsBlock:是否应该用阻塞的单轴指令（中心轨迹太短)
    """
    def OEM_RotateTransfCalcSyncVel(crdHandle, dx, dy, pathRadius, followSide, ptVel):
        SyncVel_tmp = c_double()
        IsBlock_tmp = c_short()
        libc.OEM_RotateTransfCalcSyncVel.argtypes = [c_ushort,  c_double,  c_double,  c_double,  c_short,  c_double,  POINTER(c_double),  POINTER(c_short)]
        ret = libc.OEM_RotateTransfCalcSyncVel(crdHandle,  dx,  dy,  pathRadius,  followSide,  ptVel,  byref(SyncVel_tmp),  byref(IsBlock_tmp))
        return SyncVel_tmp, IsBlock_tmp, ret
    """
    // ------------------------------------------------------------------------------------------------------------
    // 变量锁存功能
    // ------------------------------------------------------------------------------------------------------------
    """
    class TVarCaptPara(Structure):
        _fields_ = [
            ("eventType", c_int16),     # 触发锁存的类型，0：DO
            ("eventPara1", c_int16),    # 事件参数1
            ("eventPara2", c_int16),    # 事件参数2
            ("eventPara3", c_int16),    # 事件参数3
            ("eventDir", c_int16),      # 比较方向，大于等,参考EVENT_DIR_EQUAL等定义
            ("reserved1", c_int16 * 3), # 保留字段
            ("compVal1", c_double),     # 比较值1
            ("compVal2", c_double),     # 比较值2
            ("captVarCnt", c_int16),    # 锁存变量数量
            ("reserved2", c_int16 * 7), # 保留字段
            ("captVarList", c_int16 * VAR_CAPT_NUM_MAX),    # 变量类型列表
            ("captVarIdxList", c_int16 * VAR_CAPT_NUM_MAX)  # 变量通道号列表
        ]

        def __init__(self):
            super().__init__()
            self.eventType = 0
            self.eventPara1 = 0
            self.eventPara2 = 0
            self.eventPara3 = 0
            self.eventDir = 0
            self.compVal1 = 0.0
            self.compVal2 = 0.0
            self.captVarCnt = 0

            self.reserved1[:] = (0, 0, 0)
            self.reserved2[:] = (0,) * 7
            self.captVarList[:] = (0,) * VAR_CAPT_NUM_MAX
            self.captVarIdxList[:] = (0,) * VAR_CAPT_NUM_MAX
    """ 
    // 变量锁存参数设置
    // pPara:参数 如上
    // chn:控制通道号，取值范围[0,n)
    """
    def OEM_VarCaptSetPara(devHandle, Para, chn):
        libc.OEM_VarCaptSetPara.argtypes = [c_ushort,  POINTER(pymtn.TVarCaptPara),  c_short]
        ret = libc.OEM_VarCaptSetPara(devHandle,   byref(Para),  chn)
        return ret

    """ 
    // 变量锁存开关
    """
    def OEM_VarCaptSetOnOff(devHandle, onOff, chn):
        libc.OEM_VarCaptSetOnOff.argtypes = [c_ushort,  c_short,  c_short]
        return libc.OEM_VarCaptSetOnOff(devHandle,  onOff,  chn)

    """ 
    // 变量锁存获取状态
    """
    def OEM_VarCaptGetSts(devHandle, chn):
        OnOff_tmp = c_short()
        TrigCnt_tmp = c_short()
        UsedSpaceByte_tmp = c_int32()
        LeftSpaceByte_tmp = c_int32()
        libc.OEM_VarCaptGetSts.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_short),  POINTER(c_int32),  POINTER(c_int32),  c_short]
        ret = libc.OEM_VarCaptGetSts(devHandle,  byref(OnOff_tmp),  byref(TrigCnt_tmp),  byref(UsedSpaceByte_tmp),  byref(LeftSpaceByte_tmp),  chn)
        return OnOff_tmp, TrigCnt_tmp, UsedSpaceByte_tmp, LeftSpaceByte_tmp, ret

    """ 
    // 变量锁存获取锁存数据
    // pData:返回的数据，数据的组织根据变量类型排列
    // toGetByte:期望读取的数据长度，单位:Byte,长度为数据单元的整数倍
    // pGetByte:返回的实际数据的长度,单位:Byte,长度为数据单元的整数倍
    """
    def OEM_VarCaptGetData(devHandle, toGetByte, chn):
        data_len = toGetByte // 4          # 计算Int32元素个数
        Data_tmp = (c_int32 * data_len)()  # 定义数据缓冲区数组
        GetByte_tmp = c_short()
        libc.OEM_VarCaptGetData.argtypes = [c_ushort,  POINTER(c_int32),  c_short,  POINTER(c_short),  c_short]
        ret = libc.OEM_VarCaptGetData(devHandle,  Data_tmp,  toGetByte,  byref(GetByte_tmp),  chn)
        data_list = [Data_tmp[i] for i in range(data_len)]
        return data_list, GetByte_tmp, ret

    class TMioConfig(Structure):
        _fields_ = [
            ("mioType", c_int8),   # 映射的IO类型 (如DI_TYPE_GPI)
            ("mioGroup", c_int8),  # IO组号
            ("mioIdx", c_int8),    # IO序号
            ("reverse", c_int8),   # 是否反向 (0:正常 1:反向)
            ("reserved", c_int8 * 4)  # 保留字段
        ]

        def __init__(self):
            super().__init__()
            self.mioType = DI_TYPE_GPI
            self.mioGroup = 0
            self.mioIdx = 0
            self.reverse = 0
            self.reserved[:] = (0, 0, 0, 0)
    """ 
    // 设置MotionIO的映射
    // mioInOut:0:输入类型的mio  1:输出类型的mio
    // mioType:设置的mio的类型，宏定义DI_TYPE等
    // pDiCfg:配置的参数
    """
    def NMC_MtSetMioConfig(axisHandle, mioInOut, mioType, DiCfg):
        libc.NMC_MtSetMioConfig.argtypes = [c_ushort,  c_short,  c_short,  POINTER(pymtn.TMioConfig)]
        ret = libc.NMC_MtSetMioConfig(axisHandle,  mioInOut,  mioType,  byref(DiCfg))
        return ret

    def NMC_MtGetMioConfig(axisHandle, mioInOut, mioType, DiCfg):
        libc.NMC_MtGetMioConfig.argtypes = [c_ushort,  c_short,  c_short,  POINTER(pymtn.TMioConfig)]
        ret = libc.NMC_MtGetMioConfig(axisHandle,  mioInOut,  mioType,  byref(DiCfg))
        return DiCfg, ret

    # 设置坐标系运动限制，仅上位机前瞻下工作
    class TCrdAxMvLimit(Structure):
        _fields_ = [
            ("axMaxVel", c_double * CRD_MAX_DIMENSION),  # 单轴最大分解速度 [m/s或单位/s]
            ("reserved", c_double * 8)  # 保留字段
        ]

        def __init__(self):
            super().__init__()
            for i in range(CRD_MAX_DIMENSION):
                self.axMaxVel[i] = 0.0
            for i in range(8):
                self.reserved[i] = 0.0

    def OEM_CrdSetAxMvLimit(crdHandle,MvLmt):
        libc.OEM_CrdSetAxMvLimit.argtypes = [c_ushort,  POINTER(pymtn.TCrdAxMvLimit)]
        ret = libc.OEM_CrdSetAxMvLimit(crdHandle,  byref(MvLmt))
        return ret

    def OEM_CrdGetAxMvLimit(crdHandle, MvLmt):
        libc.OEM_CrdGetAxMvLimit.argtypes = [c_ushort,  POINTER(pymtn.TCrdAxMvLimit)]
        ret = libc.OEM_CrdGetAxMvLimit(crdHandle,  byref(MvLmt))
        return MvLmt, ret

    """------------------------------------------------------------------------------------------------------------
    //    高度跟随功能    
    //    步骤：1.设置高度跟随参数
    //          2.运动到轨迹起点，开启采样，通过坐标系运动，走完轨迹，到达终点后，结束采样
    //          3.运动到轨迹起点，开启补偿，加工完成轨迹运动，关闭补偿
    //------------------------------------------------------------------------------------------------------------
    """

    class THeightAdjusterPara(Structure):
        _fields_ = [
            ("mode", c_int16),    # 调高模式 0 采样调高  先采集后 应用数据
            ("axis", c_int16),    # 调高运动的轴号
            ("adcChn", c_int16),  # 调高使用的adc通道号
            ("minVal", c_int16),  # 调高的最小电压 0~32767 对应 0~10V
            ("maxVal", c_int16),  # 调高的最大电压 0~32767 对应 0~10V
            ("limitVal", c_int16),# 调高允许的最大变化量 0~32767 对应 0~10V
            ("dir1No", c_int16),  # X轴轴号
            ("dir2No", c_int16),  # Y轴轴号
            ("voltageToPulse", c_double),  # 电压-脉冲转换系数 (脉冲/V)
            ("vel", c_double),    # 调高速度 (脉冲/ms)
            ("acc", c_double),    # 调高加速度 (脉冲/ms²)
            ("dirReverse", c_int16),  # 调高方向取反 (0:正常 1:取反)
            ("posSrc", c_int16),      # 位置源 (0:规划 1:编码器)
            ("reversed2", c_int32 * 7)  # 保留字段
        ]

        def __init__(self):
            super().__init__()
            self.mode = 0
            self.axis = 2
            self.adcChn = 256    # 默认扩展ADC通道
            self.minVal = 0      # 最小电压0V
            self.maxVal = 32767  # 最大电压10V
            self.limitVal = 1000 # 最大变化量≈0.3V
            self.dir1No = 0  # X轴
            self.dir2No = 1  # Y轴
            self.voltageToPulse = 10.0  # 10脉冲/V
            self.vel = 1.0  # 1脉冲/ms
            self.acc = 0.5  # 0.5脉冲/ms²
            self.dirReverse = 0  # 方向不取反
            self.posSrc = 0  # 使用规划位置
            self.reversed2[:] = (0,) * 7 # 保留字段清零
    """
    // 设置调高功能参数
    // ch: 调高通道号 目前支持0
    // THeightAdjusterPara:调高功能参数结构体
    // group:组号，取值范围[0,32)，暂时共用一组参数
    """
    def OEM_SetHeightAdjusterPara(devHandle, ch, para, group):
        libc.OEM_SetHeightAdjusterPara.argtypes = [c_ushort,  c_short,  POINTER(pymtn.THeightAdjusterPara),  c_short]
        ret = libc.OEM_SetHeightAdjusterPara(devHandle,  ch,  byref(para),  group)
        return ret

    """ 读取调高功能参数
    // ch: 调高通道号 目前支持0
    // THeightAdjusterPara:调高功能参数结构体
    // group:组号，取值范围[0,32)，暂时共用一组参数
    """
    def OEM_GetHeightAdjusterPara(devHandle, ch,para, group):
        libc.OEM_GetHeightAdjusterPara.argtypes = [c_ushort,  c_short,  POINTER(pymtn.THeightAdjusterPara),  c_short]
        ret = libc.OEM_GetHeightAdjusterPara(devHandle,  ch,  byref(para),  group)
        return ret

    """ 
    // 启动调高采样参数
    // ch: 调高通道号 目前支持0
    // onOff: 0 采样关闭 1采样开始
    // sampleInterval: 采样位置间隔 单位 脉冲
    // sampleCount: 采样个数 当前设0
    // group:组号，取值范围[0,32)
    """
    def OEM_SetHeightAdjusterSamplingOnOff(devHandle, ch, onOff, sampleInterval, sampleCount, group):
        libc.OEM_SetHeightAdjusterSamplingOnOff.argtypes = [c_ushort,  c_short,  c_short,  c_int32,  c_int32,  c_short]
        return libc.OEM_SetHeightAdjusterSamplingOnOff(devHandle,  ch,  onOff,  sampleInterval,  sampleCount,  group)

    """ 
    // 读取调高采样参数
    // ch: 调高通道号 目前支持0
    // onOff: 0 采样关闭 1采样开始
    // sampleInterval: 采样位置间隔 单位 脉冲
    // sampleCount: 采样个数 当前设0.
    // group:组号，取值范围[0,32)
    """
    def OEM_GetHeightAdjusterSamplingOnOff(devHandle, ch, group):
        onOff_tmp = c_short()
        sampleInterval_tmp = c_int32()
        sampleCount_tmp = c_int32()
        libc.OEM_GetHeightAdjusterSamplingOnOff.argtypes = [c_ushort,  c_short,  POINTER(c_short),  POINTER(c_int32),  POINTER(c_int32),  c_short]
        ret = libc.OEM_GetHeightAdjusterSamplingOnOff(devHandle,  ch,  byref(onOff_tmp),  byref(sampleInterval_tmp),  byref(sampleCount_tmp), group)
        return onOff_tmp, sampleInterval_tmp, sampleCount_tmp, ret

    """ 
    // 读取调高采样状态
    // ch: 调高通道号 目前支持0
    // dataCount: 已采样数据个数
    // group:组号，取值范围[0,32)
    """
    def OEM_HeightAdjusterGetSamplingSts(devHandle, ch, group):
        dataCount_tmp = c_int32()
        libc.OEM_HeightAdjusterGetSamplingSts.argtypes = [c_ushort,  c_short,  POINTER(c_int32),  c_short]
        ret = libc.OEM_HeightAdjusterGetSamplingSts(devHandle,  ch,  byref(dataCount_tmp),  group)
        return dataCount_tmp, ret

    """ 
    // 设置调高启动参数
    // ch: 调高通道号 目前支持0
    // onOff: 0 调高关闭 1调高开始
    // offset: 调高轨迹和采样轨迹的偏移 offset[0]为X方向偏移 offset[1]为Y方向偏移 
    // group:组号，取值范围[0,32)
    """
    def OEM_SetHeightAdjusterOnOff(devHandle, ch, onOff, offset, group):
        offset_tmp = (c_double * len(offset))(*offset)
        libc.OEM_SetHeightAdjusterOnOff.argtypes = [c_ushort,  c_short,  c_short,  POINTER(c_double),  c_short]
        ret = libc.OEM_SetHeightAdjusterOnOff(devHandle,  ch,  onOff,  offset_tmp,  group)
        return ret

    """ 
    // 读取调高启动参数
    // ch: 调高通道号 目前支持0
    // onOff: 0 调高关闭 1调高开始
    // offset: 调高轨迹和采样轨迹的偏移 offset[0]为X方向偏移 offset[1]为Y方向偏移 
    // group:组号，取值范围[0,32)
    """
    def OEM_GetHeightAdjusterOnOff(devHandle, ch, group):
        onOff_tmp = c_short()
        offset_tmp = (c_double * 2)()
        libc.OEM_GetHeightAdjusterOnOff.argtypes = [c_ushort,  c_short,  POINTER(c_short),  POINTER(c_double),  c_short]
        ret = libc.OEM_GetHeightAdjusterOnOff(devHandle,  ch,  byref(onOff_tmp),  offset_tmp,  group)
        return onOff_tmp, offset_tmp[0], offset_tmp[1], ret

    """ 
    // 读取调高采样数据,未实现
    // ch: 调高通道号 目前支持0
    // data: 采样数据 数组3个数据为一组，顺序为 X Y ADC
    """
    def OEM_GetHeightAdjusterSamplingData(devHandle, ch, group):
        data_tmp = (c_double * 3)()
        libc.OEM_GetHeightAdjusterSamplingData.argtypes = [c_ushort,  c_short,  POINTER(c_double),  c_short]
        ret = libc.OEM_GetHeightAdjusterSamplingData(devHandle,  ch,  data_tmp,  group)
        return data_tmp[0], data_tmp[1], data_tmp[2], ret

    """ 
    // 设置规划映射
    // prfMapCnt: 规划映射的轴数量
    // pPrfIdxList:规划映射的序号列表
    // pPrfCoe:规划映射的Coe系数，取值范围[-8,8]
    """
    def OEM_MtSetPrfMap(axisHandle, prfMapCnt, PrfIdxList,  PrfCoe):
        PrfIdxList_tmp = (c_short * prfMapCnt)(*PrfIdxList)
        PrfCoe_tmp =(c_double * prfMapCnt)(*PrfCoe)
        libc.OEM_MtSetPrfMap.argtypes = [c_ushort,  c_short,  POINTER(c_short),  POINTER(c_double)]
        ret = libc.OEM_MtSetPrfMap(axisHandle,  prfMapCnt,  PrfIdxList_tmp,  PrfCoe_tmp)
        return ret

    def OEM_MtGetPrfMap(axisHandle):
        prfMapCnt_tmp = c_short()
        PrfIdxList_tmp = (c_short * MT_PRF_MAP_CNT_MAX)()
        PrfCoe_tmp = (c_double * MT_PRF_MAP_CNT_MAX)()
        libc.OEM_MtGetPrfMap.argtypes = [c_ushort,  POINTER(c_short),  POINTER(c_short),  POINTER(c_double)]
        ret = libc.OEM_MtGetPrfMap(axisHandle,  byref(prfMapCnt_tmp),  PrfIdxList_tmp,  PrfCoe_tmp)
        PrfIdxList_tmp = [PrfIdxList_tmp[i] for i in range(prfMapCnt_tmp.value)]
        PrfCoe_tmp = [PrfCoe_tmp[i] for i in range(prfMapCnt_tmp.value)]
        return prfMapCnt_tmp, PrfIdxList_tmp, PrfCoe_tmp, ret



