Motion client

Important

The version 1.0 of MotionClient is now deprecated and will be removed in a future release. Please use the new MotionClient version 2.0

Overview

The main classes to plan and execute trajectories with xamla_motion are xamla_motion.MoveGroup and xamla_motion.EndEffector. The difference between both classes is the space in which they operate. The xamla_motion.MoveGroup class plans and executes trajectories where the input is defined in joint space. Whereas the xamla_motion.EndEffector class plans and executes trajectories where the input is defined in cartesian/task space.

Example:

import asyncio

from pyquaternion import Quaternion
from xamla_motion.data_types import CartesianPath, JointPath, Pose
from xamla_motion.motion_client import EndEffector, MoveGroup
from xamla_motion.utility import register_asyncio_shutdown_handler

# functions for supervised executation


async def next(stepped_motion_client):
    while True:
        await asyncio.sleep(0.1)
        if stepped_motion_client.state:
            stepped_motion_client.step()
            print('progress {:5.2f} percent'.format(
                stepped_motion_client.state.progress))


async def run_supervised(stepped_motion_client):
    print('start supervised execution')

    task_next = asyncio.ensure_future(next(stepped_motion_client))

    await stepped_motion_client.action_done_future
    task_next.cancel()

    print('finished supervised execution')


def main():
    # create move group instance
    move_group = MoveGroup()
    # get default endeffector of the movegroup
    end_effector = move_group.get_end_effector()

    # create cartesian path and equivalent joint path
    t1 = [0.502522, 0.2580, 0.3670]
    q1 = Quaternion(w=0.304389, x=0.5272, y=0.68704, z=0.39666)

    t2 = [0.23795, 0.46845, 0.44505]
    q2 = Quaternion(w=0.212097, x=0.470916, y=0.720915, z=0.462096)

    t3 = [0.6089578, 0.3406782, 0.208865]
    q3 = Quaternion(w=0.231852, x=0.33222, y=0.746109, z=0.528387)

    pose_1 = Pose(t1, q1)
    pose_2 = Pose(t2, q2)
    pose_3 = Pose(t3, q3)

    cartesian_path = CartesianPath([pose_1, pose_2, pose_3])

    joint_path = end_effector.inverse_kinematics_many(cartesian_path,
                                                      False).path

    loop = asyncio.get_event_loop()
    register_asyncio_shutdown_handler(loop)

    async def example_moves():
        print('test MoveGroup class')
        print('----------------          move joints                 -------------------')
        await move_group.move_joints(joint_path)

        print('----------------      move joints collision free      -------------------')
        await move_group.move_joints_collision_free(joint_path)

        print('----------------        move joints supervised        -------------------')
        stepped_motion_client = move_group.move_joints_supervised(
            joint_path, 0.5)
        await run_supervised(stepped_motion_client)

        print('----------------move joints collision free supervised -------------------')
        stepped_motion_client = move_group.move_joints_collision_free_supervised(
            joint_path, 0.5)
        await run_supervised(stepped_motion_client)

        print('test EndEffector class')
        print('----------------           move poses                 -------------------')
        await end_effector.move_poses(cartesian_path)

        print('----------------        move poses collision free     -------------------')
        await end_effector.move_poses_collision_free(cartesian_path)

        print('----------------          move poses supervised       -------------------')
        stepped_motion_client = end_effector.move_poses_supervised(
            cartesian_path, None, 0.5)
        await run_supervised(stepped_motion_client)

        print('---------------- move poses collision free supervised -------------------')
        stepped_motion_client = end_effector.move_poses_collision_free_supervised(
            cartesian_path, None, 0.5)
        await run_supervised(stepped_motion_client)

    try:
        loop.run_until_complete(example_moves())
    finally:
        loop.close()


if __name__ == '__main__':
    main()

MoveGroup

class xamla_motion.MoveGroup(move_group_name=None, end_effector_name=None, motion_service=None)[source]

