class mechanism

Represents a mechanism composed of links (rigid bodies) connected by joints.

Public Fields

Bookkeeping and options

State and dynamics members

Pointers to other entities

Public Methods

mechanism(void)

constructor

~mechanism(void)

destructor

Kinematics methods

Miscellaneous methods

Dynamics-related methods

Convenience functions

Public Members

enum baseMotionType

Indicates the type of motion for the mechanism's root link.

Documentation

Represents a mechanism composed of links (rigid bodies) connected by joints. A mechanism can compute the forward dynamics, forward kinematics, and differential kinematics (Jacobian) for a connected set of links and joints. The most simple mechanism is a single rigid body; a slightly more complex mechanism would have a series of rigid bodies connected by joints. It is also possible to have branching mechanisms whose graph of links and joints is a tree, and loops can be created from the tree by the addition of constraints.

Creating mechanisms While one could create a mechanism by manually creating links and joints and then adding them to an empty mechanism, it is easier to create an assembly from parts, and then create the mechanism from the assembly through assembly::connectParts(). This will call all the necessary initialization functions and tends to be simpler in general.

Simulating mechanisms After creating a mechanism, you must add it to a dynamicSystem using dynamicSystem::addMechanism() before you can simulation the mechanism's motion. The dynamic system's stepForward() method can then be used to compute the motion of one or more mechanisms over a period of time. Influences, timer, and other components can be added the dynamicSystem as well, allowing complex controllers and physical phenomena to be simulated.

Multiple mechanisms with constraints When constraints between mechanisms are created, one mechanism becomes a parent mechanism and the others become children. The parent mechanism handles the constraint calculations and computation of acceleration for the entire system, since the constraints cause interactions between the mechanisms. This process is mostly transparent to the user.

enum baseMotionType

Indicates the type of motion for the mechanism's root link.

• FIXED_BASE - the base is fixed and has no degrees of freedom
• PLANAR_BASE - the base can move freely in the plane and thus has 3 DOFs
• FREE_BASE - the base can move freely in space, and thus has 6 DOFs

Bookkeeping and options

baseMotionType baseType

the type of motion allowed for the base

int rootDOFs

the number of DOFs of the root link

int systemDOFs

the total number of DOFs in this mech and its children

int stateSize

the dimension of the state vector. This may be different from the number of degrees of freedom: for example, the orientation of a free base is stored as a quaternion, so the state for orientation has 4 entires while orientation has only 3 DOFs.

int systemStateSize

the size of the system state vector

int verboseLevel

desired level of output for general mechanism methods

int dynamicVerboseLevel

desired level of output for methods relating to dynamic simulation

int inverseIsCurrent

indicates whether Minv is up-to-date

int usedCS

indicates whether the constraintSolver was used for bilateral constraints

int recordLinkForces

indicates whether link forces should be recorded for later structural analysis (default is 0)

State and dynamics members

int offset

the offset of the mechanism in the dynamic eqns

vector* systemVel

a pointer to the system velocity vector. This vector is allocated only by parent mechanisms; in child mechanisms, systemVel points to the system velocity vector of the parent.

vector* systemAcc

a pointer to the system acceleration vector. This vector is allocated only by parent mechanisms; in child mechanisms, systemAcc points to the system acceleration vector of the parent. Additionally, if a parent mechanism has no children, systemAcc points to acc. It is easier for users to use 'acc' to access acceleration than to use systemAcc, though note that updateAccVector() may need to be called in some cases.

See Also:

mechanism::acc
mechanism::updateAccVector

svTriple* xDotDot

the s-val for the base's acceleration, if the base link is mobile

svTriple* omegaDot

the s-val for the base's angular acceleration, if the base link is mobile

matrix M

the mechanism's mass marix

matrix Minv

the inverse of the mechanism's mass matrix. Check 'inverseIsCurrent' to see if Minv is up-to-date before using it. If it is not, call updateMassInverse().

vector T

Vector of applied joint torques

vector V

Vector of 0th and 1st order terms in the dynamics equations

vector acc

The mechanism's acceleration vector. This may not be up-to-date for mechanisms that have constraints with other mechanisms, in which case you should call updateAccVector() before using 'acc'. The format of acc is:

