2. The Seesaw/Pendulum Process
In this section, we will illustrate how the symbolic capabilities of Mathematica can be used to derive a model of a nonlinear system. Using MathCode C++, the large symbolic expressions in the nonlinear model are then converted to C++ code and used to simulate the system very efficiently. The system is a laboratory process frequently used in control education known as the seesaw/pendulum process. One implementation of the seesaw/pendulum process has been developed by Quanser Consulting (www.quanser.com).
The process consists of a seesaw, two carts called and , two parallel tracks, an inverted pendulum, and a weight. Each cart can be driven by a DC motor controlled by an input voltage. Cart carries the weight and cart carries the inverted pendulum attached by a friction-free joint. The carts can be moved along the tracks by controlling the input voltages of the DC motors.
We start by modeling the open loop system, that is, without any feedback from measured signals. The forces and acting on each cart are chosen as inputs. We will use the Lagrangian methodology to obtain a nonlinear model of the system and then linearize it. The linearized model is used for control system design where the Control System Professional application package is used. The closed-loop system is then simulated both within Mathematica and by external code generated using MathCode C++.
Figure 1. The pendulum/seesaw process.
In Figure 1 we introduce names of variables and constants describing the pendulum/seesaw process.
The physical values of the above constants are stored as rules in Mathematica to be used in later simulations.
Following the Lagrangian methodology , the system is divided into a number of subsystems whose potential energy and kinetic energy are computed in terms of the generalized coordinates introduced in Figure 1. The Lagrangian, which is the difference between the total kinetic and potential energy, can then be used to derive the equations of motion for the system.
Computation of the Lagrangian
Coordinates of the center of mass of the seesaw:
The potential and kinetic energies of the seesaw:
Coordinates of the center of track:
Coordinates of cart 1:
The potential and kinetic energies of cart 1:
Coordinates of cart 2:
The potential and kinetic energies of cart 2:
Coordinates of the center of mass of the pendulum:
The potential and kinetic energies of the pendulum:
The total potential energy:
The total kinetic energy:
The Lagrangian of the system:
Computation of the Equations of Motion
The equations of motion are given by the partial differential equations that must satisfy
where is the Lagrangian, are the generalized coordinates, and are the generalized forces associated with each coordinate. In this case, the quadruple corresponds to and , , . We derive each equation and simplify it.
These equations are coupled ordinary differential equations (ODEs) of second-order in the generalized coordinates . To rewrite these in standard state-space form (a system of first-order ODEs) we introduce the following states:
The inputs to the system are
We observe that the second-order time derivatives of the positions and angles appear linearly, which makes it easy to solve for these in terms of the states. Second-order time derivatives will always appear linearly in the equations derived from the partial differential equation (6) that the Lagrangian of the system has to satisfy. This is due to the fact that the Lagrangian only consists of at most first-order time derivatives and the second-order derivatives appear according to the chain rule when differentiating the term in equation (6) with respect to time.
Solve for second-order derivatives.
These solutions will become a part of the right-hand sides of the differential equations used for simulating the system.
We introduce conversion rules to get rid of explicit time dependence. This makes some expressions look simpler and takes less space.
We compute the right-hand side of the nonlinear state-space form (equation (1)) of the equation
which becomes very large! Observe that the first four entries in f correspond to pure integrations. This allow us to write the model as a system of first-order differential equations as desired.
The Linearized Model
Since we will design a controller using methods for linear systems, we need to linearize the nonlinear state space model of the system around the origin.
This can easily be obtained using the
We extract the matrices from the linearization and substitute with the physical values of the parameters to get numerical entities.
The linear model of the system allows us to use standard methods for controller design.
The method for computing the feedback law requires the linear model to be controllable. This implies that the system can be
stabilized and that the method will find a numerical instantiation of such that this is obtained. To check controllability we use the
Compute a full state feedback controller using the LQG-method (
The control law to be used is , where are measurements of the states. This gives the following closed loop system to simulate .
Simulation and Code Generation
We store the states as a vector.
We close the feedback loop, which gives the following right-hand side of the state-space equations.
Change the names of variables to only ASCII characters (needed for code generation).
The right-hand side of the closed-loop state-space equations (intended for code generation).
We define the function
Simulation of the Nonlinear Model within Mathematica
We define to be a short notation for the
The state vector is defined.
The differential equations for the closed-loop system is given.
We need to specify some initial conditions for the simulation. Assume that cart 1 is positioned at -1, the seesaw is horizontal, cart 2 is positioned at +1, and the pendulum has a small deviation of 5.7° from the vertical axis. Furthermore, assume that the system is at rest at these positions (all time derivatives are zero).
Nonlinear System Simulation
We simulate the system using
Linear System Simulation
We simulate the linear system using
Plot the result for the first four state variables from the nonlinear simulation together with the result for the linear system.
Figure 2. Initial value response for the linear (red) and nonlinear (blue) systems.
We notice that the linear response differs significantly from the nonlinear one. The difference between the linear and nonlinear response will be much smaller if the initial values are chosen to be smaller since the linear model only is a good approximation for small values of the states and inputs.
External Simulation of the Nonlinear Model
To generate simulation code to be run outside Mathematica, we have to provide a differential equation solver that can be compiled or linked when the executable program is generated. In this case, we have chosen to implement a very simple Runge-Kutta solver in Mathematica, which will be included in the generated code. Another solution could be to use a solver from a publicly available software library like the solvers at www.netlib.org.
Code for External Simulation of the Nonlinear Model
Here follows an implementation of a state equation solver using the Runge-Kutta method.
To get a correct estimate of the time spent by the external code for simulating the system, we define the following functions that repeat the external simulation n times.
We are now ready to compile the package. The right-hand side of the state equations are optimized using common subexpression elimination.
The corresponding code can be inspected in a text editor.
All necessary files for building binaries are now generated. The
To use the generated code for the simulation, we only have to install the code using the
External Simulation: Uncompiled Code (Computations within Mathematica)
We plot the result to verify the Runge-Kutta solver.
Figure 3. Initial value response for the nonlinear system computed internally by Mathematica.
External Simulation: Compiled Code (External Computations)
We install the executable code.
The external simulation is performed 200 times to get an accurate measure of its timing.
We plot the result to verify the compiled Runge-Kutta solver.
Figure 4. Initial value response for the nonlinear system computed by the external code.
The responses in Figure 3 and Figure 4 are identical.
The difference in performance between the uncompiled and compiled version of the ODE solver is 1419.03.
A somewhat unfair comparison between the timings of the built-in ODE solver and the compiled solver gives 15.8667.
Uninstall the code and delete the temporary files.
Remove the functions for which we have generated code.
Unset the symbol f storing the right-hand side of the state-space equations.
Copyright © 2001 Wolfram Media, Inc. All rights reserved.