弧焊 Python SDK 使用示例

文档约定

以下各节结构统一为：

1. 适用情况 — 何时需要本场景
2. 目标 — 做完后系统应处于的状态
3. 推荐步骤 — 顺序化操作要点；
4. 常用接口与类型 — 便于检索 SDK 符号，非完整参数表
5. 注意事项 — 常见易错点

通用编程约定

1. 通过 robot.arcwelding() 取得 ArcWelding 实例，在其上调用工艺参数与焊机相关接口；运动队列仍在 robot 上操作。
2. 各 API 均传入 ec 字典（调用前初始化为 {}），每次调用后检查 ec['ec'] 与 ec['message']。
3. 涉及「压队列再启动」的焊接轨迹，通常配合 xCoreSDK_python.MotionControlMode.NrtCommandMode 与 moveAppend / moveStart；与纯参数下发场景区分开。

公共代码前提（各场景「实现代码」共用）

以下与 SDK 包内 arcwelding_example.py 入口一致（含平台相关 import、arc_welding 获取与事件监视等）。

# -*- coding: utf-8 -*-
import platform
import time
import math
from datetime import timedelta

if platform.system() == "Windows":
    from Release.windows import xCoreSDK_python
    from Release.windows.xCoreSDK_python import arcwelding
    from Release.windows.xCoreSDK_python.EventInfoKey import ArcWeldState, MoveExecution
elif platform.system() == "Linux":
    from Release.linux import xCoreSDK_python
    from Release.linux.xCoreSDK_python import arcwelding
    from Release.linux.xCoreSDK_python.EventInfoKey import ArcWeldState, MoveExecution
else:
    raise ImportError("Unsupported operating system")

ArcWelding = arcwelding.ArcWelding

# 连接机器人后：
ec = {}
robot = xCoreSDK_python.xMateRobot("192.168.0.160")  # 按机型替换
arc_welding = robot.arcwelding()


def print_log(name: str, ec: dict) -> None:
    if ec.get("ec", 0) != 0:
        print(f"{name} failed: ec={ec.get('ec')}, {ec.get('message')}")


def print_info(msg) -> None:
    print(msg)

场景一：首次接机器人与焊机

适用情况 新工作站第一次跑弧焊程序，或更换焊机 / 总线配置后需要确认控制器与焊机侧就绪。

目标 机器人已连接；弧焊工艺包可用；焊机型号与通信参数与现场一致；必要时完成 IO 与 ENI 期望配置。

推荐步骤

关键步骤关系如下（与下文分步说明对应）：

1. connectToRobot 建立与控制器连接。

2. 用 getWelderStatus 查看焊机侧状态：若 state 为 "disabled" 等表示尚未建立有效连接；为 "ok" 等表示已就绪（具体枚举以接口说明为准）。

3. 若已连接：可用 getWelderSetting 读取当前协议、品牌 mfr、型号 model、电流规格 current_type 等。

4. 若要更换焊机或重配参数：先 disconnectFromWelder，再按下方 EtherCAT 或 模拟量 分支配置后重新 connectToWelder。

5. EtherCAT 焊机：需要setIsEniHaveWeld 需设为 true（与HMI上是否连接物理焊机等效），然后在HMI软件上上传该焊机对应的ENI文件。在 setWelder（或 WelderSetting）中设置 protocol 为 EtherCAT 对应取值（如 "ethercat"，以 SDK 约定为准）、mfr 为下表中的厂商键名、model 为下表中的型号键名、current_type 必须为该机型的 current_range 中的某一档（与工艺包一致）。若该机型还提供 wire_diameter、shielding_gas、program_number、dry_extension、firmware_version 等约束，则 setWelder 时相应字段只能取自下列允许集合。

   厂商 / 型号与电流档位（及可选约束）一览（下发时 mfr、model 字符串需与键名一致）：

{
  "aotai": {
    "RL/RPL": { "current_range": [350, 500, 630, 800] },
    "RP/RPH": { "current_range": [350, 500, 630, 800] }
  },
  "megmeet": {
    "Artsen Plus": { "current_range": [350, 400, 500] },
    "Artsen Pro": { "current_range": [350, 400, 500] },
    "Ehave2": { "current_range": [350, 500, 630] },
    "Artsen3": { "current_range": [400, 500] },
    "Dex2": { "current_range": [350, 400, 500] },
    "Dex2 Ultra": { "current_range": [400] },
    "Megwave": { "current_range": [350, 400, 500] },
    "Megwave 400AC": { "current_range": [400] },
    "MetaTig": { "current_range": [315, 400, 500] },
    "RevoTig": { "current_range": [315, 400, 500] }
  },
  "riland": {
    "TiTans Low Spatter": {
      "current_range": [500],
      "wire_diameter": [0.8, 1.0, 1.2, 1.6],
      "shielding_gas": ["CO2", "80%Ar+20%CO2"]
    },
    "TiTans DP": {
      "current_range": [400, 500, 600],
      "wire_diameter": [0.8, 1.0, 1.2, 1.6],
      "shielding_gas": ["CO2", "80%Ar+20%CO2"]
    }
  },
  "panasonic": {
    "GS6": {
      "current_range": [350, 500],
      "program_number": [1, 97],
      "dry_extension": [10, 12, 15, 20, 25, 30, 35]
    }
  },
  "tayor": {
    "RB-350P": { "current_range": [350] },
    "RB-500P": { "current_range": [500] }
  },
  "headux": {
    "headux": { "current_range": [550] }
  },
  "beijingtime": {
    "time": { "current_range": [1000] }
  },
  "hugong": {
    "NVPM": { "current_range": [500] }
  },
  "ewm": {
    "TIG": { "current_range": [1000], "program_number": [0, 15] },
    "Plasma": { "current_range": [1000], "program_number": [0, 15] },
    "Phoenix": { "current_range": [1000], "program_number": [0, 15] },
    "alpha Q": { "current_range": [1000], "program_number": [0, 15] }
  },
  "bohler": {
    "URANOS NX": {
      "current_range": [3000, 4000, 5000],
      "firmware_version": ["v.14-v.24", "v.25"]
    }
  },
  "esab": {
    "Aristo 500ix": { "current_range": [500] }
  }
}

示例（奥太 RL/RPL、500A 档）：mfr = "aotai"，model = "RL/RPL"，current_type = 500（须在 [350,500,630,800] 内）。

6. 模拟量焊机：须按顺序完成下面三步，再 setWelder：

   • ① IO 绑定：先调用 setIOSetting，将起弧、送丝、送丝回退、检气、电流/电压设定与回读、焊机就绪、故障等信号绑定到实际 DI/DO 或寄存器。 用 getIOSetting 进行核对。
   • ② 电流 / 电压曲线：使用 setCurrentCharacteristicCurveData、setVoltageCharacteristicCurveData（及需要时的 calculateCurrentCurve / calculateVoltageCurve）在控制器中建立曲线数据并命名。
   • ③ setWelder：协议设为模拟量（具体字符串以 SDK / 工艺包为准，如 "analog" 等）；品牌 mfr 只能为 "manual_welding" 或 "aotai"；型号 model 等与模拟量方案约定一致；current_file、voltage_file 填步骤 ② 中已下发的电流曲线数据名与电压曲线数据名。其余字段按接口说明使用默认值或留空。

7. 调用 connectToWelder 建立与焊机的连接并启用焊机功能；调试结束或更换焊机前可用 disconnectFromWelder。

实现代码

模拟量焊机配置见同文件 setIOSetting、setCharacteristicCurveData。

    print_info("enter SetWelderAndConnectExample")
    # 设置焊机（方式一）
    arc_welding.setWelder("ethercat", "aotai", "RL/RPL", 500, ec)
    print_log("setWelder", ec)

    # 设置焊机（方式二）
    welder_setting = arcwelding.WelderSetting()
    welder_setting.mfr = "aotai"
    welder_setting.model = "RL/RPL"
    welder_setting.protocol = "ethercat"
    welder_setting.current_type = 500
    welder_setting.current_file = "current1"  # 用于模拟量连接
    welder_setting.voltage_file = "voltage1"  # 用于模拟量连接
    welder_setting.wire_diameter = 1.0
    welder_setting.shielding_gas = "CO2"
    welder_setting.program_number = 10
    welder_setting.dry_extension = 15
    arc_welding.setWelder(welder_setting, ec)
    print_log("setWelder", ec)

    # 读取焊机设置
    welder_setting_ret = arc_welding.getWelderSetting(ec)
    print_log("getWelderSetting", ec)
    print_info(f"mfr: {welder_setting_ret.mfr}")
    print_info(f"model: {welder_setting_ret.model}")
    print_info(f"protocol: {welder_setting_ret.protocol}")
    print_info(f"current_type: {welder_setting_ret.current_type}")
    print_info(f"current_file: {welder_setting_ret.current_file}")
    print_info(f"voltage_file: {welder_setting_ret.voltage_file}")
    print_info(f"wire_diameter: {welder_setting_ret.wire_diameter}")
    print_info(f"shielding_gas: {welder_setting_ret.shielding_gas}")
    print_info(f"program_number: {welder_setting_ret.program_number}")
    print_info(f"dry_extension: {welder_setting_ret.dry_extension}")

    # 连接焊机
    arc_welding.connectToWelder(ec)
    print_log("connectToWelder", ec)

    # 断开焊机
    arc_welding.disconnectFromWelder(ec)
    print_log("disconnectFromWelder", ec)

    print_info("enter SetEniHaveWeldExample")
    # 读取是否连接物理焊机（ENI文件）
    eni_have_weld = arc_welding.isEniHaveWeld(ec)
    print_log("isEniHaveWeld", ec)
    print_info(f"eniHaveWeld: {eni_have_weld}")

    # 设置是否连接物理焊机
    arc_welding.setIsEniHaveWeld(True, ec)
    print_log("setIsEniHaveWeld", ec)

常用接口与类型

getWelderStatus、getWelderSetting、setWelder、WelderSetting、connectToWelder、disconnectFromWelder、isEniHaveWeld、setIsEniHaveWeld、setIOSetting、getIOSetting、IOSetting、IOData、setCurrentCharacteristicCurveData、setVoltageCharacteristicCurveData、getCurrentCharacteristicCurveData、getVoltageCharacteristicCurveData、calculateCurrentCurve、calculateVoltageCurve

注意事项

更换焊机参数时，若已在弧焊连接状态，想要切换焊机，需先断开焊机连接再改参。

场景二：设置焊接运行参数

适用情况 需要统一调整空运行笛卡尔速度、手动送/退丝速度、气体检测时间等与焊接过程相关的全局运行选项（与单条起弧/焊接命名数据不同）。

目标 ArcWeldRunningParam 已写入控制器，空运行、送退丝、无参检气等行为与现场习惯一致。

推荐步骤

1. 构造 ArcWeldRunningParam：按工艺包范围设置 test_run_speed（mm/s）、wire_feed_speed（m/min）、gas_detect_time（s）等（字段含义与取值范围见 附录：数据结构 中「运行参数 ArcWeldRunningParam」）。
2. 调用 setRunningParam 下发；用 getRunningParam 读回核对。
3. 无参重载 detectGas() 的检气持续时间与运行参数中的 gas_detect_time 相关；带时间与使能的重载则按调用传入（见 接口说明）。

实现代码

    print_info("enter SetRunningParamExample")
    # 下发运行参数
    running_param = arcwelding.ArcWeldRunningParam()
    running_param.test_run_speed = 200
    running_param.wire_feed_speed = 2
    running_param.gas_detect_time = 10
    arc_welding.setRunningParam(running_param, ec)
    print_log("setRunningParam", ec)

    # 读取运行参数
    running_param_ret = arc_welding.getRunningParam(ec)
    print_log("getRunningParam", ec)
    print_info(f"test_run_speed: {running_param_ret.test_run_speed}")
    print_info(f"wire_feed_speed: {running_param_ret.wire_feed_speed}")
    print_info(f"gas_detect_time: {running_param_ret.gas_detect_time}")

