Struct Parallelogram 

pub struct Parallelogram {
    pub robot: Arc<dyn Kinematics>,
    pub scaling: f64,
    pub driven: usize,
    pub coupled: usize,
}

Parallelogram Mechanism: The parallelogram mechanism introduces a geometric dependency between two specific joints, typically to maintain the orientation of the end-effector as the robot arm moves. This is useful in tasks that require a constant tool orientation, such as welding or handling objects, ensuring that the tool or end-effector remains level.

The mechanism links two joints, referred to as joints[driven] and joints[coupled]. The movement of the driven joint influences the coupled joint, maintaining the orientation of the end-effector during motion. The scaling factor determines the proportional influence of the driven joint on the coupled joint.

• Forward Kinematics: The coupled joint (joints[coupled]) is adjusted based on the driven joint: joints[coupled]' = joints[coupled] - scaling * joints[driven]. This adjustment maintains the correct alignment of the end-effector.
• Inverse Kinematics: The dependency is reversed, adding the influence of the driven joint to the coupled joint: joints[coupled]' = joints[coupled] + scaling * joints[driven]. This ensures accurate calculation of joint angles to achieve the desired pose and orientation.

The Parallelogram structure automatically adjusts joints[coupled] based on joints[driven] using a scaling factor to account for the parallelogram mechanism.

Fields:

• robot: The underlying robot’s kinematics model used to compute forward and inverse kinematics.
• scaling: The factor that determines how much influence joints[driven] has on joints[coupled].
• driven: The index of the driven joint in the parallelogram mechanism (typically the primary joint).
• coupled: The index of the coupled joint in the parallelogram mechanism (the secondary joint influenced by the driven joint).

Example:

use std::sync::Arc;
// As J1 = 0, J2 = 1 and J3 = 2, so it is more clear with J-constants:
use rs_opw_kinematics::kinematic_traits::{J2, J3};

use rs_opw_kinematics::kinematics_impl::OPWKinematics;
use rs_opw_kinematics::parallelogram::Parallelogram;
use rs_opw_kinematics::parameters::opw_kinematics::Parameters;

// Assuming a robot that implements the Kinematics trait
let robot_kinematics = Arc::new(OPWKinematics::new(Parameters::irb2400_10()));

// Create the Parallelogram structure with a scaling factor of 0.5,
// where joints[1] is the driven joint and joints[2] is the coupled joint.
let parallelogram = Parallelogram {
    robot: robot_kinematics,
    scaling: 1.0, // typically there is 1-to-1 influence between driven and coupled joints
    driven: J2,   // Joint 2 is most often the driven joint. 
    coupled: J3,  // Joint 3 is most often the coupled joint
};

As Parallelogram accepts and itself implements Kinematics, it is possible to chain multiple parallelograms if the robot has more than one.

Fields

robot: Arc<dyn Kinematics>

The underlying robot’s kinematics used for forward and inverse kinematics calculations.

scaling: f64

The scaling factor that determines the proportional influence of joints[driven] on joints[coupled].

driven: usize

The index of the driven joint in the parallelogram mechanism (joints[driven]).

coupled: usize

The index of the coupled joint in the parallelogram mechanism (joints[coupled]).

Trait Implementations

impl Clone for Parallelogram

fn clone(&self) -> Parallelogram

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Kinematics for Parallelogram

fn inverse(&self, tcp: &Pose) -> Solutions

Find inverse kinematics (joint position) for this pose This function is faster but does not handle the singularity J5 = 0 well. All returned solutions are cross-checked with forward kinematics and valid.

fn inverse_5dof(&self, tcp: &Pose, j6: f64) -> Solutions

Calculates the inverse kinematics for a robot while ignoring the rotation around joint 6. The position of the tool center point remains precise, but the rotation is approximate (rotation around the tool axis is ignored). The return value for joint 6 is set according to the provided parameter. This method is significantly faster

fn inverse_continuing_5dof(&self, tcp: &Pose, previous: &Joints) -> Solutions

Calculates the inverse kinematics for a robot while ignoring the rotation around joint 6. The position of the tool center point remains precise, but the rotation is approximate (rotation around the tool axis is ignored). The return value for joint 6 is set based on the previous joint values. This method is significantly faster

fn inverse_continuing(&self, tcp: &Pose, previous: &Joints) -> Solutions

Find inverse kinematics (joint position) for this pose This function handles the singularity J5 = 0 by keeping the previous values the values J4 and J6 from the previous solution Use CONSTRAINT_CENTERED as previous if there is no previous position but we prefer to be as close to the center of constraints (or zeroes if not set) as possible. “Previous” can be in a wide range, say 90000 degrees.

fn forward(&self, qs: &Joints) -> Pose

Find forward kinematics (pose from joint positions). For 5 DOF robot, the rotation of the joint 6 should normally be 0.0 but some other value can be given, meaning the tool is mounted with fixed rotation offset.

fn forward_with_joint_poses(&self, joints: &Joints) -> [Pose; 6]

Computes the forward kinematics for a 6-DOF robotic arm and returns an array of poses representing the position and orientation of each joint, including the final end-effector.

fn kinematic_singularity(&self, qs: &Joints) -> Option<Singularity>

Detect the singularity. Returns either A type singularity or None if no singularity detected.

fn constraints(&self) -> &Option<Constraints>

Returns constraints under what the solver is operating. Constraints are remembered here and can be used for generating random joint angles needed by RRT, or say providing limits of sliders in GUI.