Class with encapsulate move functionality for a specific move group

set_default_end_effector(end_effector_name: str)[source]

Set one of the end effector from the list of available ones as default

get_end_effector(name: Union[None, str]) → EndEffector[source]

Get the end effector specified by name or the default end effector

get_current_joint_states() → JointStates[source]

Returns the current joint states of the move group joints

get_current_joint_positions() → JointValues[source]

Returns the current joint positions of the move group joints

plan_move_joints(

target: Union[JointValues, JointPath], velocity_scaling: Union[None, float]=None, collision_check: Union[None, bool]=None, max_deviation: Union[None, float]=None, acceleration_scaling: Union[None, float]=None

) -> Tuple[JointTrajectory, PlanParameters] Plans a trajectory from current state to target joint positions

plan_move_joints_collision_free(

target: Union[JointValues, JointPath], velocity_scaling: Union[None, float]=None, collision_check: Union[None, bool]=None, max_deviation: Union[None, float]=None, acceleration_scaling: Union[None, float]=None

) -> Tuple[JointTrajectory, PlanParameters] Plans a collision free trajectory from current to target joint positions.

move_joints(

target: Union[JointValues, JointPath], velocity_scaling: Union[None, float]=None, collision_check: Union[None, bool]=None, max_deviation: Union[None, float]=None, acceleration_scaling: Union[None, float]=None)

Asynchronous plan and execute joint trajectory

move_joints_supervised(

target: Union[JointValues, JointPath], velocity_scaling: Union[None, float]=None, collision_check: Union[None, bool]=None, max_deviation: Union[None, float]=None, acceleration_scaling: Union[None, float]=None

) -> SteppedMotionClient Plan joint trajectory and creates a supervised executor Create MoveJointsOperation for target joint positions

move_joints_collision_free(

target: Union[JointValues, JointPath], velocity_scaling: Union[None, float]=None, collision_check: Union[None, bool]=None, max_deviation: Union[None, float]=None, acceleration_scaling: Union[None, float]=None)

Asynchronous plan and execute collision free joint trajectory

move_joints_collision_free_supervised(

target: Union[JointValues, JointPath], velocity_scaling: Union[None, float]=None, collision_check: Union[None, bool]=None, max_deviation: Union[None, float]=None, acceleration_scaling: Union[None, float]=None

) -> SteppedMotionClient Plan collision free joint trajectory and creates a supervised executor

Initialize MoveGroup class

The initialization process is possible with different settings:

move_group_name and end_effector_name are None:

In this case the first available move group and its first end effector is selected automatically. If no move group or end_effector is available exception is raised.

move_group_name is defined and end_effector_name is none:

In this case the initialization routine tries to find the move group with requested name. If it is available create a instance for this move group and the first available end effector as default end effector. Else an exceptions is raised.

move_group is None and end_effector_name is defined:

In this case the initialization routine tries to find the move group with requested end effector. If it is available create a instance for this move group and the requested end effector as default end effector. Else an exceptions is raised.

move_group is defined and also end_effector_name is defined:

In this case the initialization routine tries to find the requested move group with requested end effector. If it is available create a instance for this move group and the requested end effector as default end effector. Else an exceptions is raised.

Parameters
  • move_group_name (Union[None, str]) – If defined name of the move group which this instance should represent

  • end_effector_name (Union[None, str]) – If defined name of the end_effector which should be used as default end_effector

  • motion_service (Union[None, MotionService]) – An instance of MotionService which is used to communicate with the motion server if None a new instance of MotionService is created

Raises
  • TypeError – If motion_service is not of type MotionService or If the other inputs are not str convertable

  • ServiceException – If necessary services to query available move groups and end effectors are not available

  • RuntTimeError – If requested move group or end effector not exist or are not available

acceleration_scaling

Current acceleration scaling value

acceleration_scalingfloat convertable

