Universal Joint

This section describes the Universal joint entity of MotionView and shows the various usage, creation, and editing methods.

Theory/Background

A Universal joint is a two degree-of-freedom kinematic pair used in mechanisms. It is functionally identical to, and also referred to as a Hooke joint. The only difference between these two joints is the way that the joint is defined. Universal joints provide two rotational functions used in applications such as:

•	Propeller shafts/drive shafts

•	Steering columns

•	Any shaft assembly where the connecting shafts are not aligned along a line

universal_joint_diagram_mv

Universal joint construction

Joint Definition

The Universal joint is represented using Markers when exported to an MBD Solver. The representation can be visualized as shown in the two figures below:

universal_joint_marker_diagram_shaft_mv_ug

Universal joint - Shaft orientation

universal_joint_marker_diagram_crosspin_mv_ug

Universal joint - Crosspin orientation

The bodies that are constrained by an Inline joint are represented using two markers: Marker I and Marker J. Marker I belongs to Body 1 and Marker J belongs to Body 2. The constraints are applied on Marker I with respect to Marker J. Both of the markers will have a common point of origin, the same as the joint’s Origin point. The Z axes of Marker I and Marker J are always perpendicular to each other by definition. Since a Universal joint connects two intersecting but non-aligned shafts/bodies, the joint needs two axes to complete the definition: one for each shaft/body. MotionView allows two different schemes for orienting a Universal joint, namely Shaft and Crosspin. The X axis of the respective markers can be oriented using the Shaft scheme and Y axis can be oriented using the Crosspin scheme. Shaft orientation can be interpreted as orienting the yoke of the joint and Crosspin orientation as the spider of the joint.

Entity Data Members

The topological information required to define an Universal joint is shown in the figure below:

universal_joint_diagram2_mv

The data members of the Universal joint can be classified into the following members:

Connectivity

An Universal joint needs the following:

•	Body 1 and Body 2 - Specify two bodies between which the joint is to be created.

•	Origin - Specify Point, which defines the location of the joint.

•	Orientation 1 - The orientation of the axis of rotation of Body 1 specified using a Point or Vector and either a Shaft or Crosspin scheme.

•	Orientation 2 - The orientation of the axis of rotation of Body 2 specified using a Point or Vector and either a Shaft or Crosspin scheme.

•	Compliant Mode (Optional) - If the Allow Compliance option is selected while adding the joint to a model, the joint's compliance state can be toggled between Compliant and Non-Compliant.

•	Friction Properties (Optional) - can also be assigned (see Properties below).

The joint can be modeled as a Single entity or as a Pair entity.

Properties

Optional Friction properties can also be specified for the joint:

universal_joint_friction_properties_diagram_mv_ug

Activating the Use Friction option on the Friction Properties tab will display the following options in the panel:

Coefficient Dynamic

Coefficient Static

Stiction Transition Velocity

Max. Stiction Deformation (Adams only)

Active for Static/Quasi-Static Analysis

True/False

Effect

•	Stiction and Sliding

•	Stiction Only

•	Sliding Only

Input Forces

•	Preload (True/False)

•	Reaction Force (True/False)

•	Bending Moment (True/False)

Torque Preload

Friction Arm

Pin Radius

Bending Arm

Rot Constraint

•

I Yoke

•

J Yoke

LuGre Parameters

•	Bristle Stiffness

•	Damping Coefficient

•	Viscous Coefficient

Creating and Editing Joints

To learn how to add a Universal joint to a model, please see the Joints topic.

1.	Once an Universal joint has been added to the model using any of the "entity" creation methods, the panel for the joint will automatically be displayed in the panel area. See the panel examples below:

universal_joint_panel_conn_tab_mv

Joints Panel (Universal Joint) – Connectivity Tab - Single Entity - Shaft Orientation

universal_joint_panel_conn_tab_crosspin_mv

Joints Panel (Universal Joint) – Connectivity Tab - Pair Entity - Crosspin Orientation

2.	The joint definition needs two bodies which are connected by the joint. From Connectivity tab, select Body 1 by picking the body from the graphics area, or double click the Body 1 collector to open to the model tree (from which the desired body can be selected).