常用接口与类型

setRunningParam、getRunningParam、ArcWeldRunningParam、detectGas

注意事项

手动送/退丝速度 取决于焊机是否可以设置该功能

场景三：设置防碰撞（碰枪检测）

适用情况 现场使用碰枪 / 防撞 DI，需要由程序配置信号名、是否启用、屏蔽与倒计时，并在上位机或逻辑中订阅防撞状态。

目标 防碰撞参数已下发；可通过查询或事件回调获取 signal、enable、block、countdown 等与 HMI 或联锁一致。

推荐步骤

1. 确定用于防撞的 DI 信号名（如 "DI0_0"）。
2. 调用 setAnticollision(signal, enable, block, countdown)：enable 为是否启用，block 为屏蔽开关，countdown 为倒计时（秒级语义以工艺包为准）。
3. 需要界面或逻辑联动时，使用 getAnticollisionState 读取当前状态；或注册 setEventWatcher(xCoreSDK_python.Event.anticollisionState, callback, ec)，在回调中解析 xCoreSDK_python.EventInfoKey.AnticollisionState 各键（与 附录：数据结构 中 AnticollisionState 对应）。

实现代码

def PrintAnticollisionState(info):
    print_info("enter PrintAnticollisionState")
    signal = info["signal"]
    enable = info["enable"]
    block = info["block"]
    countdown = info["countdown"]
    print_info("anticollision: \n" + f"signale: {signal}\n" +
               f"enable: {enable}\n" + f"block: {block}\n" +
               f"countdown: {countdown}")

    robot.setEventWatcher(xCoreSDK_python.Event.anticollisionState,
                          PrintAnticollisionState, ec)
    print_log("setEventWatcher", ec)

    arc_welding.setAnticollision("DI0_2", True, False, 30, ec)
    print_log("setAnticollision", ec)

    ret = arc_welding.getAnticollisionState(ec)
    print_log("getAnticollisionState", ec)

    print_info("anticollision: \n" + f"signale: {ret.signal}\n" +
               f"enable: {ret.enable}\n" + f"block: {ret.block}\n" +
               f"countdown: {ret.countdown}")

常用接口与类型

setAnticollision、getAnticollisionState、xCoreSDK_python.Event.anticollisionState、xCoreSDK_python.EventInfoKey.AnticollisionState、setEventWatcher

注意事项

绑定的DI信号需要确保没有被其他系统功能占用

场景四：在程序中维护工艺参数

适用情况 希望由上位机或离线工具下发 / 修改起弧、焊接、收弧、摆动、间断焊等命名工艺数据，或与示教器 HMI 中已有参数名保持一致。

目标 控制器内保存在一组可引用的参数名，供后续 ArcOnCommand 等指令或示教程序使用。

推荐步骤

1. 构造对应结构体（如 ArcOnData、ArcData、ArcOffData、WeaveData、SegData 等），填写 name 及工艺字段。
2. 调用 setXxxData 写入；用 getXxxData(name, ec) 读回校验。
3. 删除单条用 removeXxxData(name)；批量删除可传入名称列表重载。
4. 对示教器已有名称：可先 get 再改字段后 set，实现覆盖或微调。

实现代码

以下按类分别摘录 setArcOnData（起弧）、setArcData（焊接）、setArcOffData（收弧）、setWeaveData（摆焊）、setSegData（间断焊）。代码摘自 arcwelding_example.py 中对应函数体（省略 def 行）；打印辅助逻辑见该文件内嵌的 print_arc_on_data 等局部函数。

    print_info("enter SetArcOnDataExample")
    # 下发ArcOnData默认值
    arc_on_data_default = arcwelding.ArcOnData()
    arc_welding.setArcOnData(arc_on_data_default, ec)
    print_log("setArcOnData", ec)

    # 下发ArcOnData自定义值
    arc_on_data_custom = arcwelding.ArcOnData()
    arc_on_data_custom.name = "Custom1_name"
    arc_on_data_custom.annotation = "Custom1_annotation"
    arc_on_data_custom.mode = "low_spatter"
    arc_on_data_custom.current_mode = "wire_feed"
    arc_on_data_custom.voltage_mode = "separate"
    arc_on_data_custom.current = 120
    arc_on_data_custom.voltage = 2
    arc_on_data_custom.hold_time = 200
    arc_on_data_custom.detect_time = 500
    arc_on_data_custom.confirm_time = 50
    arc_on_data_custom.preflow_time = 200
    arc_on_data_custom.prearc_time = 50
    arc_on_data_custom.slow_wire_feed_speed = 8
    arc_on_data_custom.pre_wirefeed_time = 10
    arc_on_data_custom.ramp_time = 100
    arc_on_data_custom.re_arcon.enable = True
    arc_on_data_custom.re_arcon.retry_time = 3
    arc_on_data_custom.re_arcon.wire_retract_delay_time = 0
    arc_on_data_custom.re_arcon.wire_retract_time = 100
    arc_on_data_custom.re_arcon.current_step = 10
    arc_on_data_custom.re_arcon.voltage_step = 0.1
    arc_on_data_custom.scratch_arcon.enable = False
    arc_on_data_custom.scratch_arcon.distance = 50
    arc_on_data_custom.scratch_arcon.back_speed = 10
    arc_on_data_custom.scratch_arcon.step = 5
    arc_welding.setArcOnData(arc_on_data_custom, ec)
    print_log("setArcOnData", ec)

    # 获取ArcOnData
    arc_on_data_default_ret = arc_welding.getArcOnData(
        arc_on_data_default.name, ec)
    print_log("getArcOnData", ec)
    arc_on_data_custom_ret = arc_welding.getArcOnData(arc_on_data_custom.name,
                                                      ec)
    print_log("getArcOnData", ec)

    # 打印ArcOnData
    def print_arc_on_data(data: arcwelding.ArcOnData):
        print_info(f"Name: {data.name}")
        print_info(f"Annotation: {data.annotation}")
        print_info(f"Mode: {data.mode}")
        print_info(f"Current Mode: {data.current_mode}")
        print_info(f"Voltage Mode: {data.voltage_mode}")
        print_info(f"Current: {data.current}")
        print_info(f"Voltage: {data.voltage}")
        print_info(f"Hold Time: {data.hold_time}")
        print_info(f"Detect Time: {data.detect_time}")
        print_info(f"Confirm Time: {data.confirm_time}")
        print_info(f"Preflow Time: {data.preflow_time}")
        print_info(f"Prearc Time: {data.prearc_time}")
        print_info(f"Slow Wire Feed Speed: {data.slow_wire_feed_speed}")
        print_info(f"Pre Wirefeed Time: {data.pre_wirefeed_time}")
        print_info(f"Ramp Time: {data.ramp_time}")

        print_info("Re Arc On Parameters:")
        print_info(f"  Enable: {data.re_arcon.enable}")
        print_info(f"  Retry Time: {data.re_arcon.retry_time}")
        print_info(
            f"  Wire Retract Delay Time: {data.re_arcon.wire_retract_delay_time}"
        )
        print_info(f"  Wire Retract Time: {data.re_arcon.wire_retract_time}")
        print_info(f"  Current Step: {data.re_arcon.current_step}")
        print_info(f"  Voltage Step: {data.re_arcon.voltage_step}")

        print_info("Scratch Arc On Parameters:")
        print_info(f"  Enable: {data.scratch_arcon.enable}")
        print_info(f"  Distance: {data.scratch_arcon.distance}")
        print_info(f"  Back Speed: {data.scratch_arcon.back_speed}")
        print_info(f"  Step: {data.scratch_arcon.step}")

    print_arc_on_data(arc_on_data_default_ret)
    print_arc_on_data(arc_on_data_custom_ret)

    # 删除参数
    arc_welding.removeArcOnData("default", ec)
    print_log("removeArcOnData", ec)
    arc_welding.removeArcOnData(["remove1", "remove2"], ec)
    print_log("removeArcOnData", ec)

    print_info("enter SetArcDataExample")
    # 下发ArcData默认值
    arc_data_default = arcwelding.ArcData()
    arc_welding.setArcData(arc_data_default, ec)
    print_log("setArcData", ec)

    # 下发ArcData自定义值
    arc_data_custom = arcwelding.ArcData()
    arc_data_custom.name = "Custom1_name"
    arc_data_custom.annotation = "Custom1_annotation"
    arc_data_custom.mode = "low_spatter"
    arc_data_custom.current_mode = "wire_feed"
    arc_data_custom.voltage_mode = "separate"
    arc_data_custom.current = 80
    arc_data_custom.voltage = 2
    arc_data_custom.weld_speed = 50
    arc_data_custom.ramp_time = 200
    arc_data_custom.arc_break_param.detect_time = 50
    arc_data_custom.arc_break_param.arc_break_option = "stop_and_alarm"
    arc_data_custom.arc_break_param.restart_back_distance = 0
    arc_welding.setArcData(arc_data_custom, ec)
    print_log("setArcData", ec)

    # 获取ArcData
    arc_data_default_ret = arc_welding.getArcData(arc_data_default.name, ec)
    print_log("getArcData", ec)
    arc_data_custom_ret = arc_welding.getArcData(arc_data_custom.name, ec)
    print_log("getArcData", ec)

    # 打印ArcData
    def print_arc_data(data: arcwelding.ArcData):
        print_info(f"Name: {data.name}")
        print_info(f"Annotation: {data.annotation}")
        print_info(f"Mode: {data.mode}")
        print_info(f"Current Mode: {data.current_mode}")
        print_info(f"Voltage Mode: {data.voltage_mode}")
        print_info(f"Current: {data.current}")
        print_info(f"Voltage: {data.voltage}")
        print_info(f"Weld Speed: {data.weld_speed}")
        print_info(f"Ramp Time: {data.ramp_time}")

        print_info("Arc Break Parameters:")
        print_info(f"  Detect Time: {data.arc_break_param.detect_time}")
        print_info(
            f"  Arc Break Option: {data.arc_break_param.arc_break_option}")
        print_info(
            f"  Restart Back Distance: {data.arc_break_param.restart_back_distance}"
        )

    print_arc_data(arc_data_default_ret)
    print_arc_data(arc_data_custom_ret)

    # 删除ArcData
    arc_welding.removeArcData("default", ec)
    print_log("removeArcData", ec)
    arc_welding.removeArcData(["remove1,remove2"], ec)
    print_log("removeArcData", ec)

    print_info("SetArcOffDataExample")
    # 下发ArcOffData
    arc_off_data_default = arcwelding.ArcOffData()  # 默认值
    arc_welding.setArcOffData(arc_off_data_default, ec)
    print_log("setArcOffData", ec)

    arc_off_data_custom = arcwelding.ArcOffData()  # 自定义值
    arc_off_data_custom.name = "Custom1_name"
    arc_off_data_custom.annotation = "Custom1_annotation"
    arc_off_data_custom.mode = "low_spatter"
    arc_off_data_custom.current_mode = "wire_feed"
    arc_off_data_custom.voltage_mode = "separate"
    arc_off_data_custom.current = 160
    arc_off_data_custom.voltage = 5
    arc_off_data_custom.hold_time = 200
    arc_off_data_custom.delay_gasoff_time = 200
    arc_off_data_custom.detect_time = 100
    arc_off_data_custom.retract_time = 80
    arc_off_data_custom.wire_stick_detection_time = 80
    arc_off_data_custom.anti_wire_stick_param.enable = False
    arc_off_data_custom.anti_wire_stick_param.current = 0
    arc_off_data_custom.anti_wire_stick_param.voltage = 0
    arc_off_data_custom.anti_wire_stick_param.time = 100
    arc_welding.setArcOffData(arc_off_data_custom, ec)
    print_log("setArcOffData", ec)

    # 获取ArcOffData
    arc_off_data_default_ret = arc_welding.getArcOffData(
        arc_off_data_default.name, ec)
    print_log("getArcOffData", ec)
    arc_off_data_custom_ret = arc_welding.getArcOffData(
        arc_off_data_custom.name, ec)
    print_log("getArcOffData", ec)

    # 打印ArcOffData
    def print_arc_off_data(data: arcwelding.ArcOffData):
        print_info(f"Name: {data.name}")
        print_info(f"Annotation: {data.annotation}")
        print_info(f"Mode: {data.mode}")
        print_info(f"Current Mode: {data.current_mode}")
        print_info(f"Voltage Mode: {data.voltage_mode}")
        print_info(f"Current: {data.current}")
        print_info(f"Voltage: {data.voltage}")
        print_info(f"Hold Time: {data.hold_time}")
        print_info(f"Delay Gas Off Time: {data.delay_gasoff_time}")
        print_info(f"Detect Time: {data.detect_time}")
        print_info(f"Retract Time: {data.retract_time}")
        print_info(
            f"Wire Stick Detection Time: {data.wire_stick_detection_time}")

        print_info("Anti Wire Stick Parameters:")
        print_info(f"  Enable: {data.anti_wire_stick_param.enable}")
        print_info(f"  Current: {data.anti_wire_stick_param.current}")
        print_info(f"  Voltage: {data.anti_wire_stick_param.voltage}")
        print_info(f"  Time: {data.anti_wire_stick_param.time}")

    print_arc_off_data(arc_off_data_default_ret)
    print_arc_off_data(arc_off_data_custom_ret)

    # 删除ArcOffData
    arc_welding.removeArcOffData("default", ec)
    print_log("removeArcOffData", ec)
    arc_welding.removeArcOffData(["remove1,remove2"], ec)
    print_log("removeArcOffData", ec)

    print_info("enter SetWeaveDataExample")
    # 下发WeaveData
    weave_data_default = arcwelding.WeaveData()  # 默认值
    arc_welding.setWeaveData(weave_data_default, ec)
    print_log("setWeaveData", ec)

    weave_data_custom = arcwelding.WeaveData()  # 自定义值
    weave_data_custom.name = "Custom_name"
    weave_data_custom.annotation = "Custom_annotation"
    weave_data_custom.weaving_reference = "cycle"
    weave_data_custom.pattern = "sine"
    weave_data_custom.weave_length_frequency = 1
    weave_data_custom.amplitude.left = 2
    weave_data_custom.amplitude.right = 2
    weave_data_custom.dwell_type = "weave_stop"
    weave_data_custom.dwell_time = [10, 0, 20]
    weave_data_custom.radius = 5
    weave_data_custom.phase_invert = True
    weave_data_custom.elevation_type = "v_pattern"
    weave_data_custom.elevation_angle.left = 0
    weave_data_custom.elevation_angle.right = 0
    weave_data_custom.inclination_angle = 0
    weave_data_custom.acc = 1
    weave_data_custom.jerk = 10
    arc_welding.setWeaveData(weave_data_custom, ec)
    print_log("setWeaveData", ec)

    # 获取WeaveData
    weave_data_default_ret = arc_welding.getWeaveData(weave_data_default.name,
                                                      ec)
    print_log("getWeaveData", ec)
    weave_data_custom_ret = arc_welding.getWeaveData(weave_data_custom.name,
                                                     ec)
    print_log("getWeaveData", ec)

    # 打印WeaveData
    def print_weave_data(data):
        print_info(f"Name: {data.name}")
        print_info(f"Annotation: {data.annotation}")
        print_info(f"Weaving Reference: {data.weaving_reference}")
        print_info(f"Pattern: {data.pattern}")
        print_info(f"Weave Length Frequency: {data.weave_length_frequency}")

        print_info("Amplitude:")
        print_info(f"  Left: {data.amplitude.left}")
        print_info(f"  Right: {data.amplitude.right}")

        print_info(f"Dwell Type: {data.dwell_type}")
        print_info(
            f"Dwell Time: {data.dwell_time[0]}, {data.dwell_time[1]}, {data.dwell_time[2]}"
        )
        print_info(f"Radius: {data.radius}")
        print_info(f"Phase Invert: {data.phase_invert}")
        print_info(f"Elevation Type: {data.elevation_type}")

        print_info("Elevation Angle:")
        print_info(f"  Left: {data.elevation_angle.left}")
        print_info(f"  Right: {data.elevation_angle.right}")

        print_info(f"Inclination Angle: {data.inclination_angle}")
        print_info(f"Acc: {data.acc}")
        print_info(f"Jerk: {data.jerk}")

    print_weave_data(weave_data_default_ret)
    print_weave_data(weave_data_custom_ret)

    # 删除WeaveData
    arc_welding.removeWeaveData("default", ec)
    print_log("removeWeaveData", ec)
    arc_welding.removeWeaveData(["remove1", "remove2"], ec)
    print_log("removeWeaveData", ec)

    print_info("enter SetSegDataExample")
    # 下发SegData
    seg_data_default = arcwelding.SegData()  # 默认值
    arc_welding.setSegData(seg_data_default, ec)
    print_log("setSegData", ec)

    seg_data_custom = arcwelding.SegData()  # 自定义值
    seg_data_custom.name = "Custom_name"
    seg_data_custom.annotation = "Custom_annotation"
    seg_data_custom.seg_type = "normal"
    seg_data_custom.non_welded_speed = "v10"
    seg_data_custom.welded_distance = 10
    seg_data_custom.non_welded_distance = 20
    arc_welding.setSegData(seg_data_custom, ec)
    print_log("setSegData", ec)

    # 获取SegData
    seg_data_default_ret = arc_welding.getSegData("default", ec)
    print_log("getSegData", ec)
    seg_data_custom_ret = arc_welding.getSegData(seg_data_custom.name, ec)
    print_log("getSegData", ec)

    # 打印SegData
    def print_seg_data(data: arcwelding.SegData):
        print_info(f"Name: {data.name}")
        print_info(f"Annotation: {data.annotation}")
        print_info(f"Segment Type: {data.seg_type}")
        print_info(f"Non-Welded Speed: {data.non_welded_speed}")
        print_info(f"Welded Distance: {data.welded_distance}")
        print_info(f"Non-Welded Distance: {data.non_welded_distance}")

    print_seg_data(seg_data_default_ret)
    print_seg_data(seg_data_custom_ret)

    # 删除SegData
    arc_welding.removeSegData("default", ec)
    print_log("removeSegData", ec)
    arc_welding.removeSegData(["remove1", "remove2"], ec)
    print_log("removeSegData", ec)

