LECTURE NOTES

Describing Function Analysis Using MATLAB and Simulink

By Carla Schwartz and Richard Gran

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 MATLABs 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 notit 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 (rgran@cfl.rr.com) 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.
0272-1708/01/$10.002001IEEE IEEE Control Systems Magazine

August 2001

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
Pend. Angle

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

Design Gain
Pendulum Angle Force Escapement Model Esc. Accel. Esc. Spring Accel. Damping Accel. Gravity Accel. Pend. Angle Display Variables Force

Escapement Dynamics Esc. Accel. 100 s+100 Theta2dot 1 s Thetadot 1 xo s Initial 0.2 Pend. Angle

-K-

Damping Accel.

dampcoef c/(m*len^2)

dampcoef=0.01 g=9.8 plength=0.2485

Gravity Accel.

1/plength 1/length

g*sin(u) Gravity Force g*sin(Theta)

Pend. Angle

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

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 ), 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 K ( E , ) = 2 f ( E sin(t ), t ) {sin(t ) + jcos(t )}dt . TE 0
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 Newtons 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

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.

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

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 pendulums swing does not hit the clocks 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 gears teeth.

August 2001

IEEE Control Systems Magazine

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 doesnt 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 doesnt 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| Abs 0.15 Penhigh

<= =1 When Angle < Penhigh

1 Force >= =1 When Angle > Penlow Product1

0.1 Penlow

=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

Amplitude Vector "E" from Workspace E'*u sin(omega1*t) 23

Division by 2T Nonlinearity Under Test In1 In2 23 23 23 f(t)*cos 1 s 23 23 1./E/T 23 23 In1 In2 Save Data 23 sin(omega1*t) 23 f(t)*sin 1 s 23 23 1./E/T pi./omega1 Divide by 2T 23 23 Trigger at Stop pi./omega1 Stop Simulation at the End of One Cycle

cos(omega1*t )

23

Divide by E to get DF

1 Gain

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.

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')

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 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,

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

IEEE Control Systems Magazine

23

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.

Describing Functions and Oscillations

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. Lets 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.

Describing Function Gain

3.5 3 2.5 2 1.5 1 0.5 0 10

8 6 4 2 0 (a) 0 1 1.5 2 2.5

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 GH ( j 0 ) = e j . 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:

Frequency (rad/s)

0.5

Amplitude

Describing Function Phase

0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 10 8 6 4 2 2 2.5 3

Frequency (rad/s)

0 (b)

0.5

1.5

Amplitude

Figure 6. The magnitude and phase of the describing function are plotted as functions of the amplitude and frequency of the input.

24

IEEE Control Systems Magazine

August 2001

Bode Diagram 50

Bode Diagram
20 10 0 10 20 30 40 50 60 70 80 45 90

Magnitude (dB)

50 100 0 90

Phase (deg)

270 360 10
0

Frequency (rad/s)

10

Phase (deg)

180

Magnitude (dB)

System: clocksys(:,:,16) Frequency (rad/s): 6.28 Magnitude (dB): 0.413 System: clocksys(:,:,17) Frequency (rad/s): 6.28 Magnitude (dB): 1.94

135 180 225 270 10

0

Figure 7. Bode plots of all 23 models in the LTI array clocksys using the LTI Viewer.
dynamics = tf(1, [1 .01 (2pi)^2]) tf(100, [1 100]); clocksys = DFsysdynamics 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.

Frequency (rad/s)

10

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 0 0.2 950 0.2 0 0.2 950 0.2 0 0.2 950 10 0 10 950 0.5 0 0.5 950 951 952 951 952 951 952 951 951 952

Escapement Acceleration

953

954

955

956

957

958

959 960

Escapement Spring Acceleration 952 953 954 955 956 957

958

959 960

Damping Acceleration 953 954 955 956 957

958

959 960

Gravity Acceleration 953 954 955 956

957

958

959 960

953

Analyzing the Array of Frequency Response Data

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.

Pendulum Angle 954 955 956 Time

957

958

959 960

Figure 9. Simulation results for the final design gain.

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

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 swingthe frequency of the pendulum swing will not change.

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 terminologyclock 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.

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:

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 bachelors, masters, 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.

26

IEEE Control Systems Magazine

August 2001