3.	Similarly, pick Body 2 from the graphics area by clicking on the desired body (or use the collector and model tree method).

4.	Select the Origin Point from the Project Browser, or the graphics area, to specify the point of origin for the joint.

5.	Define the orientation of the shafts of the joint by selecting Shaft or Crosspin (or a combination of both) from the Orient using drop-down menus.

universal_joint_panel_crsspn_shft_example_mv_ug

The figure below shows the geometries that are oriented using the two different schemes:

universal_joint_crosspin_and_shaft_example_mv_ug

Universal joint using Shaft and Crosspin

6.	Use the corresponding drop-down menus and collectors to specify the Shaft or Crosspin orientations using either of the following methods:

-	Points - Select a Point that defines the Alignment axes for the shafts/bodies connected by the joint.

-	Vectors – Global axes can be used for vectors by clicking on the desired axis (X, Y, or Z) in the graphics area (or by browsing through the model tree).

alignment_axis_vector_example_mv

7.	Optionally, you can specify frictional properties for the joint. Activate the Use Friction check box on the Friction Properties tab. The attributes related to the Universal joint friction are shown below:

universal_joint_friction_properties_tab_mv_ug

Joints panel - Friction Properties tab

Checking the Use Friction option displays a set of input fields which you need to specify as needed by the friction model of the solver. In addition, the LuGre Parameters tab also appears if the SolverMode is set to MotionSolve.

universal_joint_lugre_param_tab_mv_ug

Joints panel - LuGre Parameters tab

For additional details on the various fields in the Friction Properties and LuGre Parameters tab, please refer to the Joints Panel – Friction Properties Tab and Joints Panel - LuGre Parameters Tab topics.

Based on the joint selection, the relevant fields will be displayed in the Friction Properties tab. These fields are populated by default values as shown above. You can click the Restore Default Values button in the LuGre Parameters tab in order to populate default LuGre parameters.

Note - The same steps as shown above can also be used to define Pair Cylindrical joint entities. When defining a Pair Cylindrical joint use pair entities for Body 1, Body 2, Origin, etc.

1.	Left click the Joints panel icon on the Constraint toolbar.

The Project Browser will filter the entities and display only the joints in the model.

2.	Select the desired joint in the Project Browser.

The corresponding panel is automatically displayed.

3.	From the Connectivity tab, use the Joint type drop-down menu to change the joint type, or use the collectors to change the bodies and origins/alignment points of the joint.

universal_joint_drop_down_menu_mv_ug

Joints panel - Connectivity tab - joint type drop-down menu

Universal Joint in MDL and XML Formats

The model containing the Universal joint can be saved in MDL format from MotionView and exported in the MotionSolve XML format.

The Universal joint can be of the following types:

1.	Non-Compliant - Single and Pair

2.	Compliant – Single and Pair

These four types of entities can be added to the model using MDL Statements shown below:

Syntax:

*UJoint(joint_name, "joint_label", body_1, body_2,

origin,

SHAFT|CROSSPIN,

POINT|VECTOR,

point_1|vector_1,

SHAFT|CROSSPIN,

POINT|VECTOR,

point_2|vector_2,

[ALLOW_COMPLIANCE])

To understand the complete syntax of the MDL statement please refer to the *UJoint topic.

To set the friction properties of the joint, the MDL statements to be used are: *SetJointFriction() and *SetJointFrictionLugre().

Syntax:

*SetJointFriction(varname, use_friction, mu_static, mu_dynamic, use_static, transition_vel, max_deformation, effect, preload_input, reaction_force_input, bending_moment_input, torsional_moment_input, f_preload, reaction_arm, initial_overlap, overlap_delta, rot_constraint, t_preload, pin_radius, friction_arm, bending_reaction_arm, ball_radius )

*SetJointFrictionLugre(varname, bristle_stiffness, damping_effects, viscous_effects )

Note - These two statements for friction are common for all of the joints where friction can be applied. However, a few of the fields might not be applicable to certain joints.

Syntax:

*UJointPair(joint_name, "joint_label", body_1, body_2,

origin,

SHAFT|CROSSPIN,

POINT|VECTOR,

point_1|vector_1,

SHAFT|CROSSPIN,

POINT|VECTOR,

point_2|vector_2,

[ALLOW_COMPLIANCE])