常用接口与类型

按「设置 / 读取 / 删除」分组的命名工艺数据接口如下（签名与重载详见 接口说明、附录：方法）。

• 起弧 / 焊接 / 收弧 / 摆焊 / 间断焊
  setArcOnData / getArcOnData / removeArcOnData setArcData / getArcData / removeArcData、enableArcData
setArcOffData / getArcOffData / removeArcOffData
setWeaveData / getWeaveData / removeWeaveData
setSegData / getSegData / removeSegData
setWeaveAdaptiveData / getWeaveAdaptiveData

• 多层多道
  setLayerData / getLayerData / removeLayerData
setLayerCout、MpmlPathCheck、GetLayerStartPoint

• 激光跟踪 / 激光寻位（命名参数）
  setLaserTrackData / getLaserTrackData / removeLaserTrackData
setLaserSearchData / getLaserSearchData / removeLaserSearchData

• 电弧跟踪（命名参数）
  setArcTrackParam / getArcTrackParam / removeArcTrackParam

• 电流 / 电压特性曲线（命名曲线数据）
  setCurrentCharacteristicCurveData / getCurrentCharacteristicCurveData
setVoltageCharacteristicCurveData / getVoltageCharacteristicCurveData
calculateCurrentCurve、calculateVoltageCurve（仅计算、不落库）

注意事项

按名读取不存在的参数时，控制器可能返回约定错误码（如 -272），需在逻辑中处理。

场景五：选择焊接模式，并对照手动 / 自动行为

适用情况 需要空运行验轨迹、仿真验节拍与摆动、或实焊出弧，并理解示教器手动单步、手动连续、自动下的差异（起弧与否、速度滑条、间断焊、摆焊、电弧跟踪等）。

目标 当前焊接模式与产线阶段匹配（调试 → 仿真 → 实焊）。

推荐步骤

1. 调用 setWeldMode，在 WeldMode::TestRun（空运行）、Simu（仿真）、Real（实焊）之间切换。
2. 用 getWeldMode 读回确认。
3. 结合现场示教器运行方式，对照下表理解现象（与工艺包说明一致）。

实现代码

    print_separator("enter SetWeldModeExample")

    weld_mode = arcwelding.WeldMode.TestRun
    arc_welding.setWeldMode(weld_mode, ec)
    print_log("setWeldMode", ec)
    weld_mode_ret = arc_welding.getWeldMode(ec)
    print_log("getWeldMode", ec)
    print_info(f"set: TestRun, return: {weld_mode_ret.name}")
    time.sleep(1)

    weld_mode = arcwelding.WeldMode.Simu
    arc_welding.setWeldMode(weld_mode, ec)
    print_log("setWeldMode", ec)
    weld_mode_ret = arc_welding.getWeldMode(ec)
    print_log("getWeldMode", ec)
    print_info(f"set: Simu, return: {weld_mode_ret.name}")
    time.sleep(1)

    weld_mode = arcwelding.WeldMode.Real
    arc_welding.setWeldMode(weld_mode, ec)
    print_log("setWeldMode", ec)
    weld_mode_ret = arc_welding.getWeldMode(ec)
    print_log("getWeldMode", ec)
    print_info(f"set: Real, return: {weld_mode_ret.name}")

焊接模式与运行方式组合（示意）

常用接口与类型

setWeldMode、getWeldMode、arcwelding.WeldMode

注意事项

场景六：典型焊缝——「起弧 → 直线/圆弧 焊接段 → 收弧」

适用情况 最常见的直线或圆弧焊缝：在非实时指令模式下，将普通运动与弧焊工艺指令按顺序压入同一队列并启动。

目标 机器人按序执行：接近段（可选）→ 起弧与焊接参数生效 → 带或不带摆动的焊接轨迹 → 收弧。

推荐步骤

1. 需要先通过场景一启用焊机
2. setMotionControlMode(NrtCommand, ec)。
3. 确认焊机已配置并 connectToWelder（与场景一一致）。
4. 构造 ArcOnCommand，绑定已下发的起弧参数名、焊接参数名（如与示教器同名）。
5. 构造焊接段：WMoveLCommand / WMoveCCommand 等；
6. 构造 ArcOffCommand 并绑定收弧参数名。
7. 使用同一队列 id 多次 moveAppend 按顺序入队；上电后 moveStart 执行。
8. 需要暂停 / 继续时，可配合 stop 与再次 moveStart（以运动控制文档为准）。

实现代码

