⚙ Development Guide > SDK > API > Data Structures

ArmControlOptions

ArmControlOptions contains all parameters used during robotic arm control and is defined as follows:

ArmControlOptions — Complete Definition of Robotic Arm Control Parameters

@dataclass
class ArmControlOptions(ValidatedDataclass):
    """
    Configuration options for robotic arm control.
    """

    eff: list[float] = vec(
        lambda: [8.0],
        elem_min=0.0,
        elem_max=20.0,
        doc="Joint efforts, equals to joint current limits (PVT)",
    )
    torque: list[float] = vec(
        lambda: [10.0],
        elem_min=0.0,
        elem_max=20.0,
        doc="Joint torques (MIT)",
    )
    kp: list[float] = vec(
        lambda: [0.1],
        elem_min=0.0,
        elem_max=5000.0,
        doc="Joint kp (MIT)",
    )
    kd: list[float] = vec(
        lambda: [0.1],
        elem_min=0.0,
        elem_max=5000.0,
        doc="Joint kd (MIT)",
    )
    eef_pos: float = scalar(0.0, min=-0.10, max=1.10)
    eef_eff: float = scalar(8.0, min=0.0, max=20.0)
    eef_torque: float = scalar(10.0, min=0.0, max=20.0)
    eef_kp: float = scalar(0.1, min=0.0, max=5000.0)
    eef_kd: float = scalar(0.1, min=0.0, max=5000.0)
    motion_type: Literal["ptp", "rrt_connect"] = "ptp"
    min_blend_radius: float = scalar(0.005, min=0.001, max=0.1)
    sampling_time: float = scalar(0.01, min=0.01, max=0.5)
    allow_blend_fail: bool = True
    velocity_scaling_factor: float = scalar(0.4, min=0.01, max=1.0)
    acceleration_scaling_factor: float = scalar(0.3, min=0.01, max=1.0)
    force_calc_lin: bool = False
    lin_hard_threshold: float = scalar(10.0, min=0.0, max=1e6)
    lin_interpolate_num: int = scalar(150, min=5, max=1000)
    circ_is_center: bool = False
    allow_planning_time: float = scalar(0.5, min=0.01, max=60.0)
    blocking: bool = False

    def __str__(self) -> str:
        n_d = 4
        max_len = 10
        parts = [
            f"eff={_fmt_seq(self.eff, n_d, max_len)}",
            f"torque={_fmt_seq(self.torque, n_d, max_len)}",
            f"kp={_fmt_seq(self.kp, n_d, max_len)}",
            f"kd={_fmt_seq(self.kd, n_d, max_len)}",
            f"eef_pos={_fmt_float(self.eef_pos, n_d)}",
            f"eef_eff={_fmt_float(self.eef_eff, n_d)}",
            f"eef_torque={_fmt_float(self.eef_torque, n_d)}",
            f"eef_kp={_fmt_float(self.eef_kp, n_d)}",
            f"eef_kd={_fmt_float(self.eef_kd, n_d)}",
            f"motion_type={self.motion_type}",
            f"sampling_time={_fmt_float(self.sampling_time, n_d)}",
            f"min_blend_radius={_fmt_float(self.min_blend_radius, n_d)}",
            f"allow_blend_fail={self.allow_blend_fail}",
            f"velocity_scaling_factor={_fmt_float(self.velocity_scaling_factor, n_d)}",
            f"acceleration_scaling_factor={_fmt_float(self.acceleration_scaling_factor, n_d)}",
            f"force_calc_lin={self.force_calc_lin}",
            f"lin_hard_threshold={_fmt_float(self.lin_hard_threshold, n_d)}",
            f"lin_interpolate_num={self.lin_interpolate_num}",
            f"circ_is_center={self.circ_is_center}",
            f"allow_planning_time={_fmt_float(self.allow_planning_time, n_d)}",
            f"blocking={self.blocking}",
        ]
        return f"ArmControlOptions({', '.join(parts)})"

Parameter	Related Control Mode	Notes
eff	(ARM) PVT	Robotic arm motor current threshold
torque	(ARM) MIT	Robotic arm motor torque
kp	(ARM) MIT	Robotic arm motor kp
kd	(ARM) MIT	Robotic arm motor kd
eef_pos	(ARM) SERVO	End-effector position
eef_eff	(EEF) PVT	End-effector current threshold
eef_torque	(EEF) MIT	End-effector torque
eef_kd	(EEF) MIT	End-effector kd
eef_kp	(EEF) MIT	End-effector kp
motion_type	PTP/RRT	Selects the planning strategy in Planning mode
sampling_time	PTP / LIN / WAYPOINT / CIRC / RRT	Trajectory sampling period (seconds)
allow_blend_fail	WAYPOINT	Whether planning continues after blending fails
velocity_scaling_factor	PTP / LIN / WAYPOINT / CIRC / RRT	Velocity scaling factor
acceleration_scaling_factor	PTP / LIN / WAYPOINT / CIRC / RRT	Acceleration scaling factor
force_calc_lin	LIN	Forces a Cartesian trajectory to be returned when a singularity is encountered; the target may not be reached
lin_hard_threshold	LIN	Hard threshold for linear deviation
lin_interpolate_num	LIN	Number of linear interpolation points
circ_is_center	CIRC	Whether path in CIRC is the center of the arc's circle
allow_planning_time	PTP / LIN / WAYPOINT / CIRC / RRT	Maximum planning time
blocking	ALL	Whether to run in blocking mode