To understand the complete syntax of the MDL statements please refer to the *UJointPair topic.

To set the friction properties of the joint, the MDL statements to be used are: *SetJointFriction() and *SetJointFrictionLugre().

Syntax for symmetric joint pair:

*SetJointFriction(varname, LEFT|RIGHT, use_friction, mu_static, mu_dynamic, use_static, transition_vel, max_deformation, effect, preload_input, reaction_force_input, bending_moment_input, torsional_moment_input, f_preload, reaction_arm, initial_overlap, overlap_delta, rot_constraint, t_preload, pin_radius, friction_arm, bending_reaction_arm, ball_radius )

*SetJointFrictionLugre(varname, bristle_stiffness_l, damping_effects_l, viscous_effects_l, bristle_stiffness_r, damping_effects_r, viscous_effects_r)

Syntax for asymmetric joint pair:

*SetJointFriction(varname, , use_friction_l, mu_static_l, mu_dynamic_l, use_static_l, transition_vel_l, max_deformation_l, effect_l, preload_input_l, reaction_force_input_l, bending_moment_input_l, torsional_moment_input_l, f_preload_l, reaction_arm_l, initial_overlap_l, overlap_delta_l, rot_constraint_l, t_preload_l, pin_radius_l, friction_arm_l, bending_reaction_arm_l, ball_radius_l, use_friction_r, mu_static_r, mu_dynamic_r, use_static_r, transition_vel_r, max_deformation_r, effect_r, preload_input_r, reaction_force_input_r, bending_moment_input_r, torsional_moment_input_r, f_preload_r, reaction_arm_r, initial_overlap_r, overlap_delta_r, rot_constraint_r, t_preload_r, pin_radius_r, friction_arm_r, bending_reaction_arm_r, ball_radius_r )

Note - These syntax for the LuGre parameters statement for an symmetric joint pair is identical to its symmetric counterpart. MotionView will ignore the part of the statement that belongs to the dependent side of the joint and replicate it with the parent side parameters.

To learn how to create a complete model using MDL Statements please refer to tutorial MV-1060: Introduction to MDL.

The Universal joint when exported to the MotionSolve XML format is defined as a Constraint_Joint statement.

Syntax:

<Constraint_Joint

id = "integer"

label = "Name of Joint"

type = "JOINT TYPE"

i_marker_id = "integer"

j_marker_id = "integer"

In case of the Universal joint the model statement will be as shown below:

<Constraint_Joint

id = "301001"

label = "Universal Joint"

type = "UNIVERSAL"

i_marker_id = "30103050"

j_marker_id = "30101050"

In the above XML Model statement the i_marker_id and j_marker_id represent the I and J markers of the Joint which belong to Body 1 and Body 2 respectively. To understand the complete syntax of the Constraint_Joint XML model statement, please refer to the MotionSolve Reference Guide Page for Constraint_Joint.

Creating a Universal Joint using the Tcl Command Layer

In MotionView, the Tcl command layer can be used to add any MDL entities to the model. There are two Tcl commands that can be used to add an entity:

Syntax:

mdlmodel_handle InterpretEntity new_handle keyword varname label

In case of the Universal joint the statement will look as shown below:

mdlmodel_handle InterpretEntity UJt_handle UJoint j_uj "\"U Joint\"" b_1 B_Ground p_ori "SHAFT" "POINT" p_ori1 "CROSSPIN" "VECTOR" v_1 "ALLOW_COMPLIANCE";

Syntax:

mdlmodel_handle InterpretSet keyword tokens

Example:

mdlmodel_handle InterpretSet SetJointFriction j_uj true mu_static mu_dynamic use_static transition_vel max_deformation effect preload_input reaction_force_input bending_moment_input torsional_moment_input f_preload reaction_arm initial_overlap overlap_delta rot_constraint t_preload pin_radius friction_arm bending_reaction_arm ball_radius

mdlmodel_handle InterpretSet SetJointFrictionLugre j_uj bristle_stiffness damping_effects viscous_effects

The InterpretEntity command is used to add entities to the model and the InterpretSet command is used to set the entity properties. So in the case of the Universal joint, the properties that can be set are the joint friction. Extended definitions for InterpretEntity and InterpretSet can be found in the HyperWorks Desktop Reference Guide.

