Creating system model with ModelBuilder 

Shown below is the ModelBuilder model of the single pendulum.  Rigid bodies 

and flexible beams are represented by blocks, and inter-body connections 

(joints, springs, dampers, forces, moments) are represented by arrows.  The 

arrows connect reference frames that are fixed on each body; these frames are 

shown as circles on the body to which they are affixed.  The international symbol 

for the center of mass designates the primary reference frame on each rigid body. 

The position and orientation of any other frame on the body is defined relative 

to this primary reference frame. 

The directions of the arrows are significant; the motion associated with the arrow 

is the relative motion of the frame at the head (end) of the arrow with respect to 

the frame at the tail (start) of the arrow.  The arrow shown in the figure below is 

the revolute joint connecting the pendulating body to the ground; the coordinate 

corresponding to this element is θ, the rotation of the body with respect to ground. 

Generating and examining system equations 

Once a DynaFlexPro input file has been created, one should open a Maple worksheet 

and load the DynaFlexPro package: 

>

restart:

 

>	with(DynaFlexPro);

 

After DynaFlexPro has been loaded, the BuildEQs command can be called to automatically 

generate the kinematic and dynamic equations of motion for the system described in the input 

file "Pendulum.dfp" in the Examples sub-directory.  The BuildEQs command has several 

optional parameters for controlling the form of the generated equations: 

>	Model:= BuildEQs("Examples/Pendulum.dfp",["DynSimpType", "Simplify"]):

 

The system model has been stored in the module "Model".  One can then access different 

portions of the Model, e.g. the generalized coordinates vQ and speeds vP in which the equations 

have been generated (which are also listed above), or the state variables vX: 

>	Model:-vQ;

 

>	Model:-vP;

 

>	Model:-vX;

 

One can load the Model module, in order to see the data and functions that can be exported 

from it: 

>	with(Model);

 

As listed, there are many functions and data available for examining different features of the 

symbolic model.  The GetDynEQs function returns the dynamic equation, which is easily 

validated by a hand derivation using the Newton-Euler or Lagrange equations: 

>	ODE:=GetDynEQs();

 

The equations for this system take the general form of  ,  where is the mass matrix, 

are the generalized speeds (vP), and contains external loads and quadratic velocity terms. 

Matrix data in the Model module are prefaced by an "x", while vector data are prefaced by a "v". 

Thus,  the mass matrix is given by:  

>

xM;

 

As expected, the mass matrix is a single scalar; it represents the moment of inertia of the 

pendulum about the joint axis of rotation, which is quickly validated using the parallel axis 

theorem.  The column matrix is the resultant moment about the joint axis, due to the weight: 

>

vF;

 

The GetFrameMotion function provides kinematic information (position,  orientation, and their 

derivatives) about any frame in the system.  For example, the position vector from the ground 

frame to the center of mass frame, resolved in XYZ components along the ground frame, can 

be automatically expressed in terms of vQ: 

>	GetFrameMotion("r","CoM","Ground","Ground");

 

Note that the frame names "Ground" and "CoM" were specified by the user in the ModelBuilder model. 

Simulating the dynamic response 

As for most dynamic systems, the governing differential equations of motion are nonlinear.  In 

this case, one can search for analytical solutions in the form of Bessel equations.  However, it 

is often more useful to proceed to a numerical solution of the differential equations, using Maple's 

built-in numerical integrators. 

Start by specifying numeric values for the symbolic parameters and defining the initial conditions. 

In this case, the pendulum is released from rest from a horizontal position. 

>	L := 1: m:= 1: Izz:= 1: G:=9.8:

 

>	SysEqns:= [ODE[1], D(theta)(0)=0,theta(0)=Pi/2];

 

One can now numerically integrate the differential equation of motion, subject to the given initial 

conditions, and plot the results for the pendulum angle versus time: 

>	Soln := dsolve(SysEqns, numeric, range=0..4):

 

>	plots[odeplot](Soln, [[t,theta(t)*180/Pi]],0..4,

 

>	title= "Angle (deg) versus Time",

 

>	labels = ["time (s)", "angle (deg)"]);

 

Now that the generalized coordinates and speeds are known as functions of time, other 

motions can be computed.  For example, using GetFrameMotion to generate the motion of 

the center of mass frame relative to the ground, the circular trajectory of the mass center 

can be plotted: 

>	plots[odeplot](Soln, [GetFrameMotion("r","CoM","Ground","Ground")[1],

 

>	GetFrameMotion("r","CoM","Ground","Ground")[2]],

 

>	t=0..4, labels=["x","y"], scaling=constrained,

 

>	title="Trajectory of mass center");

 

>

 

>