Struct CartesianSent 

pub struct CartesianSent {

    pub pose: [f64; 16],
    pub orientation: [f64; 4],
    pub target: [f64; 3],
    pub target_orientation: [f64; 4],
    pub velocity: [f64; 3],
    pub acceleration: [f64; 3],
    pub angular_velocity: [f64; 3],
    pub angular_acceleration: [f64; 3],
    pub backstop_alteration: f64,
    pub backstop_angular_alteration: f64,
    pub q_goal: [f64; 7],
    pub tau: [f64; 7],
    pub ik_error: f64,
    pub leash_alteration: f64,
    pub leash_angular_alteration: f64,
}

What one cycle sent, for the observer.

Fields

pose: [f64; 16]

The pose that went to the robot (after the backstop), or with Backend::Impedance the desired pose the IK follows; column-major.

orientation: [f64; 4]

The orientation of pose as a unit quaternion, [x, y, z, w].

target: [f64; 3]

The target position the generator was planning towards, base frame, m.

target_orientation: [f64; 4]

The target orientation the generator was planning towards, [x, y, z, w].

velocity: [f64; 3]

The generator’s velocity at the end of the cycle, m/s.

acceleration: [f64; 3]

The generator’s acceleration at the end of the cycle, m/s^2.

angular_velocity: [f64; 3]

The generator’s angular velocity at the end of the cycle, base frame, rad/s.

angular_acceleration: [f64; 3]

The generator’s angular acceleration at the end of the cycle, base frame, rad/s^2.

backstop_alteration: f64

How far the backstop moved the generator’s position, m: zero unless the generator outran the budget (or without limit_rate, or with Backend::Impedance).

backstop_angular_alteration: f64

How far the backstop turned the generator’s orientation, rad; as above.

q_goal: [f64; 7]

The joint target of the impedance law, rad; zeros with Backend::RobotController.

tau: [f64; 7]

The torques sent, Nm, clamped to the torque limits; zeros with Backend::RobotController.

ik_error: f64

The IK’s residual toward pose after this cycle’s iterations, m plus rad in one norm; 0 with Backend::RobotController.

leash_alteration: f64

How far, m, the leash pulled the generator’s anchor back from the previous desired position toward the measured one: zero while the arm follows, positive while it is held back (Leash); 0 with Backend::RobotController.

leash_angular_alteration: f64

The same for the orientation, rad.

Trait Implementations

impl Clone for CartesianSent

fn clone(&self) -> CartesianSent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for CartesianSent

impl Debug for CartesianSent

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

Formats the value using the given formatter.

impl PartialEq for CartesianSent

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for CartesianSent