The acceleration scaling value is the value which was applied to the default accelerations to get the current accelerations limits. The default accelerations are maximal accelerations. The maximal accelerations are provided by the motion server and queried from it during the initialization process.

collision_check

bool If true the trajectory planing try to plan a collision free trajectory and before executing a trajectory a collision check is performed

Type

collision_check

default_plan_parameters

PlanParameters (read only) Instance of PlanParameters from which the limits and settings are used when no specific user input is given

Type

plan_parameters

default_task_space_plan_parameters

TaskSpacePlanParameters (read only) Instance of TaskSpacePlanParameters from which the limits and settings are used when no specific user input is given

Type

task_space_plan_parameters

end_effector_names

List[str] (read only) List of end effectors the move groups contains

Type

end_effector_names

get_current_joint_positions()[source]

Returns the current joint positions of the move group joints

Returns

joint_positions – current joint position of the move group joints

Return type

JointValues

Raises

ServiceException – If Service is not available or finish not successful

get_current_joint_states()[source]

Returns the current joint states of the move group joints

Returns

joint_states – current joint states of the move group joints

Return type

JointStates

Raises

ServiceException – If Service is not available or finish not successful

get_end_effector(name=None)[source]

Get the end effector specified by name or the default end effector if name is not provided

Parameters

name (str convertable (optinal)) – Name of the end effector which should be returned

Returns

end_effector – Instance of Class EndEffector with requested name

Return type

xamla_motion.EndEffector

Raises

RuntimeError – If no end effector exist with the requested name

ik_jump_threshold

float convertable maximal allowed inverse kinematics jump threshold

Type

ik_jump_threshold

joint_set

JointSet (read only) joint set of the move group

Type

joint_set

max_deviation

float convertable Defines the maximal deviation from trajectory points when it is a fly-by-point in joint space

Type

max_deviation

motion_service

MotionService (read only) return the instance of motion service which is used to communicate via ros which the motion server

Type

motion_service

move_joints(target, velocity_scaling=None, collision_check=None, max_deviation=None, acceleration_scaling=None)[source]

Asynchronous plan and execute joint trajectory from joint space input

Parameters
  • target (Union[JointValues, JointPath]) – Target joint positions or joint path

  • velocity_scaling (Union[None, float]) – Scaling factor which is applied on the maximal possible joint velocities

  • collision_check (Union[None, bool]) – If true the trajectory planing try to plan a collision free trajectory and before executing a trajectory a collision check is performed

  • max_deviation (Union[None, float]) – Defines the maximal deviation from trajectory points when it is a fly-by-point in joint space

  • acceleration_scaling (Union[None, float]) – Scaling factor which is applied on the maximal possible joint accelerations

Raises
  • TypeError – If target is not one of types JointValues, JointPath If all other inputs are not convertable to specified types

  • ValueError – If scaling inputs are not between 0.0 and 1.0

  • ServiceException – If underlying services from motion server are not available or finish not successfully

move_joints_collision_free(target, velocity_scaling=None, collision_check=None, max_deviation=None, acceleration_scaling=None)[source]

Asynchronous plan and execute collision free joint trajectory from joint space input

Parameters
  • target (Union[JointValues, JointPath]) – Target joint positions or joint path

  • velocity_scaling (Union[None, float]) – Scaling factor which is applied on the maximal possible joint velocities

  • max_deviation (Union[None, float]) – Defines the maximal deviation from trajectory points when it is a fly-by-point in joint space

  • acceleration_scaling (Union[None, float]) – Scaling factor which is applied on the maximal possible joint accelerations

Raises
  • TypeError – If target is not one of types JointValues, JointPath If all other inputs are not convertable to specified types

  • ValueError – If scaling inputs are not between 0.0 and 1.0

  • ServiceException – If underlying services from motion server are not available or finish not successfully

move_joints_collision_free_supervised(target, velocity_scaling=None, collision_check=None, max_deviation=None, acceleration_scaling=None)[source]