print_info("enter ExampleCommand")
    # 以下点位基于CR7
    # 需要先启用焊机
    arc_welding.setWelder("ethercat", "aotai", "RL/RPL", 500, ec)  # 设置焊机
    print_log("setWelder", ec)
    arc_welding.connectToWelder(ec)  # 启用和连接焊机
    print_log("connectToWelder", ec)

    arc_welding.setArcOnData(arcwelding.ArcOnData(), ec)
    arc_welding.setArcData(arcwelding.ArcData(), ec)
    arc_welding.setArcOffData(arcwelding.ArcOffData(), ec)

    arcon = arcwelding.ArcOnCommand("default", "default")
    arcoff = arcwelding.ArcOffCommand("default")

    target = xCoreSDK_python.CartesianPosition(
        [0.315189, -0.15, 0.414397, -math.pi, 0.0, math.pi])
    wml = arcwelding.WMoveLCommand(target, 10, 1, "default")  # 直线摆动

    targetMC = xCoreSDK_python.CartesianPosition()
    targetMC.trans = [0.615167, 0.141585, 0.507386]
    targetMC.rpy = [180.000 * math.pi / 180, 0.0, -167.039 * math.pi / 180]

    auxMC = xCoreSDK_python.CartesianPosition()
    auxMC.trans = [0.583553, 0.134309, 0.628928]
    auxMC.rpy = [
        180.000 * math.pi / 180, 11.286 * math.pi / 180,
        -167.039 * math.pi / 180
    ]
    wmc = arcwelding.WMoveCCommand(targetMC, auxMC, 10, 1, "default")  # 圆弧摆动

    weave_data_default = arcwelding.WeaveData()  # 设置摆动参数
    weave_data_default.amplitude.left = 2
    weave_data_default.amplitude.right = 2
    weave_data_default.weave_length_frequency = 2
    arc_welding.setWeaveData(weave_data_default, ec)

    weaveon = arcwelding.WeaveOnCommand("default")
    weaveoff = arcwelding.WeaveOffCommand()

    robot.setMotionControlMode(
        xCoreSDK_python.MotionControlMode.NrtCommandMode, ec)
    print_log("setMotionControlMode", ec)

    id = xCoreSDK_python.PyString()
    absj = xCoreSDK_python.MoveAbsJCommand(
        target=xCoreSDK_python.JointPosition(
            [PI / 2, PI / 6, -PI / 2, 0, -PI / 3, 0]))
    robot.moveAppend(absj, id, ec)
    robot.moveStart(ec)
    wait_robot(robot, ec)

    robot.moveAppend(arcon, id, ec)
    print_log("moveAppend", ec)

    robot.moveAppend(weaveon, id, ec)
    print_log("moveAppend", ec)

    robot.moveAppend(wml, id, ec)
    print_log("moveAppend", ec)

    robot.moveAppend(weaveoff, id, ec)
    print_log("moveAppend", ec)

    robot.moveAppend(arcoff, id, ec)
    print_log("moveAppend", ec)

    robot.setPowerState(True, ec)
    print_log("setPowerState", ec)

    robot.moveStart(ec)
    print_log("moveStart", ec)

    robot.stop(ec)  # 暂停
    print_log("stop", ec)

    robot.moveStart(ec)  # 继续
    print_log("moveStart", ec)

常用接口与类型

ArcOnCommand、ArcOffCommand、WMoveLCommand、WMoveCCommand、moveAppend、moveStart、MoveLCommand

注意事项

点位、速度、Conf 需适配本机型。 mvoeStart() 是非阻塞接口，要注意避免直接退出程序。 在 arcon 和 arcoff 之前，必须要用普通的 MoveCommand 指令；在他们中间，必须要用 WMoveCommand。 在调用 moveAppend(arcon, id, ec); 时，需要保证控制器已经保存好arcon中对应的起弧参数和焊接参数，不要在这一行代码的上一行或者临近用 setArcOnData 保存数据，避免由于控制器的处理延迟导致调用报错。 如果是飞行起弧，就是 ArcOnData 中的提前起弧时间设置了不为0，则需要在 arcon 前面添加一条 MoveLCommand 指令。

场景七：焊接过程中使用 arc_set_opt（ArcSet）修改工艺参数

适用情况 已在起弧后的某一条焊缝上，希望某一段直线或圆弧改用另一套 arcdata，而不结束电弧、不拆程序。

目标 在压入队列的 WMoveLCommand / WMoveCCommand 等焊接运动上，通过 arc_set_opt 指定切换后的焊接参数名称。

推荐步骤

1. 预先 setArcData 维护多套命名工艺（如 arcdata1、arcdata2）。
2. 直线用 WMoveLCommand；圆弧用 WMoveCCommand，在指令成员上设置 arc_set_opt。

实现代码

print_info("enter ArcSetExample")
    # 以下点位基于SR5
    cmd_id = xCoreSDK_python.PyString()
    arc_on_command = arcwelding.ArcOnCommand()
    arc_off_command = arcwelding.ArcOffCommand()
    absj = xCoreSDK_python.MoveAbsJCommand(
        target=xCoreSDK_python.JointPosition(
            [0, math.pi / 6, -math.pi / 2, 0, -math.pi / 3, 0]),
        speed=1000)

    l = xCoreSDK_python.MoveLCommand(target=xCoreSDK_python.CartesianPosition(
        [0.614, 0.136, 0.389, -math.pi, 0, math.pi]),
                                     speed=500)
    wml_target1 = xCoreSDK_python.CartesianPosition(
        [0.553, -0.107, 0.309, -math.pi, 0, math.pi])
    wmovel1 = arcwelding.WMoveLCommand(target=wml_target1, speed=500)
    wml_target2 = xCoreSDK_python.CartesianPosition(
        [0.553, 0.107, 0.309, -math.pi, 0, math.pi])
    wmovel2 = arcwelding.WMoveLCommand(target=wml_target2, speed=500)
    wmovel2.arc_set_opt.arc_data = "arcdata1"
    wmovel2.arc_set_opt.ref_start = True
    wmovel2.arc_set_opt.distance = 80

    robot.setPowerState(True, ec)
    print_log("setPowerState", ec)

    robot.moveAppend(absj, cmd_id, ec)
    print_log("moveAppend", ec)

    robot.moveAppend(l, cmd_id, ec)
    print_log("moveAppend", ec)

    robot.moveAppend(arc_on_command, cmd_id, ec)
    print_log("moveAppend", ec)

    wmls = [wmovel1, wmovel2]
    robot.moveAppend(wmovel1, cmd_id, ec)
    robot.moveAppend(wmls, cmd_id, ec)
    print_log("moveAppend", ec)

    robot.moveAppend(arc_off_command, cmd_id, ec)
    print_log("moveAppend", ec)

    robot.moveStart(ec)
    print_log("moveStart", ec)

    input()
    robot.setPowerState(False, ec)
    print_log("setPowerState", ec)

常用接口与类型

WMoveLCommand::arc_set_opt、WMoveCCommand::arc_set_opt、setArcData

场景八：直线 / 圆弧耦合摆动焊接

适用情况 平角或立角等焊缝需要在直线段或圆弧段上叠加摆动（Weave），由工艺包按摆动数据名解析摆幅、频率等。

目标 摆动数据已下发并与焊接运动绑定；可用 WeaveOnCommand / WeaveOffCommand 包络多段。

推荐步骤

1. setWeaveData 写入摆动工艺名（如 weavedata1）。
2. 创建 WeaveOnCommand WeaveOffCommand。
3. 直线：构造 WMoveLCommand 后调用 setWeaveData("…", ec)，或使用带摆动索引的构造函数重载（以 SDK 为准）。
4. 圆弧：构造 WMoveCCommand，同样 setWeaveData；辅助点、目标点与速度须满足机型与工艺包约束。
5. 典型片段：ArcOnCommand → WeaveOnCommand → 若干 WMoveL / WMoveC → WeaveOffCommand → ArcOffCommand。

实现代码

print_info("enter ExampleCommand")
    # 以下点位基于CR7
    # 需要先启用焊机
    arc_welding.setWelder("ethercat", "aotai", "RL/RPL", 500, ec)  # 设置焊机
    print_log("setWelder", ec)
    arc_welding.connectToWelder(ec)  # 启用和连接焊机
    print_log("connectToWelder", ec)

    arc_welding.setArcOnData(arcwelding.ArcOnData(), ec)
    arc_welding.setArcData(arcwelding.ArcData(), ec)
    arc_welding.setArcOffData(arcwelding.ArcOffData(), ec)

    arcon = arcwelding.ArcOnCommand("default", "default")
    arcoff = arcwelding.ArcOffCommand("default")

    target = xCoreSDK_python.CartesianPosition(
        [0.315189, -0.15, 0.414397, -math.pi, 0.0, math.pi])
    wml = arcwelding.WMoveLCommand(target, 10, 1, "default")  # 直线摆动

    targetMC = xCoreSDK_python.CartesianPosition()
    targetMC.trans = [0.615167, 0.141585, 0.507386]
    targetMC.rpy = [180.000 * math.pi / 180, 0.0, -167.039 * math.pi / 180]

    auxMC = xCoreSDK_python.CartesianPosition()
    auxMC.trans = [0.583553, 0.134309, 0.628928]
    auxMC.rpy = [
        180.000 * math.pi / 180, 11.286 * math.pi / 180,
        -167.039 * math.pi / 180
    ]
    wmc = arcwelding.WMoveCCommand(targetMC, auxMC, 10, 1, "default")  # 圆弧摆动

    weave_data_default = arcwelding.WeaveData()  # 设置摆动参数
    weave_data_default.amplitude.left = 2
    weave_data_default.amplitude.right = 2
    weave_data_default.weave_length_frequency = 2
    arc_welding.setWeaveData(weave_data_default, ec)

    weaveon = arcwelding.WeaveOnCommand("default")
    weaveoff = arcwelding.WeaveOffCommand()

    robot.setMotionControlMode(
        xCoreSDK_python.MotionControlMode.NrtCommandMode, ec)
    print_log("setMotionControlMode", ec)

    id = xCoreSDK_python.PyString()
    absj = xCoreSDK_python.MoveAbsJCommand(
        target=xCoreSDK_python.JointPosition(
            [PI / 2, PI / 6, -PI / 2, 0, -PI / 3, 0]))
    robot.moveAppend(absj, id, ec)
    robot.moveStart(ec)
    wait_robot(robot, ec)

    robot.moveAppend(arcon, id, ec)
    print_log("moveAppend", ec)

    robot.moveAppend(weaveon, id, ec)
    print_log("moveAppend", ec)

    robot.moveAppend(wml, id, ec)
    print_log("moveAppend", ec)

    robot.moveAppend(weaveoff, id, ec)
    print_log("moveAppend", ec)

    robot.moveAppend(arcoff, id, ec)
    print_log("moveAppend", ec)

    robot.setPowerState(True, ec)
    print_log("setPowerState", ec)

    robot.moveStart(ec)
    print_log("moveStart", ec)

    robot.stop(ec)  # 暂停
    print_log("stop", ec)

    robot.moveStart(ec)  # 继续
    print_log("moveStart", ec)

常用接口与类型

setWeaveData、WMoveLCommand、WMoveCCommand、WeaveOnCommand、WeaveOffCommand

注意事项

1. 需要摆动的轨迹必须放在 WeaveOnCommand和WeaveOffCommand之间，如果只单独给WMoveLCommand、WMoveCCommand设置摆动参数则不会生效
2. 在WeaveOnCommand和WeaveOffCommand之间的轨迹如果不带摆动参数会默认执行WeaveOnCommand中的摆动参数

场景九：直线 / 圆弧耦合间断焊

适用情况 仅在部分轨迹上需要「焊—停—焊」节拍；不要求摆动，或摆动由其它段单独处理。

目标 在 SegOnCommand 与 SegOffCommand 之间，WMoveL / WMoveC 按 SegData 执行间断节奏；区间外为连续焊或普通焊接运动。

推荐步骤

1. setSegData 写入间断焊参数名（如 segdata1）。
2. 队列：ArcOnCommand →（可选空移或非间断段）→ SegOnCommand("segdata1") → 一条或多条直线/圆弧焊接运动 → SegOffCommand → 后续连续焊或收弧。

