Struct arcos_kdl::kinematic_arm::KinematicArm

pub struct KinematicArm { /* fields omitted */ }

Implementation of kinematic arms

These are the subset of kinematic chains that are used as robotic
arms. With an improved API for ease of used compared to the one
we have for kinematic chains. It is different from the chain because
it has a shoulder segment (segment with no joint) at the beginning
and then N mobile segments. Also has a base transform that represents
the robotic body to which the arm is attached.

base_transform: Pose of the base of the shoulder
chain: The kinematic chain that describes the arm
forward_solver: Forward kinematics solver
forward_diff_solver: Forward Differential kinematics solver
inverse_diff_solver: Inverse differential kinematics solver
joint_limits: Mechanical joint limits (radians)
joint_speed_limits: max speed of each joint (radians/s)
weights: the weight of each joint for inverse kinematics
state: current state of each joint (radians)
speed: current speed of each joint (radians/s)\

Implementations

impl KinematicArm

pub fn default() -> Self

Default empty kinematic arm

pub fn get_joint_num(&self) -> usize

Get how many joints the kinematic arm has

pub fn get_segment_num(&self) -> usize

Get how many segments the kinematic arm has

pub fn get_limits(&self) -> Vec<(f64, f64)>

Get the limits of each joint

pub fn get_speed_limits(&self) -> Vec<f64>

Get the speed limits of each joint

pub fn set_base_transform(&mut self, transform: Frame)

Set the base pose transformation.
transform: A Frame holding the base transform to set

pub fn set_base_twist(&mut self, twist: Twist)

Set the base velocity.
twist: the twist of the base to set

pub fn set_shoulder(&mut self, shoulder: Segment)

Add a shoulder to the kinematic arm. This will remove the current
chain and add a new one with this shoulder
shoulder: a segment holding the shoulder

pub fn set_shoulder_transform(&mut self, shoulder_tf: Frame)

Add a shoulder to the kinematic arm. This will remove the current
chain and add a new one with this shoulder.
shoulder_tf: Frame holding the shoulder transform

pub fn add_segment(
    &mut self,
    new_segment: Segment,
    limits: (f64, f64),
    speed_limit: f64
)

Add a new segment to the description of the kinematic arm.
It will be added to the end of the current chain
segment: The new segment to add
limits: mechanical limits of the joint (radians)
speed_limits: speed limit of the joint (radians/s)\

pub fn add_segment_by_type(
    &mut self,
    joint_type: JointType,
    transform: Frame,
    limits: (f64, f64),
    speed_limit: f64
)

Add a new joint by Type and transform. See ‘add_segment’ for more info
joint_type: type of joint
transform: transform of the segment
limits: mechanical limits of the joint (radians)
speed_limits: speed limit of the joint (radians/s)\

pub fn set_joint_weight_ranges(
    &mut self,
    weights: Vec<f64>,
    min_weights: Vec<f64>
)

Set the weight ranges for each joint. The algorithm will use the highest
weight for each joint, but when it gets close to the limit, it will
switch to the minimum weight to avoid a collision (to the joint limit)
weights: Weight for normal operation of the arm
min_weights: Weight to use when the joint approaches its limit.

pub fn set_joint_weights(&mut self, weights: Vec<f64>)

Set the weights of each joint. This tells the algorithm how much to move
each joint for IK. The weight is a floating value between 0 and 1, where
1 means free movement and 0 means to stay put.
weights: The weight for each movable joint\

pub fn set_singularity_avoidance_ratio(&mut self, lambda: f64)

Set how much to avoid singularities for inverse kinematics.
It is a scalar from 0 to 1 where
0 means low avoidance and high accuracy and 1 means high avoidance
and low accuracy.
lambda: singularity avoidance\

pub fn set_ik_convergence_parameters(&mut self, epsilon: f64, max_iter: usize)

Configure the behaviour of the inverse kinematics differential
solver. By changing the epsilon and maximum iterations parameters.
Lower epsilon means more accuracy but slower execution. Higher
maxiter means higher robustness but slower executions.
epsilon: IK SVD solution threshold max_iter: IK SVD solver maximum iterations

pub fn get_joint_speeds(&mut self) -> Vec<f64>

Get the current joint speeds (radians/s)\

pub fn get_joint_states(&mut self) -> Vec<f64>

Get the current joint state (radians)\

pub fn set_joint_speeds(&mut self, joint_speeds: Vec<f64>)

Set the speeds of each joint.
joint_speeds: vector with the speed to set (radians/s). Must be the same
length as movable joints in the arm\

pub fn set_joint_states(&mut self, joint_states: Vec<f64>)

Set the state of each joint. If the joint approaches a limit, it will also handle the weights for the inverse kinematic solver.
joint_states: vector with the state to set (radians). Must be the same length as movable joints in the arm\

pub fn get_global_pose(&mut self) -> Frame

Get the end effector pose. Takes into consideration the pose of the base of the arm.

pub fn get_global_twist(&mut self) -> Twist

Get the end effector twist. Takes into consideration the pose and twist of the base of the arm

pub fn get_pose(&mut self) -> Frame

Get the end effector local pose, from the shoulder to the end effector.

pub fn get_twist(&mut self) -> Twist

Get the end effector local twist, from the shoulder to the

pub fn move_base(&mut self, base_twist: Twist, dt: f64)

Move the base.\

pub fn cartesian_diff_move(&mut self, twist: Twist, dt: f64)

Move the end effector a differential
twist: Required or commanded Twist
dt: time differential\

pub fn cartesian_move(
    &mut self,
    goal: Frame,
    speed: f64,
    rot_speed: f64,
    dt: f64,
    timeout: f64,
    translation_tolerance: f64,
    rotation_tolerance: f64
) -> Result<Vec<f64>, &str>

Move to the goal pose in a straight line from the current pose to the goal.

goal: the goal pose
speed: the speed at which the end effector should move
rot_speed: the speed at which the end effector should rotate
dt: time differential
timeout: time after which the goal is unreachable
translation_tolerance: allowed translational error
rotation_tolerance: allowed rotational error
returns final state if reachable\

pub fn build_from_description(description: Vec<SegmentDescription>) -> Self

Build the arm from a kinematic description.\

pub fn get_description(&self) -> Vec<SegmentDescription>

Return the description of the current arm

Trait Implementations

impl Clone for KinematicArm

fn clone(&self) -> KinematicArm

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for KinematicArm

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq<KinematicArm> for KinematicArm

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.