plan collision free joint trajectory and creates a supervised executor

Parameters
  • target (Union[JointValues, JointPath]) – Target joint positions or joint path

  • velocity_scaling (Union[None, float]) – Scaling factor which is applied on the maximal possible joint velocities

  • max_deviation (Union[None, float]) – Defines the maximal deviation from trajectory points when it is a fly-by-point in joint space

  • acceleration_scaling (Union[None, float]) – Scaling factor which is applied on the maximal possible joint accelerations

Returns

executor – Executor for supervised execution of trajectory

Return type

SteppedMotionClient

Raises
  • TypeError – If target is not one of types JointValues, JointPath If all other inputs are not convertable to specified types

  • ValueError – If scaling inputs are not between 0.0 and 1.0

  • ServiceException – If underlying services from motion server are not available or finish not successfully

move_joints_supervised(target, velocity_scaling=None, collision_check=None, max_deviation=None, acceleration_scaling=None)[source]

Plan joint trajectory and creates a supervised executor

Parameters
  • target (Union[JointValues, JointPath]) – Target joint positions or joint path

  • velocity_scaling (Union[None, float]) – Scaling factor which is applied on the maximal possible joint velocities

  • collision_check (Union[None, bool]) – If true the trajectory planing try to plan a collision free trajectory and before executing a trajectory a collision check is performed

  • max_deviation (Union[None, float]) – Defines the maximal deviation from trajectory points when it is a fly-by-point in joint space

  • acceleration_scaling (Union[None, float]) – Scaling factor which is applied on the maximal possible joint accelerations

Returns

executor – Executor for supervised execution of trajectory

Return type

SteppedMotionClient

Raises
  • TypeError – If target is not one of types JointValues, JointPath If all other inputs are not convertable to specified types

  • ValueError – If scaling inputs are not between 0.0 and 1.0

  • ServiceException – If underlying services from motion server are not available or finish not successfully

name

str (read only) move group name

Type

name

plan_move_joints(target, velocity_scaling=None, collision_check=None, max_deviation=None, acceleration_scaling=None)[source]

Plans a trajectory from current state to target joint positions :type target: Union[JointValues, JointPath] :param target: Target joint positions or target JointPath :type target: Union[JointValues, JointPath] :type velocity_scaling: Union[None, float] :param velocity_scaling: Scaling factor which is applied on the maximal

possible joint velocities

Parameters
  • collision_check (Union[None, bool]) – If true the trajectory planing try to plan a collision free trajectory and before executing a trajectory a collision check is performed

  • max_deviation (Union[None, float]) – Defines the maximal deviation from trajectory points when it is a fly-by-point in joint space

  • acceleration_scaling (Union[None, float]) – Scaling factor which is applied on the maximal possible joint accelerations

Returns

trajectory, parameters – Returns a tuple where the first argument is the planed trajectory and the second argument the parameters which are used for it

Return type

Tuple[JointTrajectory, PlanParameters]

Raises
  • TypeError – If target is not one of types JointValues, JointPath If all other inputs are not convertable to specified types

  • ValueError – If scaling inputs are not between 0.0 and 1.0

  • ServiceException – If underlying services from motion server are not available or finish not successfully

plan_move_joints_collision_free(target, velocity_scaling=None, max_deviation=None, acceleration_scaling=None)[source]

Plans a collision free trajectory from current to target joint positions

Parameters
  • target (Union[JointValues, JointPath]) – Target joint positions or joint path

  • velocity_scaling (Union[None, float]) – Scaling factor which is applied on the maximal possible joint velocities

  • max_deviation (Union[None, float]) – Defines the maximal deviation from trajectory points when it is a fly-by-point in joint space

  • acceleration_scaling (Union[None, float]) – Scaling factor which is applied on the maximal possible joint accelerations

Returns