Note - When using the InterpretEntity and InterpretSet commands, it is important to also use the Evaluate command in order for the changes to take effect immediately.

To learn how to create a complete model using Tcl commands, please refer to tutorial MV-1040: Model Building Using Tcl.

Example Models

The example file below shows a Universal joint connecting two bodies:

*BeginMDL( the_model, "Model", "12.0.110.26" )

*StandardInclude(FILE)

*PointPair( p_sjorigin, "Pair joint origin" )

*Point( p_b1cg, "Body 1 CG" )

*Point( p_b2cg, "Body 2 CG" )

*Point( p_jor, "Joint origin" )

*Body( b_1, "Body 1", p_b1cg, , , , )

*Body( b_2, "Body 2", p_b2cg, , , , )

//Universal joint - single using CROSSPIN orientation

*UJoint( j_uj, "Universal Joint", b_1, b_2, p_jor, CROSSPIN, VECTOR, V_Global_Z, CROSSPIN, VECTOR, V_Global_Y )

//Universal joint - pair using SHAFT orientation

*UJointPair( j_pujoint, "Universal Joint Pair", b_a, b_b, p_sjorigin, SHAFT, POINT, p_ori1, SHAFT, POINT, p_ori2 )

*PointPair( p_ori1, "Orient point 1" )

*PointPair( p_ori2, "Orient point 2" )

*BodyPair( b_a, "Body A", p_bodyA_cg, , , , b_a.cm )

*BodyPair( b_b, "Body B", p_bodyB_cg, , , , )

*PointPair( p_bodyA_cg, "Body A CG" )

*PointPair( p_bodyB_cg, "Body B CG" )

*VectorPair( v_ori1, "Orient vector 1" )

*VectorPair( v_ori2, "Orient vector 2" )

*SetPoint( p_ori1, LEFT, -100, -50, -25 )

*SetPoint( p_sjorigin, LEFT, , -50 )

*SetPoint( p_ori2, LEFT, 100, -50, 0 )

*SetPoint( p_bodyA_cg, LEFT, -50, -50, -12.5 )

*SetPoint( p_bodyB_cg, LEFT, 50, -50 )

*Set( b_a.usecm, true )

*Set( b_b.usecm, true )

*SetVector( v_ori1, LEFT, -0.2425, 0, 0.9701 )

*SetVector( v_ori2, LEFT, 0, 1, 0 )

*SetPoint( p_b1cg, -50, , -12.5 )

*SetPoint( p_b2cg, 50 )

*Set( b_1.usecm, true )

*Set( b_2.usecm, true )

//Setting joint friction using SetJointFriction - Single

*SetJointFriction( j_uj, true, 0.32, 0.26, ACTIVE_STATIC, 0.11, , STICTION_ONLY, PRELOAD, REACTION_FORCE, BENDING_MOMENT, , , , , , I_YOKE, 1000, 5, 10, 3 )

//Setting joint friction using SetJointFriction - Symmetric Pair

*SetJointFriction( j_pujoint, LEFT, true, , , ACTIVE_STATIC, , , , PRELOAD, REACTION_FORCE, BENDING_MOMENT, , , , , , I_YOKE, 1000, 5, 10, 25, )

//Setting joint friction using SetJointFriction - Asymmetric Pair

*SetJointFriction( j_pujoint, , true, , , ACTIVE_STATIC, , , , PRELOAD, REACTION_FORCE, BENDING_MOMENT, , , , , , I_YOKE, 1000, 5, 10, 25,

, true, 0.3, 0.25, ACTIVE_STATIC, 0.1, 0.01, STICTION_AND_SLIDING, PRELOAD, REACTION_FORCE, BENDING_MOMENT, TORSIONAL_MOMENT, 0.0, 1.0, 1000.0, CONSTANT, J_YOKE, 1500, 4, 8, 30, 1.0 )

//Setting joint friction LuGre parameters using SetJointFrictionLugre - Pair

*SetJointFrictionLugre( j_pujoint, 100.0, 0.316, 0.0004

, 100.0, 0.316, 0.0004 )

*EndMDL()