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 dq_goal: [f64; 7],
    pub cap_scale: f64,
    pub pinned: [i8; 7],
    pub tau: [f64; 7],
    pub tau_envelope: [f64; 7],
    pub tau_position: [f64; 7],
    pub ik_error: f64,
    pub ik_passes: u32,
    pub stall_pressure: f64,
    pub stalled: bool,
    pub ik_step: f64,
    pub ik_step_clipped: f64,
    pub ik_blend: f64,
    pub held: bool,
    pub wall_age: [i8; 2],
    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. On a cycle the joint velocity cap cut, the desired pose before the cut: q_goal and dq_goal are what was commanded.

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.

dq_goal: [f64; 7]

The joint goal’s velocity, rad/s: the finite difference of q_goal the law feeds forward with ImpedanceOptions::velocity_feedforward on, under the joint velocity cap and after ImpedanceOptions::velocity_feedforward_cutoff’s low-pass if one is set; zeros on the first cycle, while holding and with Backend::RobotController. This is the value the law and the recorder both see, not the raw difference.

cap_scale: f64

The fraction of the generator’s step the goal carried on a cycle it fell short and the generator was restarted from the goal: held at a joint position limit, cut to ImpedanceOptions::joint_velocity_fraction of the joint velocity limits, or both. Exactly 1 on every other cycle, and with Backend::RobotController.

pinned: [i8; 7]

Per joint, the bound of the IK’s box the goal was held on: 0 none, -1 / +1 the lower / upper position bound (the margin, or the braking toward it), -2 / +2 the velocity bound; zeros with Backend::RobotController.

tau: [f64; 7]

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

tau_envelope: [f64; 7]

The velocity envelope’s share of tau, Nm, before the clamp: the barrier opposing every joint measured faster than ImpedanceOptions::velocity_barrier_fraction of its limit, less the law’s torque along a joint’s motion faded out above the fade’s start (FADE_BAND); zeros below it and with Backend::RobotController.

tau_position: [f64; 7]

The position envelope’s share of tau, Nm, before the clamp: the spring pushing a joint measured inside the position barrier’s onset out, less the law’s torque toward a limit faded out inside ImpedanceOptions::joint_position_margin; tau is the clamped sum of the law, tau_envelope and this. Zeros away from the limits and with Backend::RobotController.

ik_error: f64

The IK’s residual toward pose after this cycle’s iterations, the norm of the position error, m, and the orientation error weighted by IkOptions::rotation_weight; 0 with Backend::RobotController.

ik_passes: u32

The IK’s active-set passes this cycle, over its iterations; 0 with Backend::RobotController.

stall_pressure: f64

How hard the residual pushes on the goal’s position pins, in the weighted task units of ik_error (m) per cycle: the largest residual along a pinned joint’s unit Jacobian column, counted only into its bound; 0 with Backend::RobotController.

stalled: bool

Whether the IK’s goal is stalled at a joint position limit, the flag on stall_pressure with its hysteresis; while it or a position pin after it holds, the generator is restarted from the goal every cycle without its velocity into the limit. Always false with Backend::RobotController.

ik_step: f64

The largest raw step the cycle’s IK solves asked for, rad: its norm with the nullspace bias in and before the per-joint box clip. While ik_blend is above 0 each iteration solves twice, and a position stage’s norm is its own, before the blend scales it down. 0 with Backend::RobotController.

ik_step_clipped: f64

How much of that same solve’s ik_step the box took off, rad; 0 with Backend::RobotController.

ik_blend: f64

The IK’s priority blend β this cycle: 0 the weighted solve, 1 position first (see stalled); 0 with Backend::RobotController.

held: bool

Whether the generator was held at a wall this cycle: the IK stalled, or a wall still within its life. Always false with Backend::RobotController.

wall_age: [i8; 2]

Per block (translation, rotation), cycles since that block was last pushed on a wall, and -1 when it claims no wall; [-1, -1] with Backend::RobotController.

A block takes a wall only when the free joints’ remainder in it exceeds the stall’s wall share of what the pins push, and keeps it for a while after. On this path, where position first drives the translation residual down to micrometres, the translation age normally stays -1 and only the rotation’s varies.

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.

What the leash took off, not the lead itself: 0 whenever the pose is inside the leash – the common case – so a recording of nothing but zeros says only that the arm kept up. The leash scales both blocks together, so an orientation beyond its own leash pulls the position back with it and this reads positive inside the translation leash.

leash_angular_alteration: f64

The same for the orientation, rad, and zero on the same terms.

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