trajectory, parameters – Returns a tuple where the firt argument is the planed trajectory and the second argument the parameters which are used for it

Return type

Tuple[JointTrajectory, PlanParameters]

Raises
  • TypeError – If target is not one of types JointValues, JointPath If all other inputs are not convertable to specified types

  • ValueError – If scaling inputs are not between 0.0 and 1.0

  • ServiceException – If underlying services from motion server are not available or finish not successfully

sample_resolution

float convertable Trajectory point sampling frequency If value smaller one in seconds else in Hz

Type

sample_resolution

selected_end_effector

str (read only) Name of the currently selected end effector

Type

selected_end_effector

set_default_end_effector(end_effector_name)[source]

set one of the end effector from the list of available ones as default

Parameters

end_effector_name (str convertable) – Name of the end effector which should be now the default end effector of this move group

Raises
  • TypeError – If end_effector_name is not str convertable

  • RuntimeError – If the input end effector name is not available

velocity_scaling

Current velocity scaling value

velocity_scalingfloat convertable

The velocity scaling value is the value which was applied to the default velocities to get the current velocity limits. The default velocities are maximal velocities. The maximal velocities are provided by the motion server and queried from it during the initialization process.

EndEffector

class xamla_motion.EndEffector(move_group, end_effector_name, end_effector_link_name)[source]

Class with encapsulate move functionality for a specific end effector

from_end_effector_name(end_effector_name: str) → EndEffector[source]

Creates an instance of MoveGroup and select the correct instance of EndEffector

get_current_pose() → Pose[source]

Returns the current pose of the end effector

compute_pose(joint_values: JointValues) → Pose[source]

compute pose from joint values / configuration

inverse_kinematics(

poses: Union[Pose, CartesianPath], collision_check: Union[None, bool], seed: Union[None, JointValues], timeout: Union[None, datatime.timedelta], const_seed: bool, attempts: int

) -> JointValues: inverse kinematic solutions for one pose

inverse_kinematics_many(

poses: Union[Pose, CartesianPath], collision_check: Union[None, bool], seed: Union[None, JointValues], timeout: Union[None, datatime.timedelta], const_seed: bool, attempts: int

) -> IkResults: inverse kinematic solutions for many poses

move_poses(

target: Union[Pose, CartesianPath], seed: Union[None, JointValues]=None, velocity_scaling: Union[None, float]=None, collision_check: Union[None, bool]=None, max_deviation: Union[None, float]=None, acceleration_scaling: Union[None, float]=None)

Asynchronous plan and execute trajectory from task space input

move_poses_supervised(

target: Union[Pose, CartesianPath], seed: Union[None, JointValues]=None, velocity_scaling: Union[None, float]=None, collision_check: Union[None, bool]=None, max_deviation: Union[None, float]=None, acceleration_scaling: Union[None, float]=None

) -> SteppedMotionClient Plan trajectory from task space input and create executor

move_poses_collision_free(

target: Union[Pose, CartesianPath], seed: Union[None, JointValues]=None, velocity_scaling: Union[None, float]=None, collision_check: Union[None, bool]=None, max_deviation: Union[None, float]=None, acceleration_scaling: Union[None, float]=None)

Asynchronous plan and execute collision free trajectory from task space input

move_poses_collision_free_supervised(

target: Union[Pose, CartesianPath], seed: Union[None, JointValues]=None, velocity_scaling: Union[None, float]=None, collision_check: Union[None, bool]=None, max_deviation: Union[None, float]=None, acceleration_scaling: Union[None, float]=None

) -> SteppedMotionClient Plan collision free trajectory from task space input and create executor

plan_poses_linear(

target: Union[Pose, CartesianPath], velocity_scaling: Union[None, float]=None, collision_check: Union[None, bool]=None, max_deviation: Union[None, float]=None, acceleration_scaling: Union[None, float]=None, seed: Union[None, JointValues]=None

) -> Tuple[JointTrajectory, PlanParameters] Plans a trajectory with linear movements from task space input

