一、基础连接与系统接口（Python）
本页对应 C++ 版。函数名与参数顺序与 C++ 完全一致（Python SDK 由 C++ 经 SWIG 生成），差异只在两处：
- 返回值形态：C++ 用引用参数回填数据；Python 的返回形态由 SWIG 绑定决定，逐接口实测，不按类型推断。
- 少数接口在 Python 中不可直接调用（绑定缺陷），页面内已逐个标注。
本页共 162 个接口，其中 162 个在 Python SDK 中存在。
1.1 连接管理
get_library_version
获取库版本信息。
def get_library_version():返回值：str。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret = nrc.get_library_version()
print(ret)C++ 侧返回值描述：库版本相关信息字符串。
connect_robot
连接机器人控制器。同步方式，函数会阻塞直到返回连接结果。
def connect_robot(ip, port):返回值：int —— socket 文件描述符（>0 成功，<=0 失败）。该接口会发起真实网络连接，本文档未做在线实测，按 C++ 语义描述。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 输入/输出 | 说明 |
|---|---|---|---|
| ip | const std::string& | 输入 | 控制器 IP 地址，如 "192.168.1.13" |
| port | const std::string& | 输入 | 端口号，如 "6001" |
C++ 侧返回值描述：SOCKETFD（int）—— 连接成功返回 socket 文件描述符；-1 表示连接失败。
disconnect_robot
断开与控制器连接。
def disconnect_robot(socketFd):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret = nrc.disconnect_robot(fd)
print(ret)get_connection_status
获取控制器连接状态。
def get_connection_status(socketFd):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret = nrc.get_connection_status(fd)
print(ret)set_reconnect
设置是否开启断开后自动重连功能，默认关闭。
def set_reconnect(socketFd, reconnect):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
set_reconnect_callback
设置重连成功后的回调函数。
def set_reconnect_callback(socketFd, function):返回值：未实测（该接口需要真实控制器环境），语义同 C++。
自动重连的三个要点
set_reconnect默认关闭：不显式打开，断线后不会重连，后续调用会一路返回-2。- 回调是 C 函数指针
void(*)()，在重连成功后触发。回调里不要做耗时操作、也不要直接下发运动命令。 - 重连回来不要假设机器人状态没变：伺服状态、运行模式、队列模式都可能已被控制器复位。先读
get_servo_state/get_current_mode/queue_motion_get_status，确认后再继续下发。
1.2 消息通讯
send_message
向控制器发送一条自定义消息。
def send_message(socketFd, messageID, message):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| messageID | int | 消息 ID |
| message | const std::string& | 消息内容 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
recv_message
注册消息接收回调，当收到控制器消息时触发。
def recv_message(*args):返回值：未实测（该接口需要真实控制器环境），语义同 C++。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| callback | void()(int, const char) | 回调函数，参数为消息 ID 和消息内容 |
1.3 伺服控制
set_axis_sdo
设置伺服命令字（SDO，Service Data Object）。用于直接向伺服驱动器写入 CANopen SDO 对象字典数据。
def set_axis_sdo(socketFd, axisNum, index, subindex, cmdvalue, size):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| axisNum | int | 机器人的轴编号 |
| index | unsigned int | 命令字编码（对象字典索引） |
| subindex | unsigned int | 命令字子编码（对象字典子索引） |
| cmdvalue | int | 要设置进去的值 |
| size | unsigned int | 命令字对应的值的字节数 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
set_robots_parallel
设置多机器人并行模式。
def set_robots_parallel(socketFd, open):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| open | bool | true=开启并行，false=关闭 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
clear_error / clear_error_robot
伺服清错。
clear_error
def clear_error(socketFd):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret = nrc.clear_error(fd)
print(ret)clear_error_robot
def clear_error_robot(socketFd, robotNum):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret = nrc.clear_error_robot(fd, 1)
print(ret)参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
注意
出错前如果处于伺服运行状态，清错后需要手动进行下电操作，释放控制器的占用状态才可以继续上电（清错后不能直接上电，先下电再上电）。
set_servo_state / set_servo_state_robot
设置伺服状态（停止/就绪）。
set_servo_state
def set_servo_state(socketFd, state):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
set_servo_state_robot
def set_servo_state_robot(socketFd, robotNum, state):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| state | int | 0=停止，1=就绪 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
注意
- 设置伺服就绪前应确保系统没有错误（先调用
clear_error） - 该函数只有伺服状态为 0（停止）或 1（就绪）时调用生效，状态为 2（报警）或 3（运行）时不能直接设置
get_servo_state / get_servo_state_robot
获取伺服状态。
get_servo_state
def get_servo_state(socketFd, status):返回值：list，共 2 个元素，形如 [结果码, 数据...]。下标 0 是结果码，下标 1 是出参值。（实测为 list 而非 tuple，解包写法 ret, val = ... 同样可用。）
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret, val = nrc.get_servo_state(fd, 0)
print(ret, val) # 返回 list，可直接解包get_servo_state_robot
def get_servo_state_robot(socketFd, robotNum, status):返回值：list，共 2 个元素，形如 [结果码, 数据...]。下标 0 是结果码，下标 1 是出参值。（实测为 list 而非 tuple，解包写法 ret, val = ... 同样可用。）
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret, val = nrc.get_servo_state_robot(fd, 1, 0)
print(ret, val) # 返回 list，可直接解包参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| status | int& | 输出参数：0=停止，1=就绪，2=报警，3=运行 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
set_servo_poweron / set_servo_poweron_robot
机器人上电。
set_servo_poweron
def set_servo_poweron(socketFd):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret = nrc.set_servo_poweron(fd)
print(ret)set_servo_poweron_robot
def set_servo_poweron_robot(socketFd, robotNum):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret = nrc.set_servo_poweron_robot(fd, 1)
print(ret)参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
注意
调用该函数前需要先调用 set_servo_state(fd, 1) 将伺服设置为就绪状态；上电成功后调用 get_servo_state 返回 3（运行状态）。该函数只有伺服状态为 1（就绪）时调用生效。
set_servo_poweroff / set_servo_poweroff_robot
机器人下电。
set_servo_poweroff
def set_servo_poweroff(socketFd):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret = nrc.set_servo_poweroff(fd)
print(ret)set_servo_poweroff_robot
def set_servo_poweroff_robot(socketFd, robotNum):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret = nrc.set_servo_poweroff_robot(fd, 1)
print(ret)参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
注意
下电成功后调用 get_servo_state 返回 1（就绪状态）。该函数只有伺服状态为 3（运行）时调用生效。
上下电失败排查（RECEIVE_FAILED）
现象：set_servo_state(fd, 1) 返回成功，但 set_servo_poweron / set_servo_poweroff（含 _robot 变体）返回 RECEIVE_FAILED。
排查顺序（都用只读 / 可逆手段）
| 假设 | 怎么验 | 判定 |
|---|---|---|
| 上一步未下电、控制器被占用 | 按顺序重跑：clear_error →（若状态为 3 则下电）→（若非 0 则置 0）→ 置 1 → 上电 | 若仍 RECEIVE_FAILED → 不是占用问题 |
| 当前模式不对 | 在示教 / 远程 / 运行三种模式下各试一次 set_servo_poweroff | 三种模式都失败 → 与模式无关 |
| 使能方式为硬件触发 | 读 JSON 命令字 0x3034 | 返回 mode=0（软件触发）→ 不是该原因 |
| 该命令未实现 | 用不存在的机器人编号（如 robot=2）发同一命令 | 返回"参数错误" → 命令已被实现且会被应答，说明是"不被应答"而非"未实现" |
| 只读接口是否也大面积不应答 | 批量调用只读接口 | 实测仅 get_robot_configuration 不应答，其余正常 → 可判定 RECEIVE_FAILED ≈ 该命令在本机固件上不被应答 |
1.4 位置与状态查询
get_current_position / get_current_position_robot
获取机器人当前位置。
get_current_position
def get_current_position(socketFd, coord, pos):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参容器原地填充——先创建 nrc.VectorDouble() 传入，调用成功后用 list(obj) 读取。
get_current_position_robot
def get_current_position_robot(socketFd, robotNum, coord, pos):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参容器原地填充——先创建 nrc.VectorDouble() 传入，调用成功后用 list(obj) 读取。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| coord | int | 坐标系：0=关节，1=直角，2=工具，3=用户 |
| pos | std::vector<double>& | 输出参数，存储点位数据，长度 7 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
get_joint_position / get_joint_position_robot
获取机器人指定关节（axisNum）对应的点位数据（24.03 版本专用）。
不要凭名字猜语义：先用小探针比较
get_joint_position(axisNum)与get_current_position(coord=0/1)的返回值，确认口径后再用于业务。
get_joint_position
def get_joint_position(socketFd, axisNum, pos):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参容器原地填充——先创建 nrc.VectorDouble() 传入，调用成功后用 list(obj) 读取。
get_joint_position_robot
def get_joint_position_robot(socketFd, robotNum, axisNum, pos):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参容器原地填充——先创建 nrc.VectorDouble() 传入，调用成功后用 list(obj) 读取。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| axisNum | int | 指定需要查询的关节 |
| pos | std::vector<double>& | 输出参数，存储点位数据，长度 7 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
get_current_extra_position / get_current_extra_position_robot
获取机器人外部轴当前位置。
get_current_extra_position
def get_current_extra_position(socketFd, pos):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参容器原地填充——先创建 nrc.VectorDouble() 传入，调用成功后用 list(obj) 读取。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
out_pos = nrc.VectorDouble()
ret = nrc.get_current_extra_position(fd, out_pos)
print(ret, list(out_pos)) # 容器用 list() 读取get_current_extra_position_robot
def get_current_extra_position_robot(socketFd, robotNum, pos):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参容器原地填充——先创建 nrc.VectorDouble() 传入，调用成功后用 list(obj) 读取。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
out_pos = nrc.VectorDouble()
ret = nrc.get_current_extra_position_robot(fd, 1, out_pos)
print(ret, list(out_pos)) # 容器用 list() 读取参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| pos | std::vector<double>& | 输出参数，点位数组，长度 5 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
get_current_positon_and_extra_position / get_current_positon_and_extra_position_robot
获取机器人和外部轴的当前位置。
get_current_positon_and_extra_position
def get_current_positon_and_extra_position(socketFd, coord, pos):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参容器原地填充——先创建 nrc.VectorDouble() 传入，调用成功后用 list(obj) 读取。
get_current_positon_and_extra_position_robot
def get_current_positon_and_extra_position_robot(socketFd, robotNum, coord, pos):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参容器原地填充——先创建 nrc.VectorDouble() 传入，调用成功后用 list(obj) 读取。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| coord | int | 坐标系：0=关节，1=直角，2=工具，3=用户 |
| pos | std::vector<double>& | 输出参数，点位数组，长度 12（前 7 位机器人，后 5 位外部轴） |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
get_robot_running_state / get_robot_running_state_robot
获取机器人运行状态。
get_robot_running_state
def get_robot_running_state(socketFd, status):返回值：list，共 2 个元素，形如 [结果码, 数据...]。下标 0 是结果码，下标 1 是出参值。（实测为 list 而非 tuple，解包写法 ret, val = ... 同样可用。）
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret, val = nrc.get_robot_running_state(fd, 0)
print(ret, val) # 返回 list，可直接解包get_robot_running_state_robot
def get_robot_running_state_robot(socketFd, robotNum, status):返回值：list，共 2 个元素，形如 [结果码, 数据...]。下标 0 是结果码，下标 1 是出参值。（实测为 list 而非 tuple，解包写法 ret, val = ... 同样可用。）
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret, val = nrc.get_robot_running_state_robot(fd, 1, 0)
print(ret, val) # 返回 list，可直接解包参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| status | int& | 输出参数：0=停止，1=暂停，2=运行 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
1.5 速度与模式控制
set_speed / set_speed_robot
设置当前模式的速度（示教/运行/远程三种模式）。
set_speed
def set_speed(socketFd, speed):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
set_speed_robot
def set_speed_robot(socketFd, robotNum, speed):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| speed | int | 速度，范围 0<speed≤100 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
get_speed / get_speed_robot
获取当前模式的速度。
get_speed
def get_speed(socketFd, speed):返回值：list，共 2 个元素，形如 [结果码, 数据...]。下标 0 是结果码，下标 1 是出参值。（实测为 list 而非 tuple，解包写法 ret, val = ... 同样可用。）
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret, val = nrc.get_speed(fd, 0)
print(ret, val) # 返回 list，可直接解包get_speed_robot
def get_speed_robot(socketFd, robotNum, speed):返回值：list，共 2 个元素，形如 [结果码, 数据...]。下标 0 是结果码，下标 1 是出参值。（实测为 list 而非 tuple，解包写法 ret, val = ... 同样可用。）
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret, val = nrc.get_speed_robot(fd, 1, 0)
print(ret, val) # 返回 list，可直接解包参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| speed | int& | 输出参数，当前速度 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
set_current_coord / set_current_coord_robot
设置机器人当前坐标系。
set_current_coord
def set_current_coord(socketFd, coord):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
set_current_coord_robot
def set_current_coord_robot(socketFd, robotNum, coord):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| coord | int | 坐标系：0=关节，1=直角，2=工具，3=用户 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
get_current_coord / get_current_coord_robot
获取机器人当前坐标系。
get_current_coord
def get_current_coord(socketFd, coord):返回值：list，共 2 个元素，形如 [结果码, 数据...]。下标 0 是结果码，下标 1 是出参值。（实测为 list 而非 tuple，解包写法 ret, val = ... 同样可用。）
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret, val = nrc.get_current_coord(fd, 0)
print(ret, val) # 返回 list，可直接解包get_current_coord_robot
def get_current_coord_robot(socketFd, robotNum, coord):返回值：list，共 2 个元素，形如 [结果码, 数据...]。下标 0 是结果码，下标 1 是出参值。（实测为 list 而非 tuple，解包写法 ret, val = ... 同样可用。）
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret, val = nrc.get_current_coord_robot(fd, 1, 0)
print(ret, val) # 返回 list，可直接解包参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| coord | int& | 输出参数，坐标系：0=关节，1=直角，2=工具，3=用户 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
set_current_mode / set_current_mode_robot
设置机器人当前模式。
set_current_mode
def set_current_mode(socketFd, mode):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
set_current_mode_robot
def set_current_mode_robot(socketFd, robotNum, mode):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| mode | int | 模式：0=示教，1=远程，2=运行 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
get_current_mode / get_current_mode_robot
获取机器人当前模式。
get_current_mode
def get_current_mode(socketFd, mode):返回值：list，共 2 个元素，形如 [结果码, 数据...]。下标 0 是结果码，下标 1 是出参值。（实测为 list 而非 tuple，解包写法 ret, val = ... 同样可用。）
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret, val = nrc.get_current_mode(fd, 0)
print(ret, val) # 返回 list，可直接解包get_current_mode_robot
def get_current_mode_robot(socketFd, robotNum, mode):返回值：list，共 2 个元素，形如 [结果码, 数据...]。下标 0 是结果码，下标 1 是出参值。（实测为 list 而非 tuple，解包写法 ret, val = ... 同样可用。）
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret, val = nrc.get_current_mode_robot(fd, 1, 0)
print(ret, val) # 返回 list，可直接解包参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| mode | int& | 输出参数，模式：0=示教，1=远程，2=运行 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
get_robot_type / get_robot_type_robot
获取机器人类型。
get_robot_type
def get_robot_type(socketFd, type):返回值：list，共 2 个元素，形如 [结果码, 数据...]。下标 0 是结果码，下标 1 是出参值。（实测为 list 而非 tuple，解包写法 ret, val = ... 同样可用。）
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret, val = nrc.get_robot_type(fd, 0)
print(ret, val) # 返回 list，可直接解包get_robot_type_robot
def get_robot_type_robot(socketFd, robotNum, type):返回值：list，共 2 个元素，形如 [结果码, 数据...]。下标 0 是结果码，下标 1 是出参值。（实测为 list 而非 tuple，解包写法 ret, val = ... 同样可用。）
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret, val = nrc.get_robot_type_robot(fd, 1, 0)
print(ret, val) # 返回 list，可直接解包参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| type | int& | 输出参数，机器人类型：1=六轴串联多关节，2=四轴 SCARA，3=四轴码垛，4=四轴串联多关节，5=单轴，6=五轴串联多关节，7=六轴协作，8=二轴 SCARA，9=三轴 SCARA，10=三轴直角，11=三轴异形，12=七轴串联多关节，13=SCARA 异形一，14=四轴码垛丝杆 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
1.7 用户坐标
set_user_coord_number / set_user_coord_number_robot
设置用户坐标编号。
set_user_coord_number
def set_user_coord_number(socketFd, userNum):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
set_user_coord_number_robot
def set_user_coord_number_robot(socketFd, robotNum, userNum):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| userNum | int | 用户坐标编号 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
get_user_coord_number / get_user_coord_number_robot
获取当前使用的用户坐标编号。
get_user_coord_number
def get_user_coord_number(socketFd, userNum):返回值：list，共 2 个元素，形如 [结果码, 数据...]。下标 0 是结果码，下标 1 是出参值。（实测为 list 而非 tuple，解包写法 ret, val = ... 同样可用。）
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret, val = nrc.get_user_coord_number(fd, 0)
print(ret, val) # 返回 list，可直接解包get_user_coord_number_robot
def get_user_coord_number_robot(socketFd, robotNum, userNum):返回值：list，共 2 个元素，形如 [结果码, 数据...]。下标 0 是结果码，下标 1 是出参值。（实测为 list 而非 tuple，解包写法 ret, val = ... 同样可用。）
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret, val = nrc.get_user_coord_number_robot(fd, 1, 0)
print(ret, val) # 返回 list，可直接解包参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| userNum | int& | 输出参数，当前用户坐标编号 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
get_user_coord_para / get_user_coord_para_robot
获取用户坐标参数。
get_user_coord_para
def get_user_coord_para(socketFd, userNum, pos):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参容器原地填充——先创建 nrc.VectorDouble() 传入，调用成功后用 list(obj) 读取。
get_user_coord_para_robot
def get_user_coord_para_robot(socketFd, robotNum, userNum, pos):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参容器原地填充——先创建 nrc.VectorDouble() 传入，调用成功后用 list(obj) 读取。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| userNum | int | 用户坐标编号 |
| pos | std::vector<double>& | 输出参数，用户坐标参数（X/Y/Z 偏移 + A/B/C 旋转角） |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
set_user_coordinate_data / set_user_coordinate_data_robot
标定用户坐标（写入坐标数据）。
set_user_coordinate_data
def set_user_coordinate_data(socketFd, userNum, pos):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
set_user_coordinate_data_robot
def set_user_coordinate_data_robot(socketFd, robotNum, userNum, pos):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| userNum | int | 用户坐标编号 |
| pos | std::vector<double> | 坐标数据（X/Y/Z 偏移 + A/B/C 旋转角） |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
calibration_oxy / calibration_oxy_robot
标定 OXY（三点法：原点、X 轴方向点、Y 轴方向点）。
calibration_oxy
def calibration_oxy(socketFd, userNum, xyo):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
calibration_oxy_robot
def calibration_oxy_robot(socketFd, robotNum, userNum, xyo):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| userNum | int | 用户坐标编号 |
| xyo | std::string | 标定类型：'X'（X 轴方向点）、'Y'（Y 轴方向点）、'O'（原点） |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
calculate_user_coordinate / calculate_user_coordinate_robot
计算用户坐标（OXY 三点标定完成后计算最终结果）。
calculate_user_coordinate
def calculate_user_coordinate(socketFd, userNumber):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
calculate_user_coordinate_robot
def calculate_user_coordinate_robot(socketFd, robotNum, userNum):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| userNum / userNumber | int | 用户坐标编号 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
1.8 全局点位与变量
set_global_position / set_global_position_robot
设置全局 GP 点位。
set_global_position
def set_global_position(socketFd, posName, posInfo):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
set_global_position_robot
def set_global_position_robot(socketFd, robotNum, posName, posInfo):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| posName | std::string | 全局位置名，如 "GP0001" |
| posInfo | std::vector<double> | 点位数据，长度 14：[0]坐标系（0=关节，1=直角，2=工具，3=用户）；[1]角度制(0)/弧度制(1)；[2]形态；[3]工具手坐标序号；[4]用户坐标序号；[5][6]备用；[7-13]点位信息 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
get_global_position / get_global_position_robot
查询全局 GP 点位。
get_global_position
def get_global_position(socketFd, posName, pos):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参容器原地填充——先创建 nrc.VectorDouble() 传入，调用成功后用 list(obj) 读取。
get_global_position_robot
def get_global_position_robot(socketFd, robotNum, posName, pos):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参容器原地填充——先创建 nrc.VectorDouble() 传入，调用成功后用 list(obj) 读取。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| posName | std::string | 全局位置名，如 "GP0001" |
| pos | std::vector<double>& | 输出参数，全局点位数组，长度 14（前 7 位为点位坐标/姿态信息，后 7 位为机器人位置） |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
set_global_sync_position / set_global_sync_position_robot
设置全局 GE 点位（含外部轴）。
set_global_sync_position
def set_global_sync_position(socketFd, posName, posInfo):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
set_global_sync_position_robot
def set_global_sync_position_robot(socketFd, robotNum, posName, posInfo):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| posName | const std::string& | 全局位置名，如 "GE0001" |
| posInfo | std::vector<double> | 点位数据，长度 21：[0-6]坐标系/角度制/形态/工具/用户坐标序号/备用；[7-13]机器人本体点位；[14-20]外部轴点位 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
get_global_sync_position / get_global_sync_position_robot
查询全局 GE 点位。
get_global_sync_position
def get_global_sync_position(socketFd, posName, pos):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参容器原地填充——先创建 nrc.VectorDouble() 传入，调用成功后用 list(obj) 读取。
get_global_sync_position_robot
def get_global_sync_position_robot(socketFd, robotNum, posName, pos):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参容器原地填充——先创建 nrc.VectorDouble() 传入，调用成功后用 list(obj) 读取。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| posName | const std::string& | 全局位置名，如 "GE0001" |
| pos | std::vector<double>& | 输出参数，全局点位数组，长度 21（前 7 位坐标/姿态，中间 7 位机器人位置，后 7 位外部轴位置） |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
set_global_variant / set_global_variant_robot
设置全局变量（GI/GD/GB 系列）。
set_global_variant
def set_global_variant(socketFd, varName, varValue):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
set_global_variant_robot
def set_global_variant_robot(socketFd, robotNum, varName, varValue):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| varName | const std::string& | 全局变量名，如 "GI001"、"GD001"、"GB001" |
| varValue | double | 变量值 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
get_global_variant / get_global_variant_robot
查询全局变量。
get_global_variant
def get_global_variant(socketFd, varName, vaule):返回值：list，共 2 个元素，形如 [结果码, 数据...]。下标 0 是结果码，下标 1 是出参值。（实测为 list 而非 tuple，解包写法 ret, val = ... 同样可用。）
get_global_variant_robot
def get_global_variant_robot(socketFd, robotNum, varName, vaule):返回值：list，共 2 个元素，形如 [结果码, 数据...]。下标 0 是结果码，下标 1 是出参值。（实测为 list 而非 tuple，解包写法 ret, val = ... 同样可用。）
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| varName | const std::string& | 全局变量名，如 "GI001"、"GD001"、"GB001" |
| vaule | double& | 输出参数，变量值 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
1.9 零点与标定
set_axis_zero_position / set_axis_zero_position_robot
设置零点位置（将当前轴位置设为零点）。
set_axis_zero_position
def set_axis_zero_position(socketFd, axis):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
set_axis_zero_position_robot
def set_axis_zero_position_robot(socketFd, robotNum, axis):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| axis | int | 轴号 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
set_zero_pos_deviation / set_zero_pos_deviation_robot
设置零点偏移。
set_zero_pos_deviation
def set_zero_pos_deviation(socketFd, axis, shift):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
set_zero_pos_deviation_robot
def set_zero_pos_deviation_robot(socketFd, robotNum, axis, shift):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| axis | int | 需要偏移的轴号 |
| shift | double | 偏移量，范围 -360° < shift < 360° |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
get_single_cycle / get_single_cycle_robot
获取单圈值（编码器单圈位置）。
get_single_cycle
def get_single_cycle(socketFd, single_cycle):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参容器原地填充——先创建 nrc.VectorDouble() 传入，调用成功后用 list(obj) 读取。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
out_single_cycle = nrc.VectorDouble()
ret = nrc.get_single_cycle(fd, out_single_cycle)
print(ret, list(out_single_cycle)) # 容器用 list() 读取get_single_cycle_robot
def get_single_cycle_robot(socketFd, robotNum, single_cycle):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参容器原地填充——先创建 nrc.VectorDouble() 传入，调用成功后用 list(obj) 读取。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
out_single_cycle = nrc.VectorDouble()
ret = nrc.get_single_cycle_robot(fd, 1, out_single_cycle)
print(ret, list(out_single_cycle)) # 容器用 list() 读取参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| single_cycle | std::vector<double>& | 输出参数，单圈值数组，长度 7 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
get_four_point / get_four_point_robot
查询 4 点标定（SCARA 杆长标定）。
get_four_point
def get_four_point(socketFd, result):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参容器原地填充——先创建 nrc.VectorDouble() 传入，调用成功后用 list(obj) 读取。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
out_result = nrc.VectorDouble()
ret = nrc.get_four_point(fd, out_result)
print(ret, list(out_result)) # 容器用 list() 读取get_four_point_robot
def get_four_point_robot(socketFd, robotNum, result):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参容器原地填充——先创建 nrc.VectorDouble() 传入，调用成功后用 list(obj) 读取。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
out_result = nrc.VectorDouble()
ret = nrc.get_four_point_robot(fd, 1, out_result)
print(ret, list(out_result)) # 容器用 list() 读取参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| result | std::vector<double>& | 输出参数，4 点标定结果 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
set_four_point_mark / set_four_point_mark_robot
进行 4 点标记。
set_four_point_mark
def set_four_point_mark(socketFd, point, status):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
set_four_point_mark_robot
def set_four_point_mark_robot(socketFd, robotNum, point, status):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| point | int | 标记点位编号，范围 0-3 |
| status | int | 标记状态：0=取消标记，1=标记 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
four_point_calculation / four_point_calculation_robot
4 点标定计算。
four_point_calculation
def four_point_calculation(socketFd, L1, L2, result):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参容器原地填充——先创建 nrc.VectorDouble() 传入，调用成功后用 list(obj) 读取。
four_point_calculation_robot
def four_point_calculation_robot(socketFd, robotNum, L1, L2, result):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参容器原地填充——先创建 nrc.VectorDouble() 传入，调用成功后用 list(obj) 读取。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| L1 | double | 大臂杆长 |
| L2 | double | 小臂杆长 |
| result | std::vector<double>& | 输出参数，标定计算结果 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
set_result_for_DH / set_result_for_DH_robot
将 4 点标定计算的结果写入机器人 DH 参数。
set_result_for_DH
def set_result_for_DH(socketFd, apply):返回值：list，共 2 个元素，形如 [结果码, 数据...]。下标 0 是结果码，下标 1 是出参值。（实测为 list 而非 tuple，解包写法 ret, val = ... 同样可用。）
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret, val = nrc.set_result_for_DH(fd, 0)
print(ret, val) # 返回 list，可直接解包set_result_for_DH_robot
def set_result_for_DH_robot(socketFd, robotNum, apply):返回值：list，共 2 个元素，形如 [结果码, 数据...]。下标 0 是结果码，下标 1 是出参值。（实测为 list 而非 tuple，解包写法 ret, val = ... 同样可用。）
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret, val = nrc.set_result_for_DH_robot(fd, 1, 0)
print(ret, val) # 返回 list，可直接解包参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| apply | int& | 写入是否成功：成功/失败（1/0） |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
get_origin_coord_to_target_coord / get_origin_coord_to_target_coord_robot
坐标值坐标系转换（原坐标系转换为目标坐标系）。
get_origin_coord_to_target_coord
def get_origin_coord_to_target_coord(socketFd, originCoord, originPos, targetCoord, targetPos):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参容器原地填充——先创建 nrc.VectorDouble() 传入，调用成功后用 list(obj) 读取。
get_origin_coord_to_target_coord_robot
def get_origin_coord_to_target_coord_robot(socketFd, robotNum, originCoord, originPos, targetCoord, targetPos):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参容器原地填充——先创建 nrc.VectorDouble() 传入，调用成功后用 list(obj) 读取。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| originCoord | int | 原坐标系：0=关节，1=直角，2=工具，3=用户 |
| originPos | std::vector<double> | 要进行转换的坐标值，长度 7：关节取值范围 0-6[-10000,10000]；直角/工具/用户取值范围 0-2[-10000,10000]、3-6[-3.1416,3.1416]rad |
| targetCoord | int | 目标坐标系：0=关节，1=直角，2=工具，3=用户 |
| targetPos | std::vector<double>& | 输出参数，转换后的坐标值 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
1.10 机器人切换与参数
set_robot_switch
切换当前机器人。
def set_robot_switch(socketFd, robot):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robot | int | 切换到的机器人编号 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
get_robot_switch
获取当前机器人。
def get_robot_switch(socketFd, robot):返回值：⚠️ 该接口在 Python 中不可调用。C++ 原型为标量引用出参（如 int&/double&），SWIG 生成的 Python 绑定无法从 Python 侧构造可绑定的实参，任何传参都会抛 TypeError: argument N of type 'int &'。这是当前 Python SDK 的限制，请改用 C++ SDK 调用该接口，或联系纳博特确认 Python 侧修复版本。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robot | int& | 输出参数，当前机器人编号 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
get_robot_dh_param / get_robot_dh_param_robot
获取当前机器人 DH 参数。
get_robot_dh_param
def get_robot_dh_param(socketFd, param):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参结构体原地填充——先创建 nrc.RobotDHParam() 传入，调用成功后按字段读取（如 obj.field；结构体不支持 list()）。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
out_param = nrc.RobotDHParam()
ret = nrc.get_robot_dh_param(fd, out_param)
print(ret, out_param.type, out_param.num) # 结构体按字段读取get_robot_dh_param_robot
def get_robot_dh_param_robot(socketFd, robotNum, param):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参结构体原地填充——先创建 nrc.RobotDHParam() 传入，调用成功后按字段读取（如 obj.field；结构体不支持 list()）。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
out_param = nrc.RobotDHParam()
ret = nrc.get_robot_dh_param_robot(fd, 1, out_param)
print(ret, out_param.type, out_param.num) # 结构体按字段读取参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| param | RobotDHParam& | 输出参数，DH 参数结构体 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
get_robot_joint_param / get_robot_joint_param_robot
获取当前机器人关节参数。
get_robot_joint_param
def get_robot_joint_param(socketFd, id, param):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参结构体原地填充——先创建 nrc.RobotJointParam() 传入，调用成功后按字段读取（如 obj.field；结构体不支持 list()）。
get_robot_joint_param_robot
def get_robot_joint_param_robot(socketFd, robotNum, id, param):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参结构体原地填充——先创建 nrc.RobotJointParam() 传入，调用成功后按字段读取（如 obj.field；结构体不支持 list()）。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| id | int | 关节编号，范围 [1,6] |
| param | RobotJointParam& | 输出参数，关节参数结构体 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
get_teachbox_connection_status / get_teachbox_connection_status_robot
查询示教盒连接状态。
get_teachbox_connection_status
def get_teachbox_connection_status(socketFd, connected):返回值：list，共 2 个元素 [结果码, bool] —— 如 [-2, False]。SWIG 把 C++ 的 bool& 出参转成了传值 bool 参数，出参值直接放在返回列表下标 1。调用示例：ret, connected = nrc.get_teachbox_connection_status(fd, False)（第二个实参传 False 占位，实际取值看返回值）。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret, val = nrc.get_teachbox_connection_status(fd, False)
print(ret, val) # 返回 [结果码, bool]get_teachbox_connection_status_robot
def get_teachbox_connection_status_robot(socketFd, robotNum, connected):返回值：list，共 2 个元素 [结果码, bool] —— 如 [-2, False]。SWIG 把 C++ 的 bool& 出参转成了传值 bool 参数，出参值直接放在返回列表下标 1。调用示例：ret, connected = nrc.get_teachbox_connection_status_robot(fd, False)（第二个实参传 False 占位，实际取值看返回值）。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret, val = nrc.get_teachbox_connection_status_robot(fd, 1, False)
print(ret, val) # 返回 [结果码, bool]参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| connected | bool& | 输出参数，示教盒连接状态 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
get_controller_id / get_controller_id_robot
获取控制器序列号 ID（char* 版本）。
get_controller_id
def get_controller_id(socketFd, id):返回值：int 结果码（0 成功，负数为错误码）。字符串出参以传值方式传入（C++ 侧为 std::string&，SWIG 未回填），返回值中取不到字符串内容。需要该字符串请使用 C++ SDK。
get_controller_id_robot
def get_controller_id_robot(socketFd, robotNum, id):返回值：int 结果码（0 成功，负数为错误码）。字符串出参以传值方式传入（C++ 侧为 std::string&，SWIG 未回填），返回值中取不到字符串内容。需要该字符串请使用 C++ SDK。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| id | char* | 输出参数，控制器序列号 ID |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
get_controller_id_csharp / get_controller_id_csharp_robot
获取控制器序列号 ID（std::vector<char> 版本，供 C# 使用）。
get_controller_id_csharp
def get_controller_id_csharp(socketFd, id):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参对象原地填充——先创建出参对象传入，调用成功后从该对象读取。
get_controller_id_csharp_robot
def get_controller_id_csharp_robot(socketFd, robotNum, id):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参对象原地填充——先创建出参对象传入，调用成功后从该对象读取。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| id | std::vector<char>& | 输出参数，控制器序列号 ID |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
1.11 传感器与电机数据
get_static_search_position / get_static_search_position_robot
获取静态寻位坐标。
get_static_search_position
def get_static_search_position(socketFd, fileid, tableid, delaytime, pos):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参容器原地填充——先创建 nrc.VectorDouble() 传入，调用成功后用 list(obj) 读取。
get_static_search_position_robot
def get_static_search_position_robot(socketFd, robotNum, fileid, tableid, delaytime, pos):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参容器原地填充——先创建 nrc.VectorDouble() 传入，调用成功后用 list(obj) 读取。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| fileid | int | 寻位文件号 |
| tableid | int | 寻位参数表号 |
| delaytime | int | 参数表延时 |
| pos | std::vector<double>& | 输出参数，寻位坐标 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
get_curretn_motor_torque / get_curretn_motor_torque_robot
获取当前电机扭矩。
get_curretn_motor_torque
def get_curretn_motor_torque(socketFd, motorTorque, motorTorqueSync):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参容器原地填充——先创建 nrc.VectorInt() 传入，调用成功后用 list(obj) 读取。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
out_motorTorque = nrc.VectorInt()
out_motorTorqueSync = nrc.VectorInt()
ret = nrc.get_curretn_motor_torque(fd, out_motorTorque, out_motorTorqueSync)
print(ret, list(out_motorTorqueSync)) # 容器用 list() 读取get_curretn_motor_torque_robot
def get_curretn_motor_torque_robot(socketFd, robotNum, motorTorque, motorTorqueSync):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参容器原地填充——先创建 nrc.VectorInt() 传入，调用成功后用 list(obj) 读取。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
out_motorTorque = nrc.VectorInt()
out_motorTorqueSync = nrc.VectorInt()
ret = nrc.get_curretn_motor_torque_robot(fd, 1, out_motorTorque, out_motorTorqueSync)
print(ret, list(out_motorTorqueSync)) # 容器用 list() 读取参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| motorTorque | std::vector<int>& | 输出参数，机器人扭矩，长度 7，单位 [%] |
| motorTorqueSync | std::vector<int>& | 输出参数，外部轴扭矩，长度 5，单位 [%] |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
get_curretn_motor_speed / get_curretn_motor_speed_robot
获取当前电机转速。
get_curretn_motor_speed
def get_curretn_motor_speed(socketFd, motorSpeed, motorSpeedSync):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参容器原地填充——先创建 nrc.VectorInt() 传入，调用成功后用 list(obj) 读取。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
out_motorSpeed = nrc.VectorInt()
out_motorSpeedSync = nrc.VectorInt()
ret = nrc.get_curretn_motor_speed(fd, out_motorSpeed, out_motorSpeedSync)
print(ret, list(out_motorSpeedSync)) # 容器用 list() 读取get_curretn_motor_speed_robot
def get_curretn_motor_speed_robot(socketFd, robotNum, motorSpeed, motorSpeedSync):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参容器原地填充——先创建 nrc.VectorInt() 传入，调用成功后用 list(obj) 读取。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
out_motorSpeed = nrc.VectorInt()
out_motorSpeedSync = nrc.VectorInt()
ret = nrc.get_curretn_motor_speed_robot(fd, 1, out_motorSpeed, out_motorSpeedSync)
print(ret, list(out_motorSpeedSync)) # 容器用 list() 读取参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| motorSpeed | std::vector<int>& | 输出参数，机器人电机转速，长度 7，单位 [RPM] |
| motorSpeedSync | std::vector<int>& | 输出参数，外部轴电机转速，长度 5，单位 [RPM] |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
get_curretn_motor_payload / get_curretn_motor_payload_robot
获取当前电机负载。
get_curretn_motor_payload
def get_curretn_motor_payload(socketFd, motorPayload, motorPayloadSync):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参容器原地填充——先创建 nrc.VectorDouble() 传入，调用成功后用 list(obj) 读取。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
out_motorPayload = nrc.VectorDouble()
out_motorPayloadSync = nrc.VectorDouble()
ret = nrc.get_curretn_motor_payload(fd, out_motorPayload, out_motorPayloadSync)
print(ret, list(out_motorPayloadSync)) # 容器用 list() 读取get_curretn_motor_payload_robot
def get_curretn_motor_payload_robot(socketFd, robotNum, motorPayload, motorPayloadSync):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参容器原地填充——先创建 nrc.VectorDouble() 传入，调用成功后用 list(obj) 读取。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
out_motorPayload = nrc.VectorDouble()
out_motorPayloadSync = nrc.VectorDouble()
ret = nrc.get_curretn_motor_payload_robot(fd, 1, out_motorPayload, out_motorPayloadSync)
print(ret, list(out_motorPayloadSync)) # 容器用 list() 读取参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| motorPayload | std::vector<double>& | 输出参数，机器人电机负载，长度 7，单位 [%] |
| motorPayloadSync | std::vector<double>& | 输出参数，外部轴电机负载，长度 5，单位 [%] |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
get_current_line_speed_and_joint_speed / get_current_line_speed_and_joint_speed_robot
获取当前末端线速度和轴速度。
get_current_line_speed_and_joint_speed
def get_current_line_speed_and_joint_speed(socketFd, lineSpeed, jointSpeed, jointSpeedSync):返回值：list，共 2 个元素，形如 [结果码, 数据...]。下标 0 是结果码，其余为各出参值（按 C++ 参数顺序）。（实测为 list 而非 tuple，解包写法 ret, val = ... 同样可用。）
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
out_jointSpeed = nrc.VectorDouble()
out_jointSpeedSync = nrc.VectorDouble()
ret = nrc.get_current_line_speed_and_joint_speed(fd, 0, out_jointSpeed, out_jointSpeedSync)
print(ret, list(out_jointSpeedSync)) # 容器用 list() 读取get_current_line_speed_and_joint_speed_robot
def get_current_line_speed_and_joint_speed_robot(socketFd, robotNum, lineSpeed, jointSpeed, jointSpeedSync):返回值：list，共 2 个元素，形如 [结果码, 数据...]。下标 0 是结果码，其余为各出参值（按 C++ 参数顺序）。（实测为 list 而非 tuple，解包写法 ret, val = ... 同样可用。）
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
out_jointSpeed = nrc.VectorDouble()
out_jointSpeedSync = nrc.VectorDouble()
ret = nrc.get_current_line_speed_and_joint_speed_robot(fd, 1, 0, out_jointSpeed, out_jointSpeedSync)
print(ret, list(out_jointSpeedSync)) # 容器用 list() 读取参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| lineSpeed | double& | 输出参数，末端线速度，单位 [mm/s] |
| jointSpeed | std::vector<double>& | 输出参数，关节速度，长度 5，单位 [°/s] |
| jointSpeedSync | std::vector<double>& | 输出参数，外部轴关节速度，长度 5，单位 [°/s] |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
1.12 运动控制
robot_start_jogging / robot_start_jogging_robot
开始点动。
robot_start_jogging
def robot_start_jogging(socketFd, axis, dir):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
robot_start_jogging_robot
def robot_start_jogging_robot(socketFd, robotNum, axis, dir):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| axis | int | 轴号 |
| dir | bool | 方向（true=正方向，false=反方向） |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
robot_stop_jogging / robot_stop_jogging_robot
停止点动。
robot_stop_jogging
def robot_stop_jogging(socketFd, axis):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
robot_stop_jogging_robot
def robot_stop_jogging_robot(socketFd, robotNum, axis):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| axis | int | 轴号 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
点动使用提示
- 前置条件：点动属于运动操作，需先完成伺服上电、机器人处于允许运动的运行状态（见上电流程示例），并确认急停已释放；
- 调用方式（重要）：点动为"保持式"——控制器要求 200ms 内再次调用
robot_start_jogging（同轴、同方向；重复调用幂等）才会持续运动，超过 200ms 未再次调用将自动停止；因此点动期间需按不超过 200ms 的周期（例如 50ms）持续重发，松开按键后调用robot_stop_jogging主动停止； - 速度：
robot_start_jogging无速度参数；点动速度由控制器侧配置（示教器【机器人参数 - 点动速度】中查看/修改，实际速度为"关节轴最大点动速度 × 全局速度"）。上位机 SDK 未提供点动专用的速度设置接口；相关速度接口见 §1.5「速度与模式控制」（set_speed/get_speed，设置/获取当前模式速度）； - 停止与换向：停止调用
robot_stop_jogging(socketFd, axis)；需要换向时先停止再反向启动； - 独立轴（外部轴）点动：见
independent_axis_jog。
robot_go_to_reset_position / robot_go_to_reset_position_robot
回到设定的复位点。
robot_go_to_reset_position
def robot_go_to_reset_position(socketFd):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret = nrc.robot_go_to_reset_position(fd)
print(ret)robot_go_to_reset_position_robot
def robot_go_to_reset_position_robot(socketFd, robotNum):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret = nrc.robot_go_to_reset_position_robot(fd, 1)
print(ret)参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
robot_go_home / robot_go_home_robot
回到设定的零点。
robot_go_home
def robot_go_home(socketFd):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret = nrc.robot_go_home(fd)
print(ret)robot_go_home_robot
def robot_go_home_robot(socketFd, robotNum):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret = nrc.robot_go_home_robot(fd, 1)
print(ret)参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
robot_movej / robot_movej_robot
关节运动（MoveJ）。关节空间点到点运动，速度快但路径不固定。
robot_movej
def robot_movej(socketFd, moveCmd):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
robot_movej_robot
def robot_movej_robot(socketFd, robotNum, moveCmd):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| moveCmd | MoveCmd | 运动指令参数 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
robot_movel / robot_movel_robot
直线运动（MoveL）。笛卡尔空间直线运动。
robot_movel
def robot_movel(socketFd, moveCmd):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
robot_movel_robot
def robot_movel_robot(socketFd, robotNum, moveCmd):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| moveCmd | MoveCmd | 运动指令参数 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
robot_extra_movej / robot_extra_movej_robot
外部轴关节运动。
robot_extra_movej
def robot_extra_movej(socketFd, moveCmd):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
robot_extra_movej_robot
def robot_extra_movej_robot(socketFd, robotNum, moveCmd):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| moveCmd | MoveCmd | 运动指令参数 |
robot_extra_movel / robot_extra_movel_robot
外部轴直线运动。
robot_extra_movel
def robot_extra_movel(socketFd, moveCmd):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
robot_extra_movel_robot
def robot_extra_movel_robot(socketFd, robotNum, moveCmd):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| moveCmd | MoveCmd | 运动指令参数 |
1.13 7000 端口功能（伺服跟踪）
get_robot_state / get_robot_state_robot
7000 端口查询状态。
get_robot_state
def get_robot_state(socketFd, param):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
get_robot_state_robot
def get_robot_state_robot(socketFd, robotNum, param):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 7000 端口连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| param | RobotState | 查询状态参数 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
robot_state_callback
7000 端口状态返回的回调函数。
def robot_state_callback(*args):返回值：未实测（该接口需要真实控制器环境），语义同 C++。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 7000 端口连接句柄 |
| function | void()(const char) | 状态回调函数 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
servo_move / servo_move_robot
外部点移动（伺服跟踪）。
servo_move
def servo_move(socketFd, servoMove):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
servo_move_robot
def servo_move_robot(socketFd, robotNum, servoMove):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 7000 端口连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| servoMove | ServoMovePara | 伺服运动参数 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
enable_servo_position_motion_control / enable_servo_position_motion_control_robot
开启/关闭伺服点位运动控制。
enable_servo_position_motion_control
def enable_servo_position_motion_control(socketFd, statue):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
enable_servo_position_motion_control_robot
def enable_servo_position_motion_control_robot(socketFd, robotNum, statue):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 7000 端口连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| statue | bool | 1=开启，0=关闭 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
servo_point_position_motion_control / servo_point_position_motion_control_robot
伺服点位运动控制。
servo_point_position_motion_control
def servo_point_position_motion_control(socketFd, servoMove):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
servo_point_position_motion_control_robot
def servo_point_position_motion_control_robot(socketFd, robotNum, servoMove):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 7000 端口连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| servoMove | ServoPointMovePara | 伺服点位运动参数 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
1.14 碰撞检测与拖拽
set_collision_para / set_collision_para_robot
设置碰撞检测阈值。
set_collision_para
def set_collision_para(socketFd, collisionpara):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
set_collision_para_robot
def set_collision_para_robot(socketFd, robotNum, collisionpara):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| collisionpara | CollisionPara | 碰撞检测参数结构体（含指令位置响应时间、误差允许时间、碰撞检测阈值（点动）、碰撞检测阈值（指令）、机器人轴数） |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
set_darg_mode / set_darg_mode_robot
设置拖拽示教的拖拽方式。
set_darg_mode
def set_darg_mode(socketFd, mode):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
set_darg_mode_robot
def set_darg_mode_robot(socketFd, robotNum, mode):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| mode | int | 拖拽模式：0=无，1=3D 鼠标，2=力矩模式，3=位置 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
set_position_dragParams / set_position_dragParams_robot
设置位置拖动参数（笛卡尔空间线速度限制和关节空间速度限制）。
set_position_dragParams
def set_position_dragParams(socketFd, param):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参结构体原地填充——先创建 nrc.DragParam() 传入，调用成功后按字段读取（如 obj.field；结构体不支持 list()）。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
out_param = nrc.DragParam()
ret = nrc.set_position_dragParams(fd, out_param)
print(ret, out_param.type, out_param.num) # 结构体按字段读取set_position_dragParams_robot
def set_position_dragParams_robot(socketFd, robotNum, param):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参结构体原地填充——先创建 nrc.DragParam() 传入，调用成功后按字段读取（如 obj.field；结构体不支持 list()）。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
out_param = nrc.DragParam()
ret = nrc.set_position_dragParams_robot(fd, 1, out_param)
print(ret, out_param.type, out_param.num) # 结构体按字段读取参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| param | DragParam& | 位置拖动参数结构体 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
get_drag_thread_is_end / get_drag_thread_is_end_robot
获取拖拽是否已结束。
get_drag_thread_is_end
def get_drag_thread_is_end(socketFd, endFlag):返回值：list，共 2 个元素 [结果码, bool] —— 如 [-2, False]。SWIG 把 C++ 的 bool& 出参转成了传值 bool 参数，出参值直接放在返回列表下标 1。调用示例：ret, connected = nrc.get_drag_thread_is_end(fd, False)（第二个实参传 False 占位，实际取值看返回值）。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret, val = nrc.get_drag_thread_is_end(fd, False)
print(ret, val) # 返回 [结果码, bool]get_drag_thread_is_end_robot
def get_drag_thread_is_end_robot(socketFd, robotNum, endFlag):返回值：list，共 2 个元素 [结果码, bool] —— 如 [-2, False]。SWIG 把 C++ 的 bool& 出参转成了传值 bool 参数，出参值直接放在返回列表下标 1。调用示例：ret, connected = nrc.get_drag_thread_is_end_robot(fd, False)（第二个实参传 False 占位，实际取值看返回值）。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret, val = nrc.get_drag_thread_is_end_robot(fd, 1, False)
print(ret, val) # 返回 [结果码, bool]参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| endFlag | bool& | 输出参数，拖拽结束标志位 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
1.15 独立轴控制
new_independent_axis_param / new_independent_axis_param_robot
新建独立轴参数。
new_independent_axis_param
def new_independent_axis_param(socketFd, axis_num):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
new_independent_axis_param_robot
def new_independent_axis_param_robot(socketFd, robotNum, axis_num):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| axis_num | int | 新建的独立轴数量 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
modify_independent_axis_param / modify_independent_axis_param_robot
修改独立轴参数（先新建再修改）。
modify_independent_axis_param
def modify_independent_axis_param(socketFd, param):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参结构体原地填充——先创建 nrc.IndependentAxisParam() 传入，调用成功后按字段读取（如 obj.field；结构体不支持 list()）。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
out_param = nrc.IndependentAxisParam()
ret = nrc.modify_independent_axis_param(fd, out_param)
print(ret, out_param.type, out_param.num) # 结构体按字段读取modify_independent_axis_param_robot
def modify_independent_axis_param_robot(socketFd, robotNum, param):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参结构体原地填充——先创建 nrc.IndependentAxisParam() 传入，调用成功后按字段读取（如 obj.field；结构体不支持 list()）。
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
out_param = nrc.IndependentAxisParam()
ret = nrc.modify_independent_axis_param_robot(fd, 1, out_param)
print(ret, out_param.type, out_param.num) # 结构体按字段读取参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| param | IndependentAxisParam& | 独立轴参数结构体 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
get_independent_axis_param / get_independent_axis_param_robot
获取独立轴参数。
get_independent_axis_param
def get_independent_axis_param(socketFd, num, param):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参结构体原地填充——先创建 nrc.IndependentAxisParam() 传入，调用成功后按字段读取（如 obj.field；结构体不支持 list()）。
get_independent_axis_param_robot
def get_independent_axis_param_robot(socketFd, robotNum, num, param):返回值：int 结果码（0 成功，负数为错误码）。数据通过出参结构体原地填充——先创建 nrc.IndependentAxisParam() 传入，调用成功后按字段读取（如 obj.field；结构体不支持 list()）。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| num | int | 独立轴编号 |
| param | IndependentAxisParam& | 输出参数，独立轴参数结构体 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
get_axis_sum / get_axis_sum_robot
获取独立轴总数。
get_axis_sum
def get_axis_sum(socketFd, sum):返回值：⚠️ 该接口在 Python 中不可调用。C++ 原型为标量引用出参（如 int&/double&），SWIG 生成的 Python 绑定无法从 Python 侧构造可绑定的实参，任何传参都会抛 TypeError: argument N of type 'int &'。这是当前 Python SDK 的限制，请改用 C++ SDK 调用该接口，或联系纳博特确认 Python 侧修复版本。
get_axis_sum_robot
def get_axis_sum_robot(socketFd, robotNum, sum):返回值：⚠️ 该接口在 Python 中不可调用。C++ 原型为标量引用出参（如 int&/double&），SWIG 生成的 Python 绑定无法从 Python 侧构造可绑定的实参，任何传参都会抛 TypeError: argument N of type 'int &'。这是当前 Python SDK 的限制，请改用 C++ SDK 调用该接口，或联系纳博特确认 Python 侧修复版本。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| sum | int& | 输出参数，独立轴总数 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
delete_axis_sum / delete_axis_sum_robot
删除某个独立轴。
delete_axis_sum
def delete_axis_sum(socketFd, num):返回值：list，共 2 个元素，形如 [结果码, 数据...]。下标 0 是结果码，下标 1 是出参值。（实测为 list 而非 tuple，解包写法 ret, val = ... 同样可用。）
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret, val = nrc.delete_axis_sum(fd, 0)
print(ret, val) # 返回 list，可直接解包delete_axis_sum_robot
def delete_axis_sum_robot(socketFd, robotNum, num):返回值：list，共 2 个元素，形如 [结果码, 数据...]。下标 0 是结果码，下标 1 是出参值。（实测为 list 而非 tuple，解包写法 ret, val = ... 同样可用。）
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret, val = nrc.delete_axis_sum_robot(fd, 1, 0)
print(ret, val) # 返回 list，可直接解包参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| num | int& | 将要删除的独立轴编号 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
get_axis_position / get_axis_position_robot
查询独立轴位置。
get_axis_position
def get_axis_position(socketFd, num, currentPos):返回值：⚠️ 该接口在 Python 中不可调用。C++ 原型为标量引用出参（如 int&/double&），SWIG 生成的 Python 绑定无法从 Python 侧构造可绑定的实参，任何传参都会抛 TypeError: argument N of type 'int &'。这是当前 Python SDK 的限制，请改用 C++ SDK 调用该接口，或联系纳博特确认 Python 侧修复版本。
get_axis_position_robot
def get_axis_position_robot(socketFd, robotNum, num, currentPos):返回值：⚠️ 该接口在 Python 中不可调用。C++ 原型为标量引用出参（如 int&/double&），SWIG 生成的 Python 绑定无法从 Python 侧构造可绑定的实参，任何传参都会抛 TypeError: argument N of type 'int &'。这是当前 Python SDK 的限制，请改用 C++ SDK 调用该接口，或联系纳博特确认 Python 侧修复版本。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| robotNum | int | 机器人编号 (1-4)，仅 _robot 版本 |
| num | int& | 要查询的独立轴 |
| currentPos | double& | 输出参数，独立轴当前位置 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
independent_axis_zero_calibration
独立轴零点标定。
def independent_axis_zero_calibration(socketFd, num):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| num | int | 要标定的独立轴 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
set_independent_axis_PV_run
独立控制轴 PV 运动（恒转速，仅支持外部轴）。
def set_independent_axis_PV_run(socketFd, param):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| param | IndependentAxisRun | 运动参数结构体（含速度、加减速等） |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
set_independent_axis_PV_stop
独立控制轴 PV 停止（仅支持外部轴）。
def set_independent_axis_PV_stop(socketFd, num):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| num | int | 轴编号 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
cancel_independent_axis_move
取消轴独立控制运动（仅支持外部轴）。
def cancel_independent_axis_move(socketFd, num):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| num | int | 轴编号 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
independent_axis_homing
独立轴回零。
def independent_axis_homing(socketFd, num):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| num | int | 轴编号 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
independent_axis_homing_stop
独立轴回零停止。
def independent_axis_homing_stop(socketFd, num):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| num | int | 轴编号 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
independent_axis_jog
独立轴点动。
def independent_axis_jog(socketFd, param):返回值：int 结果码（0 成功，负数为错误码）。本接口无数据出参。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 说明 |
|---|---|---|
| socketFd | SOCKETFD | 连接句柄 |
| param | IndependentAxisRun | 点动参数结构体 |
C++ 侧返回值描述：SUCCESS(0) 表示成功，负数表示失败。
1.16 机器人形态与可达性
get_robot_configuration / get_robot_configuration_robot
获取 4 轴 SCARA 机器人的形态。SCARA 机器人在运动学正逆解时存在多解情况，需要通过形态参数指定机器人当前的臂型配置。
get_robot_configuration
def get_robot_configuration(socketFd, configuration):返回值：list，共 2 个元素，形如 [结果码, 数据...]。下标 0 是结果码，下标 1 是出参值。（实测为 list 而非 tuple，解包写法 ret, val = ... 同样可用。）
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret, val = nrc.get_robot_configuration(fd, 0)
print(ret, val) # 返回 list，可直接解包get_robot_configuration_robot
def get_robot_configuration_robot(socketFd, robotNum, configuration):返回值：list，共 2 个元素，形如 [结果码, 数据...]。下标 0 是结果码，下标 1 是出参值。（实测为 list 而非 tuple，解包写法 ret, val = ... 同样可用。）
示例：
import nrc_interface as nrc
fd = nrc.connect_robot("192.168.1.13", "6001")
ret, val = nrc.get_robot_configuration_robot(fd, 1, 0)
print(ret, val) # 返回 list，可直接解包参数说明（与 C++ 一致）：
| 参数 | 类型 | 输入/输出 | 说明 |
|---|---|---|---|
| socketFd | SOCKETFD | 输入 | 连接句柄 |
| robotNum | int | 输入 | 机器人编号（仅 _robot 版本） |
| configuration | int& | 输出 | 机器人形态 |
C++ 侧返回值描述：- 0：成功
- 负数：失败
get_pos_reachable / get_pos_reachable_robot
判断指定点位在当前机器人工作空间内是否可达。该接口基于机器人运动学正逆解算法，验证目标点位是否存在有效的关节解。
get_pos_reachable
def get_pos_reachable(socketFd, pos, movetype, result):返回值：list，共 2 个元素 [结果码, bool] —— 如 [-2, False]。SWIG 把 C++ 的 bool& 出参转成了传值 bool 参数，出参值直接放在返回列表下标 1。调用示例：ret, connected = nrc.get_pos_reachable(fd, False)（第二个实参传 False 占位，实际取值看返回值）。
get_pos_reachable_robot
def get_pos_reachable_robot(socketFd, robotNum, pos, movetype, result):返回值：list，共 2 个元素 [结果码, bool] —— 如 [-2, False]。SWIG 把 C++ 的 bool& 出参转成了传值 bool 参数，出参值直接放在返回列表下标 1。调用示例：ret, connected = nrc.get_pos_reachable_robot(fd, False)（第二个实参传 False 占位，实际取值看返回值）。
参数说明（与 C++ 一致）：
| 参数 | 类型 | 输入/输出 | 说明 |
|---|---|---|---|
| socketFd | SOCKETFD | 输入 | 连接句柄 |
| robotNum | int | 输入 | 机器人编号（仅 _robot 版本） |
| pos | std::vector<double> | 输入 | 目标点位坐标数据，长度 14 |
| movetype | std::string | 输入 | 运动方式："MOVJ"（关节运动）或 "MOVL"（直线运动） |
| result | bool& | 输出 | 点位是否可达 |
C++ 侧返回值描述：- 0：成功（查询操作本身成功）
- 负数：失败
注意
result 参数才是点位可达性的判断结果，true 表示可达，false 表示不可达。函数返回值仅表示接口调用是否成功。