实现代码

    print_info("enter segOnExample")
    # 以下点位基于SR5
    # 根据起始轴角度，计算笛卡尔位姿
    drag_posture = [0, math.pi / 6, -math.pi / 2, 0, -math.pi / 3, 0]
    p_start = robot.model().calcFk(drag_posture, ec)
    print_info(f"start pose: {p_start}")

    # 设置间断焊参数
    seg_data = arcwelding.SegData()
    seg_data.name = "segdata1"
    seg_data.annotation = "segannotation"
    seg_data.seg_type = "normal"
    seg_data.non_welded_speed = "v5"
    seg_data.welded_distance = 15
    seg_data.non_welded_distance = 30
    arc_welding.setSegData(seg_data, ec)
    # 开始间断焊指令，设置间断焊参数为segdata1
    seg_on_cmd = arcwelding.SegOnCommand("segdata1")
    seg_off_cmd = arcwelding.SegOffCommand()
    # 几条焊接运动指令
    seg_wmovel0 = arcwelding.WMoveLCommand(target=p_start, speed=2000, zone=0)
    seg_wmovel0.offset.type = xCoreSDK_python.CartesianPositionOffsetType.offs
    seg_wmovel0.offset.frame.trans = [0, -0.11, -0.12]
    seg_wmovel1 = arcwelding.WMoveLCommand(target=p_start, speed=20, zone=0)
    seg_wmovel1.offset.type = xCoreSDK_python.CartesianPositionOffsetType.offs
    seg_wmovel1.offset.frame.trans = [0, 0.08, -0.02]
    seg_wmc = arcwelding.WMoveCCommand(target=p_start,
                                       aux=p_start,
                                       speed=10,
                                       zone=0)
    seg_wmc.targetOffset.type = xCoreSDK_python.CartesianPositionOffsetType.offs
    seg_wmc.targetOffset.frame.trans = [0, -0.05, 0.01]
    seg_wmc.auxOffset.type = xCoreSDK_python.CartesianPositionOffsetType.offs
    seg_wmc.auxOffset.frame.trans = [0, 0.070, 0]

    non_seg_wmovl = arcwelding.WMoveLCommand(target=p_start, speed=20, zone=1)
    non_seg_wmovl.offset.type = xCoreSDK_python.CartesianPositionOffsetType.offs
    non_seg_wmovl.offset.frame.trans = [-0.05, 0, 0]

    arc_on_cmd = arcwelding.ArcOnCommand("arcondata1", "arcdata1")
    arc_off_cmd = arcwelding.ArcOffCommand("arcoffdata1")
    absj = xCoreSDK_python.MoveAbsJCommand(
        target=xCoreSDK_python.JointPosition(
            [0, math.pi / 6, -math.pi / 2, 0, -math.pi / 3, 0]),
        speed=500)
    weave_on_command = arcwelding.WeaveOnCommand("weavedata1")
    weave_off_cmd = arcwelding.WeaveOffCommand()

    id = xCoreSDK_python.PyString()
    robot.setPowerState(True, ec)
    robot.moveAppend(absj, id, ec)
    robot.moveStart(ec)
    while True:
        time.sleep(1)
        st = robot.operationState(ec)
        if st == xCoreSDK_python.OperationState.idle or st == xCoreSDK_python.OperationState.unknown:
            break
    print_info("运动到初始点")

    robot.moveAppend(arc_on_cmd, id, ec)
    robot.moveAppend(weave_on_command, id, ec)
    robot.moveAppend(seg_on_cmd, id, ec)
    wmovels = [seg_wmovel0, seg_wmovel1]
    robot.moveAppend(wmovels, id, ec)
    robot.moveAppend(seg_wmc, id, ec)
    robot.moveAppend(seg_off_cmd, id, ec)
    robot.moveAppend(non_seg_wmovl, id, ec)
    robot.moveAppend(weave_off_cmd, id, ec)
    robot.moveAppend(arc_off_cmd, id, ec)
    robot.moveStart(ec)

常用接口与类型

setSegData、SegOnCommand、SegOffCommand、WMoveLCommand、WMoveCCommand

场景十：直线 / 圆弧耦合间断焊 + 摆动

适用情况 间断节拍与摆动同时作用在同一电弧区间。

目标 WeaveOn 包络与 SegOn～SegOff 区间在队列中顺序正确，且各 WMoveL / WMoveC 上 arc_set_opt、偏移等与现场标定一致。

推荐步骤

1. 同时完成 setWeaveData 与 setSegData。
2. 参考 segOnExample 的典型顺序：ArcOnCommand → WeaveOnCommand → 非间断的过渡 WMoveL（可选）→ SegOnCommand → 间断区间内的多条 WMoveL / WMoveC → SegOffCommand → 后续运动 → WeaveOffCommand → ArcOffCommand。
3. 若间断段与连续段工艺不同，在对应指令上分别设置 arc_set_opt。
4. 圆弧段目标点、辅助点偏移建议与示例一致地在指令的 offset / targetOffset 等成员上配置（以 SDK 类型存根 / 接口说明为准）。

实现代码

    print_info("enter segOnExample")
    # 以下点位基于SR5
    # 根据起始轴角度，计算笛卡尔位姿
    drag_posture = [0, math.pi / 6, -math.pi / 2, 0, -math.pi / 3, 0]
    p_start = robot.model().calcFk(drag_posture, ec)
    print_info(f"start pose: {p_start}")

    # 设置间断焊参数
    seg_data = arcwelding.SegData()
    seg_data.name = "segdata1"
    seg_data.annotation = "segannotation"
    seg_data.seg_type = "normal"
    seg_data.non_welded_speed = "v5"
    seg_data.welded_distance = 15
    seg_data.non_welded_distance = 30
    arc_welding.setSegData(seg_data, ec)
    # 开始间断焊指令，设置间断焊参数为segdata1
    seg_on_cmd = arcwelding.SegOnCommand("segdata1")
    seg_off_cmd = arcwelding.SegOffCommand()
    # 几条焊接运动指令
    seg_wmovel0 = arcwelding.WMoveLCommand(target=p_start, speed=2000, zone=0)
    seg_wmovel0.offset.type = xCoreSDK_python.CartesianPositionOffsetType.offs
    seg_wmovel0.offset.frame.trans = [0, -0.11, -0.12]
    seg_wmovel1 = arcwelding.WMoveLCommand(target=p_start, speed=20, zone=0)
    seg_wmovel1.offset.type = xCoreSDK_python.CartesianPositionOffsetType.offs
    seg_wmovel1.offset.frame.trans = [0, 0.08, -0.02]
    seg_wmc = arcwelding.WMoveCCommand(target=p_start,
                                       aux=p_start,
                                       speed=10,
                                       zone=0)
    seg_wmc.targetOffset.type = xCoreSDK_python.CartesianPositionOffsetType.offs
    seg_wmc.targetOffset.frame.trans = [0, -0.05, 0.01]
    seg_wmc.auxOffset.type = xCoreSDK_python.CartesianPositionOffsetType.offs
    seg_wmc.auxOffset.frame.trans = [0, 0.070, 0]

    non_seg_wmovl = arcwelding.WMoveLCommand(target=p_start, speed=20, zone=1)
    non_seg_wmovl.offset.type = xCoreSDK_python.CartesianPositionOffsetType.offs
    non_seg_wmovl.offset.frame.trans = [-0.05, 0, 0]

    arc_on_cmd = arcwelding.ArcOnCommand("arcondata1", "arcdata1")
    arc_off_cmd = arcwelding.ArcOffCommand("arcoffdata1")
    absj = xCoreSDK_python.MoveAbsJCommand(
        target=xCoreSDK_python.JointPosition(
            [0, math.pi / 6, -math.pi / 2, 0, -math.pi / 3, 0]),
        speed=500)
    weave_on_command = arcwelding.WeaveOnCommand("weavedata1")
    weave_off_cmd = arcwelding.WeaveOffCommand()

    id = xCoreSDK_python.PyString()
    robot.setPowerState(True, ec)
    robot.moveAppend(absj, id, ec)
    robot.moveStart(ec)
    while True:
        time.sleep(1)
        st = robot.operationState(ec)
        if st == xCoreSDK_python.OperationState.idle or st == xCoreSDK_python.OperationState.unknown:
            break
    print_info("运动到初始点")

    robot.moveAppend(arc_on_cmd, id, ec)
    robot.moveAppend(weave_on_command, id, ec)
    robot.moveAppend(seg_on_cmd, id, ec)
    wmovels = [seg_wmovel0, seg_wmovel1]
    robot.moveAppend(wmovels, id, ec)
    robot.moveAppend(seg_wmc, id, ec)
    robot.moveAppend(seg_off_cmd, id, ec)
    robot.moveAppend(non_seg_wmovl, id, ec)
    robot.moveAppend(weave_off_cmd, id, ec)
    robot.moveAppend(arc_off_cmd, id, ec)
    robot.moveStart(ec)

常用接口与类型

同场景八与场景九所列类型组合使用。

注意事项

场景十一：钟摆形轨迹焊接

适用情况 焊缝几何由工艺定义为钟摆形路径（专用钟摆运动指令）。

目标 正确使用 WMoveLPendulumCommand 的起点、辅助点、目标点及速度等参数；需要切换规范时在成员上设置 arc_set_opt。

推荐步骤

1. 按工艺包与示教数据填入 WMoveLPendulumCommand 各点（与 arcSetPendulumExample 一致）。
2. 与 ArcOnCommand / ArcOffCommand 组合方式与普通焊接运动相同，压入非实时队列后 moveStart。
3. 若同程序中还有普通摆焊，注意与场景八区分：钟摆为独立运动类型，一般不混用 WeaveOn 包络同一段钟摆（以工艺包说明为准）。

实现代码

# 示例 - 焊接钟摆过程中设置焊接参数（点位需按机型标定）
cmd_id = xCoreSDK_python.PyString()

arc_data = arcwelding.ArcData()
arc_data.name = "arcdata1"
arc_welding.setArcData(arc_data, ec)

arc_data.name = "arcdata2"
arc_data.current = 20
arc_data.voltage = 15
arc_welding.setArcData(arc_data, ec)

arc_data.name = "arcdata3"
arc_data.current = 100
arc_data.voltage = 20
arc_data.weld_speed = 15
arc_welding.setArcData(arc_data, ec)

arcon_data = arcwelding.ArcOnData()
arcon_data.name = "arcondata1"
arc_welding.setArcOnData(arcon_data, ec)

arcoff_data = arcwelding.ArcOffData()
arcoff_data.name = "arcoffdata1"
arc_welding.setArcOffData(arcoff_data, ec)

weave_data = arcwelding.WeaveData()
weave_data.weave_length_frequency = 3.5
weave_data.amplitude.left = 6
weave_data.amplitude.right = 4.5
arc_welding.setWeaveData(weave_data, ec)

arc_on_command = arcwelding.ArcOnCommand("arcondata1", "arcdata1")
arc_off_command = arcwelding.ArcOffCommand("arcoffdata1")

absj = xCoreSDK_python.MoveAbsJCommand(
    [0.168, 0.369, -0.883, -0.210, -0.637, -0.137], 1000)
start1 = xCoreSDK_python.CartesianPosition(
    [0.68015, -0.077702, 0.777555, -2.319, 1.112, -2.228])
start_aux1 = xCoreSDK_python.CartesianPosition(
    [0.672849, -0.0777043, 0.777555, -2.319, 1.112, -2.228])
target_aux1 = xCoreSDK_python.CartesianPosition(
    [0.647849, -0.0943, 0.750882, -2.319, 1.112, -2.228])
target1 = xCoreSDK_python.CartesianPosition(
    [0.647849, -0.09473, 0.747882, -2.319, 1.112, -2.228])
target_aux2 = xCoreSDK_python.CartesianPosition(
    [0.437346, -0.2597, 0.793403, -2.319, 1.112, -2.228])
target2 = xCoreSDK_python.CartesianPosition(
    [0.435346, -0.2597, 0.796403, -2.319, 1.112, -2.228])
target_aux3 = xCoreSDK_python.CartesianPosition(
    [0.6117849, -0.14534, 0.666882, -2.319, 1.112, -2.228])
target3 = xCoreSDK_python.CartesianPosition(
    [0.599849, -0.14574, 0.667882, -2.319, 1.112, -2.228])