move_poses_linear(

target: Union[Pose, CartesianPath], velocity_scaling: Union[None, float]=None, collision_check: Union[None, bool]=None, max_deviation: Union[None, float]=None, acceleration_scaling: Union[None, float]=None)

Plans and executes a trajectory with linear movements from task space input

Initialize EndEffector class

Parameters
  • move_group (xamla_motion.MoveGroup) – Instance of move group where the endeffector belongs to

  • end_effector_name (str_convertable) – If defined name of the end_effector which should for which a instance of EndEffector is created and which is selected as default for the move group

  • end_effector_link_name (str convertable) – name of the end effector link

Raises
  • TypeError – If move_group is not of type MoveGroup or If the other inputs are not str convertable

  • ServiceException – If necessary services to query available move groups and end effectors are not available

  • RuntTimeError – If requested move group or end effector not exist or are not available

compute_pose(joint_values)[source]

compute pose from joint values / configuration

Parameters

joint_values (JointValues) – Joint configuration of the robot which should be transformed to a cartesian pose

Returns

pose – An instance of Pose which represents the joint configuration of joint_values as a pose in cartesian space

Return type

Pose

Raises
  • ServiceException – If query services from motion server are not available or finish unsuccessfully

  • TypeError – If joint_values is not of expected type JointValues

static from_end_effector_name(end_effector_name)[source]

Creates an instance of MoveGroup and select the correct instance of EndEffector

Parameters

end_effector_name (str convertable) – Name of the end_effector for which a instance of EndEffector should be created

Returns

Instance of EndEffector for end effector with the name specified by end_effector name (instance is also hold by the created move_group)

Return type

xamla_motion.EndEffector

Raises
  • TypeError – If end_effector_name ist not convertable to str

  • RuntimeError – If it is not possible to create an instance of EndEffector because the end effector specified by end_effector_name is not available

get_current_pose()[source]

Returns the current pose of the end effector

Returns

pose – An instance of Pose which represents the current end effector pose

Return type

Pose

Raises

ServiceException – If query services from motion server are not available or finish unsuccessfully

inverse_kinematics(pose, collision_check, seed=None, timeout=None, const_seed=False, attempts=1)[source]

inverse kinematic solutions for one pose

Parameters
  • poses (Union[Pose, CartesianPath]) – Poses to transform to joint space

  • collision_check (Union[None, bool]) – If true the trajectory planing try to plan a collision free trajectory and before executing a trajectory a collision check is performed

  • seed (Union[None, JointValues] (optional)) – Numerical seed to control joint configuration

  • timeout (Union[None, datatime.timedelta] (optional)) – timeout

  • const_seed (bool (optional default False)) – Determines if for each pose in poses the same seed should be used

  • attempts (int (optional default 1)) – number of attempts to find solution

Returns

Instance of JointValues with a found solution

Return type

JointValues

Raises
  • TypeError – If poses is not of correct type

  • ServiceException – If query service is not available

inverse_kinematics_many(poses, collision_check, seed=None, timeout=None, const_seed=False, attempts=1)[source]

inverse kinematic solutions for many poses

Parameters
  • poses (Union[Pose, CartesianPath]) – Poses to transform to joint space

  • collision_check (Union[None, bool]) – If true the trajectory planing try to plan a collision free trajectory and before executing a trajectory a collision check is performed

  • seed (Union[None, JointValues] (optional)) – Numerical seed to control joint configuration

  • timeout (Union[None, datatime.timedelta] (optional)) – timeout

  • const_seed (bool (optional default False)) – Determines if for each pose in poses the same seed should be used

  • attempts (int (optional default 1)) – number of attempts to find solution

Returns

Instance of IkResult with all found solutions as a JointPath and error codes

Return type

IkResult