• linear acceleration (0 entries for FIXED_BASE, 2 for PLANAR_BASE, or 3 for FREE_BASE
• angular acceleration (0 entries for FIXED_BASE, 1 for PLANAR_BASE, or 3 for FREE_BASE
• joint accelerations (one per joint DOF; total number is (numDOFs - (0 for FIXED_BASE, 3 for PLANAR_BASE, 6 for FREE_BASE))

vector* Ts

The system torque vector for parent mechanisms

matrix* Ms

The system mass matrix. Only parent mechanisms have this allocated.

matrix* Minvs

The inverse of the system mass matrix. Only parent mechanisms have this allocated.

vector* Vs

The system inertial and external force vector. Only parent mechanisms have this allocated.

Pointers to other entities

mechanism* parent

the parent mechanism (or NULL if this mechanism is a parent)

link* root

the root link of the mechanism

assembly* as

the assembly from which the mechanism was built, if any. If 'as' is non-null, it will be deleted when the mechanism is deleted.

dynamicSystem* ds

The dynamicSystem to which the mechanism belongs

constraintSolver* cs

The object for solving dynamic constraints. This is only allocated when a mechanism has unilateral constraints.

mechanism(void)

constructor

~mechanism(void)

destructor

Kinematics methods

int setBaseType(baseMotionType newType)

sets the type of base motion (fixed, planar, or spatial)

int setPoseFromJoints(void)

sets the pose of the mechanism's links from joint states

int setPoseFromJoints(const quaternion &q, const triple &t)

sets the pose of the mechanism's links from joint states, setting the pose of the root link to q & t

int computeBaseJacobian(const triple &worldPt, matrix &J, int rowOffset, int columnOffset)

computes the jacobian matrix for 'worldPt' with respect to the base's degrees of freedom, and store it in J at the position indicated by (rowOffset, columnOffset)

Miscellaneous methods

int checkGraphConsistency(void)

checks link-joint and part-connection graphs for consistency

void nameLinks(void)

allocates names for each link to aid debugging

void print(link* n = NULL)

prints the mechanism's current state

int setRoot(link* m)

sets the root link of the mechanism

int isLocked(int sysOffset) const

returns 1 if the indicated DOF is locked, or 0 if not

inline int* getLock(void) const

gets the array of DOF locking values

void printPose(void)

prints the current pose of the mechanism

int joinMechanisms(mechanism* otherMech, joint* newJoint)

[NOT IMPLEMENTED] connects otherMech to this one via newJoint

mechanism* split(joint* jt, baseMotionType newBaseMotion)

[NOT IMPLEMENTED] creates a new mechanism by splitting the current mechanism at jt

Dynamics-related methods

int getDynamicEquations(matrix* Mm, vector* Vm)

Stores M and V in Mm and Vm, respectively. If Mm (or Vm) is NULL, then M (or V) will not be stored. This method will re-evaluate the dynamic equations if they are not up to date.

int addConstraintForces(int evaluate, int subtract = 0)

Adds the forces computed for each constraint to Fext and Next of the links they act on. This is useful when the user needs to know the final sum of forces and moments acting on each link, since normally the constraint forces are not actually applied to the mechanism's links--their influence on acceleration is directly computed. If evaluate is 1, then the constant terms of the mechanism's dynamic equations will be re-evaluated. if subtact is -1, then the constraint forces will be subtracted from the system.

int computeConnectionForces(int addConstraintForces = 1, int evaluateDynamics = 1)

Computes the internal forces at every connection between parts in the mechanism, allowing structural analysis to be performed. If 'addConstraintForces' is non-zero, then mechanism::addConstraintForces() will be called with 'evaluateDynamics' as the first argument.

void printDynamics(int printValue) const

prints the mechanism's dynamics. Prints numeric values if printValue is 1, or symbolic values otherwise

int updateMassInverse(void)

updates Minv. Does nothing if 'inverseIsCurrent' is non-zero

inline int updateAccVector(void)

updates 'acc' from systemAcc, if necessary. returns 1 if acc was changes, 0 if not. This method is only needed if you have constraints between mechanisms; otherwise, systemAcc just points to acc.

int computeAccelerationFromTorque(double* state, double* stateDot, int &appliedImpulse)

Nomputes the acceleration of the system's mechanisms given the applied forces. This method handles constraint satisfaction in addition to the normal dynamic equations. computeAccelerationFromTorque is normally called by the dynamic system, and should only be called for parent mechanisms.

int setAccelerationFromCommand(double* stateDot)

Sets the system's acceleration to the given value. This method is normally called by the dynamic system, and should only be called for parent mechansims.

int getState(double* state, double* stateDot)

saves the mechanism's state (and velocity, if stateDot is non-NULL)

int setState(const double* state, const double* stateDot)

sets the mechanism's position (and velocity, if stateDot is non-NULL)

int getState(vector &state)

saves the mechanism's state (position and velocity) in the supplied vector, resizing it if necessary to 2*stateSize

int setState(const vector &state)

sets the mechanism's state (position and velocity) from the supplied vector, returning 0 if the vector is the wrong size or if an error occurred.

int updateSystemVelFromMech(void)

updates systemVel from link and joint velocities

int updateMechFromSystemVel(void)

updates link and joint velocities from systemVel

int computeSystemInverse(void)

computes the inverse mass matrix for the entire system

int setDynamicValues(void)

updates link velocities and other velocity-dependent variables. Call this after explicitly setting any joint or base velocities to ensure that link velocities get updated.

Convenience functions

inline link* getLink(int i)

returns the i'th link

inline joint* getJoint(int i)

returns the i'th joint

inline mechanism* getChild(int i)

returns the i'th child mechanism

inline int numLocked(void) const

returns the number of locked DOFs

inline int numSystemLocked(void) const

returns the number of locked DOFs in the system

inline int numLinks(void) const

returns the number of links in the mechanism

inline int numJoints(void) const

returns the number of links in the mechanism

inline int numChildren(void) const

returns the number of children in the mechanism

inline int numBConstraints(void) const

returns the number of bilateral constraints in the system

inline int numUConstraints(void) const

returns the number of unilateral constraints in the system

inline int numMyConstraints(void) const

returns the number of this mechanism's constraints

This class has no child classes.

Friends:

dynamicSystem
constraintSolver
constraint
assembly
link
joint

Alphabetic index HTML hierarchy of classes or Java