l = xCoreSDK_python.MoveLCommand(start1, 500)
wp1 = arcwelding.WMoveLPendulumCommand(start_aux1, target1, target_aux1, 20, 0.5, 100, 2)
wp2 = arcwelding.WMoveLPendulumCommand(None, target2, target_aux2, 20, 3, 234, 1)
wp2.arc_set_opt.arc_data = "arcdata2"
wp2.arc_set_opt.ref_start = True
wp2.arc_set_opt.distance = 0
wp3 = arcwelding.WMoveLPendulumCommand(None, target3, target_aux3, -1, 3.1, 4, 5)
wp3.arc_set_opt.arc_data = "arcdata3"
wp3.arc_set_opt.ref_start = True
wp3.arc_set_opt.distance = 0

robot.setPowerState(True, ec)
robot.moveAppend(absj, cmd_id, ec)
robot.moveAppend(l, cmd_id, ec)
robot.moveAppend(arc_on_command, cmd_id, ec)
robot.moveAppend(wp1, cmd_id, ec)
robot.moveAppend(wp2, cmd_id, ec)
robot.moveAppend(wp3, cmd_id, ec)
robot.moveAppend(arc_off_command, cmd_id, ec)
robot.moveStart(ec)
input()
robot.setPowerState(False, ec)

常用接口与类型

WMoveLPendulumCommand、ArcSetOpt（arc_set_opt 成员）

场景十二：电弧跟踪

适用情况 焊接过程中需根据电弧传感修正横向或高度方向

目标 指定轨迹段使用某套 ArcTrackParam；其它段不传跟踪名即不跟踪。

推荐步骤

1. setArcTrackParam 下发跟踪参数名（如 arctrackdata1）。
2. 在 WMoveLCommand 等带摆动名的重载中传入跟踪数据名；圆弧若 SDK 提供同等重载，绑定方式相同（以类型存根 / 接口说明为准）。
3. 典型队列：ArcOnCommand → WeaveOnCommand → 多条带跟踪的焊接运动 → WeaveOffCommand → ArcOffCommand。
4. 等待运动结束并确认收弧完成（可结合场景十八事件订阅）。

实现代码

def arc_track_example(robot: xCoreSDK_python.BaseRobot,
                            arc_welding: ArcWelding, ec): 
    # 设置电弧跟踪参数
    param = arcwelding.ArcTrackParam()
    param.name = "arctrackdata1"
    param.annotation = "test1"
    param.delay_time = 5 # 其他的值类似设置就行，这里直接使用默认值
    arc_welding.setArcTrackParam(param,ec)

    # 获取对应的电弧跟踪参数
    param_get = arc_welding.getArcTrackParam(param.name, ec)
    print(f"name: {param_get.name} annotation: {param_get.annotation} delay_time: {param_get.delay_time}")

    # 本例验证时运行于NB4h-R580-3B(注意点位匹配)
    p0 = [0.357487, 0.000633967, 0.222628, 3.0, 0.0685018, 3.12448] 
    p1 = [0.357487, 0.143835, 0.222628, 3.13197, 0.0685018, 3.12448] 
    p2 = [0.456268, 0.000634313, 0.222628, 3.13197, 0.0685026, 3.12448] 
    p3 = [0.456268, 0.143835, 0.222628, 3.13197, 0.0685024, 3.12448] 
    p4 = [0.456268, -0.103198, 0.222628, 3.13197, 0.068502, 3.12448] 

    arcon = arcwelding.ArcOnCommand("arcondata1", "arcdata1")
    arcoff = arcwelding.ArcOffCommand("arcoffdata1")
    mj = xCoreSDK_python.MoveJCommand(p0, 100, 1)

    # 第一条，开启电弧跟踪，用跟踪参数arctrackdata1
    wml1 = arcwelding.WMoveLCommand(p1, 20, 1, "weavedata1", "arctrackdata1")
    # 第二条，开启电弧跟踪，用跟踪参数arctrackdata2
    wml2=arcwelding.WMoveLCommand (p2, 20, 1, "weavedata1", "arctrackdata2")
    # 第三条，电弧跟踪参数为空，不跟踪
    wml3=arcwelding.WMoveLCommand (p3, 20, 1, "weavedata1")
    # 第四条和第五条，开启电弧跟踪，用跟踪参数arctrackdata2
    wml4=arcwelding.WMoveLCommand (p4, 20, 1, "weavedata1", "arctrackdata2")
    wml5=arcwelding.WMoveLCommand (p3, 20, 1, "weavedata1", "arctrackdata2")
    # 第六条，不跟踪
    wml6=arcwelding.WMoveLCommand (p2, 20, 1, "weavedata1") # 直线摆动
    weaveon=arcwelding.WeaveOnCommand ("weavedata1")
    weaveoff=arcwelding.WeaveOffCommand()
    wmove_list = [wml1, wml2, wml3, wml4, wml5, wml6]

    id = xCoreSDK_python.PyString()
    move_id = xCoreSDK_python.PyString()
    robot.setPowerState(True, ec)
    robot.moveAppend(mj, move_id, ec)
    robot.moveAppend(arcon, id, ec) 
    if(ec["ec"]!=0):
        print(f"{inspect.currentframe().f_lineno}: {ec["message"]}")
    robot.moveAppend(weaveon, id, ec)
    if(ec["ec"]!=0):
        print(f"{inspect.currentframe().f_lineno}: {ec["message"]}")
    robot.moveAppend(wmove_list, move_id, ec)
    if(ec["ec"]!=0):
        print(f"{inspect.currentframe().f_lineno}: {ec["message"]}")
    robot.moveAppend(weaveoff, id, ec)
    if(ec["ec"]!=0):
        print(f"{inspect.currentframe().f_lineno}: {ec["message"]}")
    robot.moveAppend(arcoff, id, ec)
    if(ec["ec"]!=0):
        print(f"{inspect.currentframe().f_lineno}: {ec["message"]}")
    robot.moveStart(ec)
    if(ec["ec"]!=0):
        print(f"{inspect.currentframe().f_lineno}: {ec["message"]}")

    from move_example import waitForFinish
    waitForFinish(robot, move_id.content(), len(wmove_list) - 1)
    while -1 != robot.queryEventInfo(xCoreSDK_python.Event.arcWeldState)[xCoreSDK_python.EventInfoKey.ArcWeldState.ArcWelding]:
        # waiting for arc off
        time.sleep(0.01)  # 10 milliseconds
    print("Finish running")

常用接口与类型

setArcTrackParam、getArcTrackParam、WMoveLCommand（带跟踪参数的重载）、ArcOnCommand、WeaveOnCommand、WeaveOffCommand、ArcOffCommand

注意事项

跟踪效果与焊机、焊丝、电流波形及机型有关；点位需在本机重新标定。 开电弧跟踪的时候必须要开摆动

场景十三：激光寻位

适用情况 在焊接主程序前或中途，需要用激光测量得到焊缝或特征点的位姿修正量。

目标 LaserSearchData 已下发，executeLaserSearch 在约定超时内返回结果；手眼数据名与指令中引用一致。

推荐步骤

1. 传感器网络、手眼关系、设备连接等基础配置见场景十四（LaserSensorCfg、setHandeyeData、connLaserSensorDev 等）。
2. setLaserSearchData 维护寻位工艺名与工艺包约定字段。
3. 构造 LaserSearchCommand（手眼数据名、寻位数据名、搜索位姿、速度等），调用 executeLaserSearch；同步/异步、超时与线程安全由应用保证。

实现代码

# 保存手眼标定参数
    handeyedata0 = arcwelding.HandeyeData()
    handeyedata0.mode = True
    handeyedata0.xyz_abc = [29.456, -14.151, 70.047, 4.5006 / 180.0 * math.pi, 4.0438 / 180.0 * math.pi, -97.358 / 180.0 * math.pi]
    handeyedata0.name = "laserhandeyedata1"
    arc_welding.setHandeyeData(handeyedata0, ec)
    print(f"ec: {ec["ec"]}, {ec["message"]}")
    # 保存寻位参数
    laser_search_data = arcwelding.LaserSearchData()
    laser_search_data.name = "lasersearchdata1"
    laser_search_data.job_number =2
    laser_search_data.search_type ="point"
    laser_search_data.search_mode ="continuous"
    laser_search_data.step_length = 3
    laser_search_data.joint_type = "lap_joint"
    arc_welding.setLaserSearchData(laser_search_data, ec)
    print(f"ec: {ec["ec"]}, {ec["message"]}")

    laser_search_pos = xCoreSDK_python.CartesianPosition()
    laser_search_pos.rpy = [3.14, 0, 3.14]
    laser_search_pos.trans = [0.563, 0.3, 0.43]
    laser_search_cmd = arcwelding.LaserSearchCommand("laserhandeyedata1", "lasersearchdata1", laser_search_pos, 10, 0)
    is_found = False
    pos = xCoreSDK_python.CartesianPosition()
    ret = None
    robot.setPowerState(True, ec)

    # 示例中选择同步等待寻位结果，设置超时时间为 30 秒。可根据轨迹速度和长度来设置超时时间。
    timeout = 30
    # 二、寻位并运动
    robot.moveReset(ec)
    ret = arc_welding.executeLaserSearch(laser_search_cmd, True, timedelta(seconds=timeout), ec)
    print(f"ec: {ec["ec"]}, {ec["message"]}")
    is_found = ret[0]
    pos = ret[1]
    print(f"isFound: {is_found}, pos: {', '.join(map(str, pos.trans))}, rpy: {', '.join(map(str, pos.rpy))}")

常用接口与类型

setLaserSearchData、LaserSearchCommand、executeLaserSearch、HandeyeData（名在指令中引用）

场景十四：激光跟踪——传感器配置、连接与队列用法

适用情况 要在上位机维护激光 IP、周期、类型；连接设备；焊缝跟踪。

目标 设备可连接、可监控；跟踪段内 LaserTrackOnCommand～LaserTrackOffCommand 与焊接运动同队列。

推荐步骤（配置与连接）

1. 填写 LaserSensorCfg，setLaserSensorCfg；可选 setEventWatcher(xCoreSDK_python.Event.lasertrackState, …)。
2. connLaserSensorDev / disconnLaserSensorDev；不用时 removeLaserSensorCfg。
3. 手眼关系：setHandeyeData / getHandeyeData；自动标定：startHandeyeCalibration → calibratePoint → calibrateEnd。
4. 跟踪工艺名：setLaserTrackData（与工艺包字段一致）。

推荐步骤（焊缝跟踪队列）

1. 连接设备后 openLaserTrack("sensor1", ec)。
2. 队列：ArcOnCommand → LaserTrackOnCommand → WMoveL / WMoveC 等 → LaserTrackOffCommand → ArcOffCommand。
3. closeLaserTrack，再按规范 disconnLaserSensorDev。

实现代码

以下依次为同文件中的 PrintLaserSensorState、set_laser_sensor_state_watcher（供配置示例注册回调）、laser_track_example、laser_track_command_example（调用后检查 ec，运动完成可结合 move_example.waitForFinish）。