Raises
  • TypeError – If poses is not of correct type

  • ServiceException – If query service is not available

str end effector link name

Type

link_name

motion_service

MotionService Instance of MotionService which the move group and all end effectors use to communicate with the motion server

Type

motion_service

move_group

xamla_motion.MoveGroup Instance of MoveGroup which manages the move group where the end effector belongs to

Type

move_group

move_poses(target, seed=None, velocity_scaling=None, collision_check=None, max_deviation=None, acceleration_scaling=None)[source]

Asynchronous plan and execute trajectory from task space input

Parameters
  • target (Union[Pose, CartesianPath]) – Target Pose or target CartesianPath

  • seed (Union[None, JointValues] (default None)) – Numerical seed to control joint configuration

  • velocity_scaling (Union[None, float] (default None)) – Scaling factor which is applied on the maximal possible joint and task velocities If None the MoveGroup default is used

  • collision_check (Union[None, bool] (default None)) – If true the trajectory planing try to plan a collision free trajectory and before executing a trajectory a collision check is performed If None the MoveGroup default is used

  • max_deviation (Union[None, float] (default None)) – Defines the maximal deviation from trajectory points when it is a fly-by-point in joint space If None the MoveGroup default is used

  • acceleration_scaling (Union[None, float] (default None)) – Scaling factor which is applied on the maximal possible joint and task accelerations If None the MoveGroup default is used

Raises
  • TypeError – If target is not one of types Pose or CartesianPath If seed is defined and not of type JointValues If all other inputs are not convertable to specified types

  • ValueError – If scaling inputs are not between 0.0 and 1.0

  • ServiceException – If underlying services from motion server are not available or finish not successfully

move_poses_collision_free(target, seed=None, velocity_scaling=None, collision_check=None, max_deviation=None, acceleration_scaling=None)[source]

Asynchronous plan and execute collision free trajectory from task space input

Parameters
  • target (Union[Pose, CartesianPath]) – Target joint positions

  • seed (Union[None, JointValues] (optional)) – Numerical seed to control joint configuration

  • velocity_scaling (Union[None, float] (optional)) – Scaling factor which is applied on the maximal possible joint velocities

  • collision_check (Union[None, bool] (optional)) – If true the trajectory planing try to plan a collision free trajectory and before executing a trajectory a collision check is performed

  • max_deviation (Union[None, float] (optional)) – Defines the maximal deviation from trajectory points when it is a fly-by-point in joint space

  • acceleration_scaling (Union[None, float] (optional)) – Scaling factor which is applied on the maximal possible joint accelerations

Raises
  • TypeError – If target is not one of types Union[Pose, CartesianPath] If seed is defined and not of type JointValues If all other inputs are not convertable to specified types

  • ValueError – If scaling inputs are not between 0.0 and 1.0

  • ServiceException – If underlying services from motion server are not available or finish not successfully

move_poses_collision_free_supervised(target, seed=None, velocity_scaling=None, collision_check=None, max_deviation=None, acceleration_scaling=None)[source]

Plan collision free trajectory from task space input and create executor

Parameters
  • target (Union[Pose, CartesianPath]) – Target joint positions

  • seed (Union[None, JointValues] (optional)) – Numerical seed to control joint configuration

  • velocity_scaling (Union[None, float] (optional)) – Scaling factor which is applied on the maximal possible joint velocities

  • collision_check (Union[None, bool] (optional)) – If true the trajectory planing try to plan a collision free trajectory and before executing a trajectory a collision check is performed

  • max_deviation (Union[None, float] (optional)) – Defines the maximal deviation from trajectory points when it is a fly-by-point in joint space

  • acceleration_scaling (Union[None, float] (optional)) – Scaling factor which is applied on the maximal possible joint accelerations

Returns

executor – Executor for supervised execution of collision free trajectory

Return type

SteppedMotionClient

