LECTURE NOTES
Describing Function Analysis Using MATLAB and Simulink
By Carla Schwartz and Richard Gran
O
ne of the earliest examples of feedback control is
the escapement mechanism that provides the
forces required to keep a mechanical clock properly synchronized. Many famous mathematicians and physicists analyzed escapements during the 17th and 18th
centuries.
This article uses computer-aided design tools to develop
a describing function analysis of a pendulum clock. We design the escapement as a control system that allows the pendulum to provide the required time keeping and, at the same
time, add enough energy to the pendulum to overcome the
damping caused by friction.
We use analysis tools in the MATLAB Control System
Toolbox to accomplish the design and analysis. A by-product of our analysis is a simple MATLAB/Simulink model and
a script that generates describing functions for any arbitrary nonlinear system (including systems with multiple
nonlinearities and with frequency-dependent describing
functions). We also develop a Simulink model of the clock to
verify the results of the analysis.
The analysis described here uses some object-oriented
programming features of MATLAB. Using a linear time-invariant (LTI) system object that is part of MATLAB’s Control
System Toolbox, we were able to integrate the describing
function frequency response data with the transfer function
of the clock mechanism in a natural way.
Although these types of clock mechanisms are no longer
designed, the computer-aided design techniques described
here can be applied to controlling or predicting oscillations
(limit cycles) in other nonlinear systems. The describing
function analysis we present is applicable to a variety of
nonlinear problems. Furthermore, it is always interesting to
understand the history of control system developments in
the abstract, and a clock is surely one of the earliest devices
to be controlled and analyzed using the mathematics that
controls engineers now take for granted.
We begin with a brief history and a description of pendulum clocks. We then develop a model of the clock using a simulation tool such as Simulink and use this simulation to
understand the problem. We then present a simple code that
combines MATLAB and Simulink to compute the describing
function. The describing function is then encapsulated in a
frequency response object that is combined with the transfer
functions of the pendulum and the escapement to allow a
classical Bode plot analysis. The result of the analysis is a
feedback gain for the escapement that will ensure the
pendulum swings at the desired frequency and amplitude.
The results of the analysis are then verified by simulation.
History of Pendulum Clocks
Timekeepers that use either the sun or water have been
built since at least 1400 BC. Sundials provided daylight time
keeping, while at night, in some civilizations, water clocks
were used. For example, the Egyptians had a “Clepsydra”
(from the Greek kleptei, to steal, and hydor, water) that consisted of a bucket with a hole. When filled with water, the water level was a measure of the elapsed time.
The first mechanical clocks appeared in the 13th century,
with the earliest known device dating to about 1290. The inventor of the first clock is unknown, but the main development that made these devices possible is not—it is the
escapement.
An escapement is a gear with steep sloping teeth. Originally, the escapement provided a set of teeth that would
“escape” from another gear as the pendulum oscillated.
Figure 1. A typical pendulum clock (from [1]).
Gran ([email protected]) is with Mathematical Analysis Co., 409 Birchington Lane, Melbourne, FL 32940, U.S.A. Schwartz is an independent contractor. The MATLAB code and the Simulink models used in this article can be obtained by e-mail from Gran.
August 2001
0272-1708/01/$10.00©2001IEEE
IEEE Control Systems Magazine
Authorized licensed use limited to: University of Michigan Library. Downloaded on May 19,2010 at 20:38:51 UTC from IEEE Xplore. Restrictions apply.
19
This escape caused a count to be registered by the clock.
Later it was realized that the escapement could
also impart energy to the oscillating pendulum
to keep it going.
Christiaan Huygens invented the escapement, shown in Fig. 1, in 1656. This type of
mechanism was responsible for the emergence of accurate mechanical clocks in the
18th century. The mechanism uses the escapement (parts 9-15 ) to achieve its accuracy.
With the pendulum as the time reference, and the escapement providing the regulation, Huygens was able to
build a clock that was accurate to within 10 seconds per day.
Previous clocks could vary by more than an hour if they
were not reset daily because the mechanisms did not have
the regulation capability of the Huygens escapement. They
would slow down as the springs or weights that drove the
clock lost energy.
Mechanics of a Pendulum Clock
How does an escapement work? The pendulum is mounted
on a rigid structure in the clock called a “back cock” (Fig. 1,
(1)). This structure allows the pendulum to swing freely, unencumbered by the mechanism that drives the hands and
the escapement. The pendulum suspension (2) is carefully
designed to allow the pendulum to swing with minimal friction. The escapement imparts its force to the pendulum
through the crutch (3) and the crutch pin
(4). The pendulum itself (5 and 7) moves
back and forth with a period that is determined solely by its length (as shown by Galileo Galilei in 1582). The pendulum includes a
nut (8) at its bottom that can be adjusted to
change the effective length, thereby adjusting the period of the pendulum.
The escapement wheel (9) is linked to all of
the gears in the clock (both the hands and the
windings) through gears not shown in the figure. The
escapement wheel is the mechanism we are designing here.
For the remainder of this description, we focus on the escapement anchor (13) and its two sides. On the left side of the
anchor is a triangular face called the entrance pallet (12) and
on the right side is the exit pallet (15). As the pendulum
moves to the left, it forces the anchor to rotate and ultimately
disengage its face (11) from the escapement wheel (9). When
it does, the exit pallet (15) engages the next tooth of the escapement wheel and the gears move. If the pendulum is set to
swing at a period of 1 s, the result of the motion of the escapement gear is to move the hands on the clock by one. When the
right face of the anchor engages the gear at (15), the anchor
and the escapement wheel interact. The escapement wheel,
which is torqued by the winding mechanism, applies a force
back through the anchor, and then through the crutch and
crutch pin (3 and 4), to the pendulum. The alternate release
Pend. Angle
Escapement
Dynamics
Design Gain
Pendulum Angle
Force
Force
Esc. Accel.
-K-
100
s+100
Escapement
Model
Theta2dot
Esc. Accel.
Esc. Spring Accel.
Damping Accel.
Gravity Accel.
Pend. Angle
Damping Accel.
1
s
dampcoef
Thetadot
1
xo s
Initial
0.2 Pend.
Angle
c/(m*len^2)
Display
Variables
dampcoef=0.01
g=9.8
plength=0.2485
Gravity Accel.
1/plength
1/length
g*sin(u)
Pend. Angle
Gravity Force
g*sin(Theta)
Model of a Pendulum Clock
Design Problem: Specify the amplitude of the force (through the design gain block)
so the amplitude of the pendulum is 14° (0.2443 rad).
Figure 2. Simulink model for the pendulum clock. The subsystem block that contains the model of the escapement is shown in Fig. 3.
20
IEEE Control Systems Magazine
August 2001
Authorized licensed use limited to: University of Michigan Library. Downloaded on May 19,2010 at 20:38:51 UTC from IEEE Xplore. Restrictions apply.
and reengagement of the anchor and escape wheel provide
the energy to the pendulum that compensates for the energy
lost to friction. A by-product of this interplay of the pendulum
and the escapement wheel is the distinctive, and comforting,
“tick tock” sound that a clock makes.
Definition of the Describing Function
Assume the nonlinearity is denoted by f(x,t). The input
x(t) is assumed to be
x ( t ) = E sin (ωt ),
The Escapement as a Control System
To analyze the interaction of the pendulum with the escapement, the pendulum can be treated as the plant in a control
system with the escapement acting as a feedback control.
The escapement provides the energy to the pendulum so
the swing does not stop because of friction. The control also
compensates for variations in the force from the driver (the
winding springs or weights) and the wear in the various mechanical parts.
Thus, the clock model has two parts: 1) the plant model,
the pendulum, and 2) the controller model, the escapement.
The pendulum model comes from the application of Newton’s laws by balancing the force due to the acceleration
with the forces created by gravity. If the pendulum angle isθ,
the mass of the pendulum is m, the length of the pendulum is
l, the inertia of the pendulum is J (if we assume that the mass
of the pendulum is concentrated at the end of the shaft, the
inertia is given by J = ml2), and the damping force coefficient
is c (Newtons/rad/s), then the equation of motion of the pendulum is
Jθ&& + cθ& = mgl sin(θ ).
Equivalently, substituting for J, the model is
c
g
θ&& = − 2 θ& + sin(θ ).
ml
l
A Simulation Model for the Clock
The clock dynamics are simulated in the pendulum clock
Simulink model shown in Fig. 2.
This model was built using integrators, gains, a summing
junction, and a mathematical function block that calculates
the sine function.
The angular acceleration of the pendulum, Theta2dot, is
formed at the right of the sum block and is calculated using
the following three terms (clockwise in the summing junction starting at the output):
• The damping acceleration from the equation above
(dampcoef*Thetadot)
• The gravity acceleration from the equation above
(g/plength*sin(Theta))
• The acceleration created by the escapement.
The Simulink model creates the variables representing
the angular position and velocity, Theta and Thetadot, by integrating the angular acceleration Theta2dot. A pendulum
clock only sustains its oscillation if the pendulum is moved
August 2001
which results in the output
y( t ) = f ( E sin(ωt ), t ).
The describing function gain, K ( E,ω ), is the fundamental of the Fourier series representation of this periodic
output, y(t), divided by the input amplitude E. Thus, the
describing function gain is given by
T
K ( E ,ω ) =
2
f ( E sin(ωt ), t ) {sin(ωt ) + jcos(ωt )}dt .
TE ∫0
It should be easy to see how this definition is implemented in Fig. 4.
to an angle that causes the escapement to operate; consequently, an initial pendulum angle of 0.2 rad (about 11.5°) is
provided to start the clock.
The Simulink subsystem that models the nonlinear escapement mechanism is shown in Fig. 3.
The attributes of the escapement that are modeled are:
• The angle of the pendulum at which the escapement
engages (applies an acceleration) is denoted by
Penlow (this has a value of 0.1 rad).
• Penhigh denotes the angle of the pendulum at which
the escapement disengages (jumps from one tooth to
the next; its value is 0.15 rad).
• The force is applied only when the pendulum is accelerating (i.e., when the pendulum angle has a derivative that is positive).
• Since the pendulum motion is symmetric, calculations are only made for positive angles (the absolute
value function block in Fig. 3). The force applied is
given the correct sign by multiplying it by +1 or −1, depending on the sign of the angle.
The Escapement Control Design Problem
The design problem is to create an escapement gear whose
tooth slope imparts enough force into the pendulum at every swing to maintain its oscillation but at the same time limits the force so that the pendulum’s swing does not hit the
clock’s case. Using the Simulink model in Fig. 2, this problem
can be interpreted in terms of selecting the value of the parameter Design Gain. This parameter can be readily converted into a slope on the escapement gear’s teeth.
IEEE Control Systems Magazine
Authorized licensed use limited to: University of Michigan Library. Downloaded on May 19,2010 at 20:38:51 UTC from IEEE Xplore. Restrictions apply.
21
This control gain must be adjusted so that the system is unstable (i.e., oscillates), and the oscillation must also be small
enough so that the pendulum doesn’t hit the walls of the clock.
We have established that the pendulum oscillation
should be 0.24 rad (or about 14°) to have the swing remain
within the clock case. This amplitude is arbitrary, but for
the escapement to work, it must be greater than
the value Penhigh in the Simulink model for the escapement (Fig. 3).
The parameter Design Gain value must also be
sufficiently large so that the pendulum sustains the
oscillation while the driving force drops as the
spring on the clock unwinds.
The units of the gain are radians per second
squared (rad/s2) per unit input (length over inertia).
Another attribute of the escapement, also modeled in Fig. 2, is the spring dynamics associated with
the escapement. These dynamics can be quite complex. Fortunately, the clock doesn’t require that these dynamics be
modeled accurately. A simple first-order time constant (of
0.01 s) is used to model the escapement spring dynamics.
Finding the Gain Using
Describing Function Analysis
The describing function for a nonlinear system is a gain that
is derived by forcing the nonlinearity with an input of the
form E sin(ωt ). The resulting output of the nonlinearity is a
periodic function that can be analyzed using a Fourier series. The first sinusoidal component (the fundamental) of
this series is used to define the describing function gain.
This gain always depends on the input amplitude and sometimes on the input frequency (see “Definition of the Describing Function” on the previous page).
Describing function methods have traditionally been used as a technique for predicting limit cycles in systems with nonlinearities
(see [2]-[4]).
Despite these dependencies, we can treat the
describing function as a linear gain for the purpose
of this analysis. The gain depends on the amplitude
of the input, so when the oscillation is predicted for
the system, the amplitude of the oscillation will also
be determined. We will use the describing function to
predict the value of the amplitude using the parameter Design Gain that results in the desired sustained oscillation.
When a nonlinearity is embedded in a system, it may
seem odd to use sinusoidal inputs to analyze the response.
This procedure is justified whenever the nonlinear dynamics are such that the output of the nonlinear element is filtered in such a way that the higher frequencies are
negligible. That is indeed the case for the clock model, as a
result of the pendulum and escapement dynamics.
Restore
Sign
1
Pendulum
Angle
|u|
<= =1 When Angle < Penhigh
Abs
0.15 Penhigh
1
Force
>=
=1 When Angle > Penlow
0.1 Penlow
Product1
=1 When Angle Decreasing
du /dt
<
Derivative
0
Relational
Operator3
Penlow1
Model of Escapement
Force = 1 when Pendulum Angle is between Penlow and Penhigh and decreasing
Figure 3. Simulink subsystem that models the escapement dynamics.
22
IEEE Control Systems Magazine
August 2001
Authorized licensed use limited to: University of Michigan Library. Downloaded on May 19,2010 at 20:38:51 UTC from IEEE Xplore. Restrictions apply.
Amplitude
Vector "E"
from
Workspace
E'*u
Division by 2T
Nonlinearity
Under Test
23
In1
In2
pi./omega1
Stop Simulation
at the End of One Cycle
23
23
sin(omega1*t)
1
s
23
f(t)*cos
23
23
cos(omega1*t )
1./E/T
23
E
Trigger at Stop
23
Divide by E to get DF
23
In1
23
In2
Save Data
–1
23
–sin(omega1*t)
23
–f(t)*sin
1
s
23
23
23
1./E/T
Gain
pi./omega1
Divide by 2T
Figure 4. Simulink “GenerateDescribingFunction” model used to calculate the describing function for a fixed ω.
Computing Describing Functions
for Nonlinear Models
A combination of MATLAB and Simulink is used to compute
the describing function of the nonlinear model. The model,
called GenerateDescribingFunction, is shown in Fig. 4. This
model implements the mathematical definition of the describing function shown in the sidebar. This model is executed from within the function GetDF.m, which is written in
MATLAB (Fig. 5). The use of Simulink to calculate the describing function provides a visual aid for both the understanding
of the calculation and for subsequent analyses.
It is easy to peruse Fig. 4 and understand what one is calculating and what one needs to change to calculate the describing function for a different nonlinearity. The reader
should be able to easily extract from Figs. 4 and 5 a method
for calculating a describing function for any nonlinearity. To
use the Simulink model and the MATLAB function to generate the describing function for any nonlinearity you choose,
follow this procedure:
• Substitute the model of your nonlinearity for the block
l a b e l e d “ N o n l i n e a r i t y U n d e r Te s t ” i n t h e
GenerateDescribingFunction Simulink model.
• Specify the vector of amplitudes, E, and frequencies,
omega, in the file GetDF.m.
• Type GetDF at the command line.
title('Describing Function Amplitude vs. Frequency and Amplitude of Input')
figure(2)
surf(E,omega,angle(s))
shading interp
ylabel('Frequency (rad/sec)'); xlabel('Amplitude');
zlabel('Describing Function Phase')
title('Describing Function Phase vs. Frequency and Amplitude of Input')
Figure 5. MATLAB code that generates the describing function
from the Simulink model of Fig. 4.
• Zero-pole gain model
• State-space model
Designing the Escapement
with MATLAB and Simulink
The MATLAB Control System Toolbox is used to analyze
the clock. This Toolbox can represent linear systems as LTI
objects; LTI objects store all of the data for an LTI model.
The object can be created in one of four forms:
• Transfer function model
August 2001
function [array]=GetDF(modelname)
% This function will generate a describing function for the nonlinear element
% in the Simulink block with the name given by the ASCII string modelname.
% To call the function, use:
%
output_array = GetDF('modelname')
% The output returned is an array whose dimensions are:
%
outputs by inputs by length(E) by length(omega)
%
where:
%
outputs = number of outputs from the nonlinearity
%
inputs = number of inputs into the nonlinearity
%
E is the vector of input amplitudes defined in this m-file
% omega is the vector of input frequnecies (in rad/sec) defined in this m-file
% To change E and omega, edit this m-file.
E=[[0.15:.01:0.25],[0.3:0.1:0.9],[1:.5:3]];
omega=[.5:.5:5 5.5:.1:6.2 2*pi 6.2:.1:7.5 7:.5:10];
Nf=length(omega);
array=zeros(1,1,length(omega),length(E));
s=zeros(length(omega),length(E));
for j=1:Nf
omega1=omega(j);
sim('GenerateDescribingFunction');
DF = (DFreal+sqrt(-1)*DFimag);
s(j,:)=DF;
array(1,1,j,:)=DF;
end
figure(1); surf(E,omega,abs(s))
shading interp
ylabel('Frequency (rad/sec)'); xlabel('Amplitude');
zlabel('Describing Function Gain')
• Frequency response data (frd) model.
The frd model stores frequency response data as a table
that consists of the complex amplitude at specified frequencies. If only frequency response data are available, you can
use frd models to represent linear system behavior in a feedback control system. As is the case for all MATLAB objects,
IEEE Control Systems Magazine
Authorized licensed use limited to: University of Michigan Library. Downloaded on May 19,2010 at 20:38:51 UTC from IEEE Xplore. Restrictions apply.
23
Describing Function Gain
you can apply the usual operations ∗, /, +, and − to concatenate frd models with any of the other LTI model types.
Because describing functions depend on the input amplitude (and possibly frequency), an frd object is an ideal way
to represent the describing function gain.
This is exactly what we do in the m-file GetDF, in which a
set of frd models is stored in the variable called “array.”
The code in GetDF.m collects the describing function
gain and phase data by driving the simulation with sinusoids at different frequencies and amplitudes. The amplitudes are all computed at once by vectorizing the Simulink
model. The frequency of the sine wave is changed in the loop
in the GetDF m-file.
The m-file then performs the following tasks:
• Drives the describing function Simulink models with
sinusoids whose amplitudes range from 0.15 to 3 rad.
• Collects the amplitude-dependent frequency response data in the variable “array,” which is then converted into a 1 by 1 frd object for every input
amplitude simulated.
3.5
3
2.5
2
1.5
1
0.5
0
10
8
6
4
2
Frequency (rad/s)
0
0
0.5
1
2
1.5
2.5
3
Amplitude
Describing Function Phase
(a)
–0.2
The result of running the GetDF m-file in Fig. 5 is the describing function shown in Fig. 6.
The describing function gain in Fig. 6(a) starts at zero
when the amplitude is zero and increases to a maximum
value, after which it decreases. Only the value of the gain after the maximum is plotted in Fig. 6 for clarity.
Let’s examine how the system operates in this region of
the gain plot (where the gain decreases as the input amplitude increases). When the system gain is set to the value at
which the system oscillates, the amplitude will be at some
value. If the system were to change so that the effective gain
decreased (as, for example, when the clock unwinds), then
in this region of the frequency response curve the describing function gain would increase. In a similar way, if the system gain were to increase (the user winds the clock), the
amplitude would increase and the describing function gain
would decrease. This reasoning implies not only that the oscillation is sustained, but that it is stable as well (in the sense
that the amplitude does not increase without bound).
For similar reasons, the region in which the describing
function gain increases as the amplitude of the input increases represents unstable oscillations. This particular
nonlinearity does not have a fundamental Fourier component that varies with frequency, so the describing function
gain is constant for all frequencies. However, it does have a
phase shift, so the describing function is complex. In [2], an
analytic representation of this function was developed, and
the results from this computation are the same.
Conditions for Sustained Oscillation
The conditions for having a sustained oscillation at a particular frequency ω 0 are that the signal that is fed back at the
summing junction (after the minus sign in Fig. 3) is exactly in
phase at this frequency. Mathematically, this is equivalent to
the condition that at the frequency ω 0 , the open-loop transfer function has unity gain and a phase of 180° or
–0.4
GH ( jω 0 ) = e jπ .
–0.6
–0.8
–1
–1.2
–1.4
–1.6
10
8
6
4
Frequency (rad/s)
2
0
0.5
0
1
1.5
2
2.5
3
Amplitude
(b)
Figure 6. The magnitude and phase of the describing function are
plotted as functions of the amplitude and frequency of the input.
24
Describing Functions and Oscillations
Therefore, to analyze the clock, we need to find the gain
at which this condition is satisfied and then use the describing function to calculate the amplitude of the oscillation that
this gain produces.
The variable array generated in the GetDF program is a
transfer function for each amplitude of the input. This is converted into an frd model using the command DFsys = frd(array,omega), where omega is the vector that contains the
frequencies at which the describing function was computed.
Once DFsys is available, it is concatenated with the transfer function of the pendulum and the spring and a frequency
response display tool called the “lti” viewer is opened to display the result. The code to do this is as follows:
IEEE Control Systems Magazine
August 2001
Authorized licensed use limited to: University of Michigan Library. Downloaded on May 19,2010 at 20:38:51 UTC from IEEE Xplore. Restrictions apply.
Bode Diagram
System: clocksys(:,:,16)
Frequency (rad/s): 6.28
Magnitude (dB): 0.413
System: clocksys(:,:,17)
Frequency (rad/s): 6.28
Magnitude (dB): –1.94
Bode Diagram
Magnitude (dB)
0
–50
–100
0
–90
–180
Phase (deg)
Phase (deg)
Magnitude (dB)
50
20
10
0
–10
–20
–30
–40
–50
–60
–70
–80
−45
−90
−135
–270
−180
–360
10
0
1
Frequency (rad/s)
10
−225
−270
Figure 7. Bode plots of all 23 models in the LTI array clocksys
using the LTI Viewer.
• dynamics = tf(1, [1 .01 (2∗pi)^2]) ∗ tf(100, [1 100]);
• clocksys = DFsys∗dynamics
• ltiview(‘bode’,clocksys)
These instructions create the model of the clock dynamics from the transfer function of the pendulum and the
spring and store the series combination in the object called
“clocksys.” Then the series combination of the describing
function and the transfer function is created. The operator
∗ used to perform this calculation is an overloaded method
that can be applied to these types of objects in MATLAB.
This operator behaves as the series concatenation of
transfer functions or systems (and frd arrays, as in the case
of DFsys).
Most operations in the Control System Toolbox are overloaded. The last instruction, for example, opens the lti
viewer, displaying the Bode plots of the entire set of LTI objects in the array DFsys to produce the plot in Fig. 7. There
are 23 plots, since the describing function was created for 23
values of the input E.
10
0
1
10
Frequency (rad/s)
Figure 8. The LTI Viewer displaying the Bode plots of the two
models corresponding to the input amplitudes that are just above
and below 0 dB.
0.2
Escapement Acceleration
0
–0.2
950
0.2
951
952
957
958
959 960
951
Escapement Spring Acceleration
952 953 954 955 956 957
958
959 960
951
952
Damping Acceleration
953 954 955 956 957
958
959 960
951
952
Gravity Acceleration
953 954 955 956
957
958
959 960
951
952
953
957
958
959 960
953
954
955
956
0
–0.2
950
0.2
0
–0.2
950
10
0
–10
950
0.5
0
–0.5
950
Pendulum Angle
954 955 956
Time
Analyzing the Array of
Frequency Response Data
Figure 9. Simulation results for the final design gain.
The Bode plots of Fig. 7 come from the display of the lti
viewer in MATLAB. When you import an array of LTI models
into the viewer, the plots for the entire collection of models
are displayed on the same plot.
In creating the transfer functions of the pendulum in the
previous section, we assumed that the value of Design Gain
was one. Among the array of Bode plots in Fig. 7 should be at
least one that has a 0 dB crossing with a phase shift that is
180°. If this is the case (and it is), then one of the Bode plots
will just have a gain of 0 dB when the phase is 180°. We need
to find this Bode plot and determine what input, E, it corresponds to.
Features of the lti viewer allow you to filter a set of Bode
plots for a set of models that have specified characteristics.
We can filter for those Bode plots that have a maximum that
is slightly below 0 dB and also slightly above 0 dB. Since the
describing function was determined for only a small number
(23 to be exact) frequencies, it is very likely that we do not
have precisely the input amplitude that would correspond
to exactly 0 dB.
Fig. 8 shows the Bode plot for the 12th and 13th inputs in
the array of frd models. These two Bode plots satisfied our
selection criteria. As can be seen, the phase rapidly changes
from about −50 to −250° within about 0.1 rad/s. Thus the
clock oscillation will be at the desired 6.28 rad/s (one second period).
August 2001
IEEE Control Systems Magazine
Authorized licensed use limited to: University of Michigan Library. Downloaded on May 19,2010 at 20:38:51 UTC from IEEE Xplore. Restrictions apply.
25
The range from the 12th to the 13th models corresponds
to amplitudes of pendulum swing between 0.3 and 0.4 rad,
which is too large (we want 0.24 rad).
Selecting the Gain
The last part of the analysis is to determine the value of the
Design Gain that will cause the oscillation to be 0.24 rad. The
array of Bode plots contains an input amplitude of 0.24 rad,
so we can look at this plot to find out how much higher than
0 dB its peak is at the 6.28 rad/s resonance. The Bode plot for
the tenth model in the frd array has a peak of 18.8 dB. Thus,
the required Design Gain is simply the amount that the peak
must be reduced to just have its value be 0 dB. From the fact
that the Bode gain is 20 log10(H(jω)), the gain needed to reduce the peak from 18.8 dB to 0 dB is
1
10
18 .8
20
= 01148
.
.
Simulating the Pendulum with the Design Gain
The simulation of Fig. 2 can now be modified to use the Design Gain of 0.1148 determined in the previous section.
When this is done, the results are shown in Fig. 9. The amplitude of pendulum oscillation is indeed 0.28 rad, and the frequency of oscillation is almost exactly 6.28 rad/s.
In fact, the simulation can be used to verify that the escapement controller has the desired properties of being insensitive to the driving force by varying the Design Gain up
and down. We have seen that as a consequence of the design, the only effect this will have is a change in the amplitude of the pendulum swing—the frequency of the
pendulum swing will not change.
Conclusions
We have provided a means for calculating describing functions using computational tools. We applied these techniques to the control design of a pendulum clock with a
nonlinear escapement gear. Using object-oriented techniques, we analyzed the feedback control system design using Bode plots, and from the plots calculated the required
escapement gain that could be used to design the escapement gear.
The use of computer-aided design tools for complex
control analysis and synthesis has been recognized for
some time. There are features of computer-aided design,
however, that to some extent are not fully appreciated by
the control community. This example, though relatively
simple, illustrates how a complex nonlinear system can be
analyzed with describing functions. The describing functions can be developed using the exact same tools we used
on this example.
From this exercise we were able to observe the following:
26
• The ability to analyze the system using both simulation and analysis tools is greatly enhanced if these
tools are the same.
• Object-oriented techniques aid in the analysis of nonlinear systems when describing functions are used.
• There is a significant coding advantage when a visual
environment is used.
It was not necessary that we use Simulink to compute the
describing function. We could have coded the calculation
using other languages; however, having done so we can easily reuse the code for generating describing functions for
other nonlinear systems. It is easy for any user to do so since
the visual representation allows the new user to rapidly
comprehend the code.
In our opinion, the reuse of computer code only takes
place when the new user can rapidly convince herself that
the code does what it is advertised to do. We believe that
this is the case for the Simulink model that computes the describing function. The reader should be able to understand
what is being done in this calculation by simply following
the flow through the diagram. Thus, even though this calculation could have been done entirely in MATLAB, the advantages of comprehension, error detection, and reuse make
this approach far better.
The ability to do computer-aided design using a visual programming environment like Simulink is only just beginning.
The future of this approach to system design is unlimited.
References
[1] British Horological Institute, (4 Dec. 1997) “Know your terminology–clock
time train,” [Online]. Available: http://www.bhi.co.uk/hints/clock.htm
[2] J.E. Gibson, Nonlinear Automatic Control. New York: McGraw-Hill, 1963.
[3] J-J.E. Slotine and W. Li, Applied Nonlinear Control. Englewood Cliffs, NJ:
Prentice-Hall, 1991.
[4] M. Rimer and R. Gran, “Analysis of systems with multiple nonlinearities,”
IEEE Trans. Automat. Contr., vol. AC-10, no. 1, Jan. 1965.
Carla Schwartz received her Ph.D. in electrical engineering
from Princeton University. She has held faculty positions at
McGill University, the University of Vermont, and the University of Florida, as well as visiting scholar positions at
Université Catholique de Louvain in Belgium and the University of Newcastle, NSW, Australia. She was also an AFOSR visiting faculty fellow at Wright Patterson AFB. For the past four
years she has held senior writing positions at software companies in the greater Boston area, including The MathWorks, Inc.
Richard Gran is President and CEO of the Mathematical
Analysis Co., a consulting company. He retired from The
MathWorks in 1999, where he was an Executive Consultant
He received his bachelor’s, master’s, and Ph.D. degrees from
Polytechnic Institute of Brooklyn in 1961, 1965, and 1969, respectively. For 33 years after graduation, he was with
Grumman Corporation. He retired from Grumman in 1985 as
Director of Advanced Concepts.
IEEE Control Systems Magazine
August 2001
Authorized licensed use limited to: University of Michigan Library. Downloaded on May 19,2010 at 20:38:51 UTC from IEEE Xplore. Restrictions apply.