def PrintLaserSensorState(info):
    print_info("enter PrintLaserSensorState")
    device_name = info["device_name"]
    connect = info["connect"]
    laser_on = info["laser_state"]
    power_on = info["power_state"]  # 注意：明图传感器没有使能状态，这里的使能状态无效

    print_info("[激光跟踪器状态信息] 设备名称: " + device_name + " 连接:" +
               ("YES " if connect else "NO ") + "激光开启:" +
               ("YES " if laser_on else "NO ") + "使能开启:" +
               ("YES " if power_on else "NO "))

    print_info("enter SetLaserSensorStateWatcher")
    robot.setEventWatcher(xCoreSDK_python.Event.lasertrackState,
                          PrintLaserSensorState, ec)
    print_log("setEventWatcher", ec)

    print_info("enter LaserTrackExample")
    # 设置激光跟踪器配置信息
    cfg = arcwelding.LaserSensorCfg()
    cfg.name = "sensor1"
    cfg.ip = "192.168.110.92"
    cfg.port = 502
    cfg.overtime = 800
    cfg.communication_cycle = 60
    cfg.type = arcwelding.LaserSensorType.CRNT  # 创想传感器
    # cfg.type = arcwelding.LaserSensorType.SMART_IMAGE  # 明图传感器

    # 发送指令设置AddLaserSensorCfg
    arc_welding.setLaserSensorCfg(cfg, ec)
    print_log("setLaserSensorCfg", ec)

    # 查询设备配置信息
    cfg_get = arc_welding.getLaserSensorCfg(cfg.name, ec)
    print_log("getLaserSensorCfg", ec)
    print_info("name: " + cfg_get.name + "  ip:" + cfg_get.ip)

    # 设置传感器状态监控watch
    set_laser_sensor_state_watcher(robot, ec)

    # 连接激光跟踪器ConnLaserTrack
    arc_welding.connLaserSensorDev(cfg.name, ec)
    print_log("connLaserSensorDev", ec)

    # 开启焊缝跟踪器，开始获取激光传感器数据OpenLaserTrack
    arc_welding.openLaserTrack(cfg.name, ec)
    print_log("openLaserTrack", ec)

    # 关闭焊缝跟踪器CloseLaserTrack
    arc_welding.closeLaserTrack(cfg.name, ec)
    print_log("closeLaserTrack", ec)

    # 断开连接DisConnLaserTrack
    arc_welding.disconnLaserSensorDev(cfg.name, ec)
    print_log("disconnLaserSensorDev", ec)

    # 删除设备配置信息RemoveLaserSensorCfg
    arc_welding.removeLaserSensorCfg(cfg.name, ec)
    print_log("removeLaserSensorCfg", ec)

    # 设置手眼标定结果
    handeyedata0 = arcwelding.HandeyeData()
    handeyedata0.mode = True
    handeyedata0.xyz_abc = [
        29.456, -14.151, 70.047, 4.5006 / 180.0 * math.pi,
        4.0438 / 180.0 * math.pi, -97.358 / 180.0 * math.pi
    ]
    handeyedata0.name = "handeyedata0"
    arc_welding.setHandeyeData(handeyedata0, ec)
    print_log("setHandeyeData", ec)

    # 查询手眼标定结果
    name = "handeyedata0"
    handeyedata0_get = arc_welding.getHandeyeData(name, ec)
    print_log("getHandeyeData", ec)
    print_info(
        f"name: {handeyedata0_get.name}  xyz_abc: {handeyedata0_get.xyz_abc[0]},"
        f"{handeyedata0_get.xyz_abc[2]},{handeyedata0_get.xyz_abc[3]},"
        f"{handeyedata0_get.xyz_abc[4]},{handeyedata0_get.xyz_abc[5]}")

    # 删除手眼标定结果
    arc_welding.removeHandeyeData(name, ec)
    print_log("removeHandeyeData", ec)

# 先连接激光器
    # 设置激光跟踪器配置信息
    cfg = arcwelding.LaserSensorCfg()
    cfg.name = "sensor1"
    cfg.ip = "192.168.110.92"
    cfg.port = 502
    cfg.overtime = 800
    cfg.communication_cycle = 60
    cfg.type = arcwelding.LaserSensorType.CRNT  # 创想传感器

    arc_welding.setLaserSensorCfg(cfg, ec)
    print_log("setLaserSensorCfg", ec)

    # 设置传感器状态监控watch
    set_laser_sensor_state_watcher(robot, ec)

    arc_welding.connLaserSensorDev(cfg.name, ec)
    print_log("connLaserSensorDev", ec)
    time.sleep(2)

    laser_track_on_cmd = arcwelding.LaserTrackOnCommand(
    )  # 默认手眼标定参数和激光跟踪参数名为"default"
    laser_track_off_cmd = arcwelding.LaserTrackOffCommand()
    id = xCoreSDK_python.PyString()
    robot.setPowerState(True, ec)

    robot.moveAppend(laser_track_on_cmd, id, ec)
    robot.moveAppend(laser_track_off_cmd, id, ec)
    robot.moveStart(ec)
    print_log("moveStart", ec)

常用接口与类型

LaserSensorCfg、setLaserSensorCfg、connLaserSensorDev、openLaserTrack、closeLaserTrack、setLaserTrackData、LaserTrackOnCommand、LaserTrackOffCommand、GetLaserPos

注意事项

场景十五：多层多道与层道偏移

适用情况 同一焊缝截面需要多道堆叠，或每层起点/姿态按 LayerData 偏移。

目标 层道参数已下发；可选先做可达性校验，再在下料队列中用 OffsetOnCommand / OffsetOffCommand 包络各层轨迹。

推荐步骤

1. setLayerData 为每层道维护名称与偏移、辅助点等。
2. 使用 MpmlPathCheck 对路径点组、运动类型列表与层道列表做校验，收集不可达层名。
3. 需要时 GetLayerStartPoint 获取建议起弧位姿。
4. 队列中在对应层轨迹前插入 OffsetOnCommand(layerName)，层结束处 OffsetOffCommand。

实现代码

    print_info("enter LayerExample")
    # 设置多层多道参数
    layer_data = arcwelding.LayerData()
    layer_data.name = "layerdata1"
    layer_data.annotation = ""
    layer_data.start_offset = 10
    layer_data.end_offset = 10
    layer_data.y_offset = 5
    layer_data.z_offset = 5
    layer_data.travel_angle = 4
    layer_data.tilt_angle = -5
    arc_welding.setLayerData(layer_data, ec)

    # 以下点位基于XMC7-R850-B0X1A0
    p0 = [0.614, 0.136, 0.389, 3.14159, 0.0, 3.14159]
    p1 = [0.514, -0.136, 0.410, 3.14159, 0.0, 3.14159]
    p2 = [0.563, -0.147, 0.410, 3.14159, 0.0, 3.14159]
    p3 = [0.550, -0.127, 0.410, 3.14159, 0.0, 3.14159]
    p4 = [0.643, 0.10, 0.410, 3.14159, 0.0, 3.14159]
    p5 = [0.713, -0.0, 0.410, 3.14159, 0.0, 3.14159]

    # 几条运动指令
    mj = xCoreSDK_python.MoveJCommand(p0, 100, 1)
    ml = xCoreSDK_python.MoveLCommand(p1, 100, 1)

    # 直线摆动
    target2 = xCoreSDK_python.CartesianPosition(p2)
    wml1 = arcwelding.WMoveLCommand(target2, 20, 1, "default")

    target3 = xCoreSDK_python.CartesianPosition(p5)
    wml2 = arcwelding.WMoveLCommand(target3, 20, 1, "default")

    
    # 几条焊接指令
    # 开始偏移指令，设置多层多道偏移计算参数为layerdata1
    offset_on_cmd = arcwelding.OffsetOnCommand("layerdata1")
    offset_off_cmd = arcwelding.OffsetOffCommand()
    arc_on_cmd = arcwelding.ArcOnCommand("arcondata1", "arcdata1")
    arc_off_cmd = arcwelding.ArcOffCommand("arcoffdata1")
    weave_on_command = arcwelding.WeaveOnCommand("weavedata1")
    weave_off_cmd = arcwelding.WeaveOffCommand()
    change_layer_data_cmd = arcwelding.ChangeLayerDataCommand("layerdata1", 8, 2, -3, 3, 0, 0)

    id = xCoreSDK_python.PyString()
    robot.setPowerState(True, ec)
    robot.moveAppend(change_layer_data_cmd, id, ec)
    robot.moveAppend(mj, id, ec)
    print_info("运动到初始点")
    robot.moveAppend(offset_on_cmd, id, ec)
    robot.moveAppend(ml, id, ec)
    robot.moveAppend(arc_on_cmd, id, ec)
    robot.moveAppend(weave_on_command, id, ec)
    robot.moveAppend(wml1, id, ec)
    robot.moveAppend(wml2, id, ec)
    robot.moveAppend(weave_off_cmd, id, ec)
    robot.moveAppend(arc_off_cmd, id, ec)
    robot.moveAppend(offset_off_cmd, id, ec)
    robot.moveStart(ec)

常用接口与类型

setLayerData、getLayerData、removeLayerData、LayerData、MpmlPathCheck、GetLayerStartPoint、OffsetOnCommand、OffsetOffCommand

场景十六：整圆与复杂空间曲线（摆动 / 间断 / 跟踪可选）

适用情况 焊缝为整圆或 MoveCF 类曲线，且可能叠加摆动、间断焊或电弧跟踪。

目标 使用 WMoveCFCommand 等与工艺指令组合；具体组合顺序与注释中的多种模式以工艺验证为准。

推荐步骤

1. 将圆或曲线以工艺包要求的辅助点与目标点形式构造 WMoveCFCommand。
2. 按需 setWeaveData、setSegData、setArcTrackParam 后，在指令上绑定名称或在队列中插入 SegOnCommand 等。
3. 在仿真或空运行下验证轨迹与姿态，再切实焊。

实现代码

    print_info("enter WMoveCFExample")
    # 点位机型 XMC7-R850-W7G3B4C
    arcon = arcwelding.ArcOnCommand ("arcondata1", "arcdata1")
    arcoff = arcwelding.ArcOffCommand ("arcoffdata1")
    segon = arcwelding.SegOnCommand ("segdata1")
    segooff = arcwelding.SegOffCommand ()
    weaveon = arcwelding.WeaveOnCommand ("weavedata1")
    weaveoff = arcwelding.WeaveOffCommand ()
    p1point = [556.769126, 101.641184, 358.852436, 158.661084, -17.184105, -148.826026]
    p2point = [590.049781, 101.641177, 358.852421, 158.66108, -17.184102, -148.826024]
    p3point = [556.769146, 17.242862, 358.852448, 179.999964, -0.000009, -179.999957]
    p4point = [556.769126, 101.641184, 358.852436, 179.999964, -0.000009, -179.999957]
    p5point = [590.049781, 101.641177, 358.852421, 179.999964, -0.000009, -179.999957]
    p1 = xCoreSDK_python.CartesianPosition(rlPoint2sdkPoint(p1point))
    p2 = xCoreSDK_python.CartesianPosition(rlPoint2sdkPoint(p2point))
    p3 = xCoreSDK_python.CartesianPosition(rlPoint2sdkPoint(p3point))
    p4 = xCoreSDK_python.CartesianPosition(rlPoint2sdkPoint(p4point))
    p5 = xCoreSDK_python.CartesianPosition(rlPoint2sdkPoint(p5point))
    wml = arcwelding.WMoveLCommand(p3, 200, 1)
    wmcf = arcwelding.WMoveCFCommand(p2, p1, 300 / 180.0 * math.pi)

    # 设置旋转类型
    wmcf.rotType = xCoreSDK_python.MoveCFCommandRotType.constPose
    # wmcf.rotType = xCoreSDK_python.MoveCFCommandRotType.rotAxis
    # wmcf.rotType = xCoreSDK_python.MoveCFCommandRotType.fixedAxis

    id = xCoreSDK_python.PyString()

    # 单独整圆、搭配摆动/间断焊/电弧跟踪等组合见 arcwelding_example.py 内注释
    # robot.moveAppend(arcon, id, ec)
    # robot.moveAppend(wmcf, id, ec)
    # robot.moveAppend(arcoff, id, ec)
    # robot.moveStart(ec)

常用接口与类型

WMoveCFCommand、MoveCFCommandRotType（rotType 成员）

场景十七：现场辅助动作与焊机状态

适用情况 调枪、引弧前送丝 / 退丝 / 检气；短时点焊铆焊；读取焊机实时量或清报警；在不实际焊接时，通过 enableArcData 选择工作模式并将电流/电压模式与设定值下发至焊机，对照焊机面板核对已生效数据是否与上位机一致。

目标 不依赖完整焊接轨迹即可完成维护性动作；HMI 可展示焊机状态。