Raises
  • TypeError – If target is not one of types Union[Pose, CartesianPath] If seed is defined and not of type JointValues If all other inputs are not convertable to specified types

  • ValueError – If scaling inputs are not between 0.0 and 1.0

  • ServiceException – If underlying services from motion server are not available or finish not successfully

move_poses_linear(target, seed=None, velocity_scaling=None, collision_check=None, max_deviation=None, acceleration_scaling=None)[source]

Plans and executes a trajectory with linear movements from task space input

Parameters
  • target (Union[Pose, CartesianPath]) – Target joint positions

  • velocity_scaling (Union[None, float]) – Scaling factor which is applied on the maximal possible joint velocities

  • collision_check (Union[None, bool]) – If true the trajectory planing try to plan a collision free trajectory and before executing a trajectory a collision check is performed

  • max_deviation (Union[None, float]) – Defines the maximal deviation from trajectory points when it is a fly-by-point in joint space

  • acceleration_scaling (Union[None, float]) – Scaling factor which is applied on the maximal possible joint accelerations

Raises
  • TypeError – If target is not one of types Union[Pose, CartesianPath] If all other inputs are not convertable to specified types

  • ValueError – If scaling inputs are not between 0.0 and 1.0

  • ServiceException – If underlying services from motion server are not available or finish not successfully

move_poses_supervised(target, seed=None, velocity_scaling=None, collision_check=None, max_deviation=None, acceleration_scaling=None)[source]

Plan trajectory from task space input and create executor

Parameters
  • target (Union[Pose, CartesianPath]) – Target Pose or target CartesianPath

  • seed (Union[None, JointValues] (default None)) – Numerical seed to control joint configuration

  • velocity_scaling (Union[None, float] (default None)) – Scaling factor which is applied on the maximal possible joint and task velocities If None the MoveGroup default is used

  • collision_check (Union[None, bool] (default None)) – If true the trajectory planing try to plan a collision free trajectory and before executing a trajectory a collision check is performed If None the MoveGroup default is used

  • max_deviation (Union[None, float] (default None)) – Defines the maximal deviation from trajectory points when it is a fly-by-point in joint space If None the MoveGroup default is used

  • acceleration_scaling (Union[None, float] (default None)) – Scaling factor which is applied on the maximal possible joint and task accelerations If None the MoveGroup default is used

Returns

executor – Executor for supervised execution of trajectory

Return type

SteppedMotionClient

Raises
  • TypeError – If target is not one of types Pose or CartesianPath If seed is defined and not of type JointValues If all other inputs are not convertable to specified types

  • ValueError – If scaling inputs are not between 0.0 and 1.0

  • ServiceException – If underlying services from motion server are not available or finish not successfully

name

str (read only) end effector name

Type

name

plan_poses_linear(target, velocity_scaling=None, collision_check=None, max_deviation=None, acceleration_scaling=None, seed=None)[source]

Plans a trajectory with linear movements from task space input

Parameters
  • target (Union[Pose, CartesianPath]) – Target joint positions

  • velocity_scaling (Union[None, float]) – Scaling factor which is applied on the maximal possible joint velocities

  • collision_check (Union[None, bool]) – If true the trajectory planing try to plan a collision free trajectory and before executing a trajectory a collision check is performed

  • max_deviation (Union[None, float]) – Defines the maximal deviation from trajectory points when it is a fly-by-point in joint space

  • acceleration_scaling (Union[None, float]) – Scaling factor which is applied on the maximal possible joint accelerations

  • seed (Union[None, JointValues]) – Numerical seed to control joint configuration

Returns

A tuple containing the trajectory and the plan parameters

Return type

Tuple[JointTrajectory, PlanParameters]

Raises
  • TypeError – If target is not one of types Union[Pose, CartesianPath] If all other inputs are not convertable to specified types

  • ValueError – If scaling inputs are not between 0.0 and 1.0

  • ServiceException – If underlying services from motion server are not available or finish not successfully