推荐步骤

1. 送丝、退丝、检气：调用 feedOnWire、feedBackWire、detectGas 等，持续时间需满足工艺包最小阈值（如大于 0.1 s）；停止动作使用对应重载中的使能参数（见附录方法）。
2. 铆焊：startWelding / stopWelding，区分一元化与分别模式等（见接口说明）。
3. 状态：getWelderStatus；报警可恢复时 clearWelderAlarm。
4. enableArcData：用于在焊机侧使能/生效一条焊接工艺数据（含工作模式、电流/电压模式及电流、电压等设定），该数据不会被保存。在不建立焊接过程的前提下调用后，对照焊机面板显示与上位机下发值是否一致，便于现场对表与联调（不能为虚拟机、须连接焊机等前提见下文代码注释）。

实现代码

以下依次为同文件中的 feedOnWire、feedBackWire、detectGas、getWelderState、exampleWelding、clearWelderAlarm、enableArcData。

    # 需要在启用焊机后执行
    print_info("enter FeedOnWireExample")
    time = 10
    # 送丝
    arc_welding.feedOnWire(time, True, ec)  # 送丝和停止送丝时间参数都要大于0.1
    print_log("feedOnWire", ec)

    # 停止送丝
    arc_welding.feedOnWire(time, False, ec)
    print_log("feedOnWire", ec)

    # 需要在启用焊机后执行
    print_info("enter FeedBackWireExample")
    time = 10
    # 退丝
    arc_welding.feedBackWire(time, True, ec)  # 退丝和停止退丝时间都要大于0.1
    print_log("feedBackWire", ec)
    # 停止退丝
    arc_welding.feedBackWire(time, False, ec)
    print_log("feedBackWire", ec)

    # 需要在启用焊机后执行
    print_info("enter DetectGasExample")
    time = 10
    # 检气
    arc_welding.detectGas(time, True, ec)  # 检气和停止检气时间参数都要大于0
    print_log("detectGas", ec)
    # 停止检气
    arc_welding.detectGas(time, False, ec)
    print_log("detectGas", ec)

    print_info("enter GetWelderStateExample")
    welder_state = arc_welding.getWelderStatus(ec)
    print_log("getWelderStatus", ec)
    print_info(f"state: {welder_state.state}")
    print_info(f"current: {welder_state.current}")
    print_info(f"voltage: {welder_state.voltage}")
    print_info(f"speed: {welder_state.speed}")
    print_info(f"welding_name: {welder_state.welding_name}")
    print_info(f"arc_welding: {welder_state.arc_welding}")
    print_info(f"running_error: {welder_state.running_error['message']}")
    print_info(f"distance: {welder_state.welding_distance}")
    print_info(f"path_number: {welder_state.welding_path_num}")
    print_info(f"welding_time: {welder_state.welding_time}")
    print_info(f"welding_wire_used: {welder_state.welding_wire_used}")
    print_info(f"welder_error_code: {welder_state.welder_error_code}")
    print_info(f"welder_ready: {welder_state.welder_ready}")

def example_welding(arc_welding: ArcWelding, ec):
    print_info("enter ExampleWelding")
    arc_welding.startWelding(100, 0, "unified", ec)  # 一元化模式
    print_log("startWelding", ec)

    arc_welding.startWelding(100, 0, "separate", ec)  # 分别模式
    print_log("startWelding", ec)

    arc_welding.stopWelding(ec)
    print_log("stopWelding", ec)

print_info("enter ClearWelderAlarmExample")
    arc_welding.clearWelderAlarm(ec)

def enable_arc_data(arc_welding: ArcWelding, ec):
    print_info("enter EnableArcData")
    # 不能为虚拟机, 并且需要连接焊机
    arc_data_custom = arcwelding.ArcData()
    arc_data_custom.name = "Custom1_name"
    arc_data_custom.annotation = "Custom1_annotation"
    arc_data_custom.mode = "low_spatter"
    arc_data_custom.current_mode = "wire_feed"
    arc_data_custom.voltage_mode = "separate"
    arc_data_custom.current = 80
    arc_data_custom.voltage = 2
    arc_data_custom.weld_speed = 50
    arc_data_custom.ramp_time = 200
    arc_data_custom.arc_break_param = arcwelding.ArcBreakParam()
    arc_data_custom.arc_break_param.detect_time = 50
    arc_data_custom.arc_break_param.arc_break_option = "stop_and_alarm"
    arc_data_custom.arc_break_param.restart_back_distance = 0
    arc_welding.enableArcData(arc_data_custom, ec)
    print_log("enableArcData", ec)

常用接口与类型

feedOnWire、feedBackWire、detectGas、startWelding、stopWelding、getWelderStatus、clearWelderAlarm、enableArcData（用途说明见上文推荐步骤第 4 条；示例见上文代码块）、FeedOnWireCommand、FeedBackWireCommand

场景十八：运行过程观测

适用情况 需要在程序中订阅焊接电流电压、弧焊状态、运动段完成等。

目标 异步回调或主动查询得到一致的状态快照；可按轨迹 id 与路点索引判断段结束。

推荐步骤

1. setEventWatcher(xCoreSDK_python.Event.arcWeldState, callback, ec)设置焊机状态回调， 解析 xCoreSDK_python.EventInfoKey.ArcWeldState 各键。
2. setEventWatcher(xCoreSDK_python.Event.moveExecution, ...) 或使用 queryEventInfo 轮询，结合业务定义的「段完成」条件（如轨迹 id + 路点索引）。
3. 收弧是否完成可结合弧焊状态中的「是否仍在焊接」等字段判断（以工艺包与 SDK 键名为准）。

实现代码

以下依次为 printWeldState、setArcWeldStateWatcher、queryWeldState、printMoveState、setMoveStateWatcher。

def PrintWeldState(info:dict):
    print_info("enter PrintWeldState")
    if (len(info) == 0):
        return
    current = info[ArcWeldState.Current]
    voltage = info[ArcWeldState.Voltage]
    state = info[ArcWeldState.State]
    speed = info[ArcWeldState.Speed]
    error = info[ArcWeldState.RunningError]
    welding_name = info[ArcWeldState.WeldingName]
    arc_welding = info[ArcWeldState.ArcWelding]
    print_info("[焊接状态] current: " + str(current) + ", voltage: " +
               str(voltage) + ", state: " + state + ", speed: " + str(speed))
    print_info("weldingName: " + welding_name + ", arc_welding: " +
               str(arc_welding))
    if info.get(ArcWeldState.WeldingDistance) is not None:
        distance = info[ArcWeldState.WeldingDistance]
        print_info("distance: "+  str(distance))
    if info.get(ArcWeldState.WeldingPathNum) is not None:
        pathNumber = info[ArcWeldState.WeldingPathNum]
        print_info("pathNumber: "+  str(pathNumber))
    if info.get(ArcWeldState.WeldingTime) is not None:
        weldingTime = info[ArcWeldState.WeldingTime]
        print_info("weldingTime: "+  str(weldingTime))
    if info.get(ArcWeldState.WeldingWireUsed) is not None:
        weldingWireUsed = info[ArcWeldState.WeldingWireUsed]
        print_info("weldingWireUsed: "+  str(weldingWireUsed))
    if info.get(ArcWeldState.WelderErrorCode) is not None:
        welderErrorCode = info[ArcWeldState.WelderErrorCode]
        print_info("welderErrorCode: "+  str(welderErrorCode))
    if info.get(ArcWeldState.WelderReady) is not None:
        welderReady = info[ArcWeldState.WelderReady]
        print_info("welderReady: "+  str(welderReady))
    print_info("error: " + error["message"])

    print_info("enter SetArcWeldStateWatcher")
    robot.setEventWatcher(xCoreSDK_python.Event.arcWeldState, PrintWeldState,
                          ec)
    print_log("setEventWatcher", ec)

    # 先调用robot.setEventWatcher(xCoreSDK_python.Event.arcWeldState, PrintWeldState,ec)
    # 与焊接状态监视一起用，容易为空
    print_info("enter QueryWeldStateExample")
    info = robot.queryEventInfo(xCoreSDK_python.Event.arcWeldState, ec)
    print_log("queryEventInfo", ec)
    PrintWeldState(info)

def PrintMoveState(info):
    print_info("enter PrintMoveState")
    print(f"{MoveExecution.ID}:{info[MoveExecution.ID]}")
    print(f"{MoveExecution.ReachTarget}:{info[MoveExecution.ReachTarget]}")
    print(f"{MoveExecution.WaypointIndex}:{info[MoveExecution.WaypointIndex]}")
    print(f"{MoveExecution.Error}:{info[MoveExecution.Error]}")
    print(f"{MoveExecution.Remark}:{info[MoveExecution.Remark]}")

    print_info("enter setMoveStateWatcher")
    robot.setEventWatcher(xCoreSDK_python.Event.moveExecution, PrintMoveState,
                          ec)
    print_log("setEventWatcher", ec)

常用接口与类型

setEventWatcher、queryEventInfo、xCoreSDK_python.Event.arcWeldState、xCoreSDK_python.Event.moveExecution、xCoreSDK_python.EventInfoKey.ArcWeldState、xCoreSDK_python.EventInfoKey.MoveExecution

注意事项

1. 焊机状态回调的周期是500ms

场景十九：其它几何与工艺辅助（按需查阅）

适用情况 三点建用户参考、焊机支持模式查询、焊接中 Jog 偏置等；

目标 在程序中完成辅助几何计算或读取焊机能力列表。

推荐步骤

1. 按业务调用 getRefBy3Points、getWelderWorkModes、weldOffsetJog 等；

实现代码

以下依次为 getRefBy3PointsExample、getWelderWorkModes、weldingJogOffsetExample。

def get_ref_by_3_points(arc_welding: ArcWelding, ec):
    print_info("enter get_ref_by_3_points")
    pos1 = xCoreSDK_python.CartesianPosition([0.55676914536239797, -0.15000000000000005, 0.35885244785437498, -3.1415926535897931, 3.8857805861880484e-16, -3.1415926535897931])
    pos2 = xCoreSDK_python.CartesianPosition([0.71096662191265758, -0.14999999687989679, 0.35885244769618885, -3.1415921387343229, 8.5631816663676866e-07, 3.1415926369370966])
    pos3 = xCoreSDK_python.CartesianPosition([0.71096662302702562, 0.0055997244168811289, 0.35885244730431071, -3.1415926429162764, 7.8093868108499471e-07, -3.1415918107904255])
    with_origin = False
    dir = arcwelding.DirType.X_Plus_Y_Plus
    ret = arc_welding.getRefBy3Points([pos1, pos2, pos3], with_origin, dir, ec)
    print_log("getRefBy3Points", ec)
    for p in ret.trans:
        print(p)
    for p in ret.rpy:
        print(p)

def get_welder_workmode(arc_welding: ArcWelding, ec):
    ret = arc_welding.getWelderWorkModes(ec)
    print_log("getWelderWorkMode", ec)
    print_info(f"welder work mode: {ret}")

def welding_jog_offset(arc_welding: ArcWelding, ec):
  arc_welding.weldOffsetJog(arcwelding.WeldOffsetJogDir.Y_PLUS,ec);
  arc_welding.weldOffsetJog(arcwelding.WeldOffsetJogDir.Y_MINUS,ec);
  arc_welding.weldOffsetJog(arcwelding.WeldOffsetJogDir.Z_PLUS,ec);
  arc_welding.weldOffsetJog(arcwelding.WeldOffsetJogDir.Z_MINUS,ec);
  print_log("weldingJogOffset", ec)

常用接口与类型

getRefBy3Points、getWelderWorkModes、weldOffsetJog

与详细文档的对应关系

需求	文档
接口列表与参数含义	接口说明
类型与数据结构	附录：类型、附录：数据结构
方法签名与重载细节	附录：方法
错误码与异常	错误码和异常