laboratory exercise 5 simulink modeling train system
Post on 09-Feb-2022
7 Views
Preview:
TRANSCRIPT
1
Laboratory Exercise 5
Simulink Modeling – Train System
Introduction: Simulink Modeling – to be done with Matlab 14a
In Simulink, it is very straightforward to represent and then simulate a mathematical model
representing a physical system. Models are represented graphically in Simulink as block
diagrams. A wide array of blocks is available to the user in provided libraries for representing
various phenomena and models in a range of formats. One of the primary advantages of
employing Simulink (and simulation in general) for the analysis of dynamic systems is that it
allows us to quickly analyze the response of complicated systems that may be prohibitively
difficult to analyze analytically. Simulink is able to numerically approximate the solutions to
mathematical models that we are unable to, or don't wish to, solve "by hand."
In general, the mathematical equations representing a given system that serves as the basis for a
Simulink model can be derived from physical laws. In this page we will demonstrate how to
derive a mathematical model and then implement that model in Simulink. This model is then
employed in the Introduction: Simulink Control page in order to demonstrate how to employ
Simulink to design and simulate the control for a system.
Contents
Train system
Free-body diagram and Newton's second law
Constructing the Simulink model
Running the model
Train system
In this example, we will consider a toy train consisting of an engine and a car. Assuming that the
train only travels in one dimension (along the track), we want to apply control to the train so that
it starts and comes to rest smoothly, and so that it can track a constant speed command with
minimal error in steady state.
The mass of the engine and the car will be represented by M1 and M2, respectively. Furthermore,
the engine and car are connected via a coupling with stiffness k. In other words, the coupling is
modeled as a spring with a spring constant k. The force F represents the force generated between
the wheels of the engine and the track, while μ represents the coefficient of rolling friction.
2
Free-body diagram and Newton's second law
The first step in deriving the mathematical equations that govern a physical system is to draw the
free-body diagram(s) representing the system. This is done below for our train system.
From Newton's second law, we know that the sum of the forces acting on a body is equal to the
product of the mass of the body and its acceleration. In this case, the forces acting on the engine
(M1) in the horizontal direction are the spring force, the rolling resistance, and the force
generated at the wheel/track interface. The forces acting on the train car (M2) in the horizontal
direction are the spring force and the rolling resistance. In the vertical direction, the weight
forces are balanced by the normal forces applied by the ground (N = mg). Therefore, there will
be no acceleration in the vertical direction.
We will model the spring as generating a force that is linearly proportional to the deformation of
the spring, k(x1 – x2), where x1 and x2 are the displacements of the engine and car, respectively.
Here it is assumed that the spring is un-deformed when x1 and x2 equal zero. The rolling
resistance forces are modeled as being linearly proportional to the product of the corresponding
velocities and normal forces (which are equal to the weight forces).
Applying Newton's second law in the horizontal direction based on the above free-body
diagrams leads to the following governing equations for the train system.
(1) ΣF1 = 𝐹 − 𝑘(𝑥1 − 𝑥2) − 𝜇𝑀1𝑔𝑥1̇ = 𝑀1𝑥1̈
(2) ΣF2 = 𝐹 − 𝑘(𝑥1 − 𝑥2) − 𝜇𝑀2𝑔𝑥2̇ = 𝑀2𝑥2̈
Constructing the Simulink model – (begin here)
This set of system equations can now be represented graphically without further manipulation.
Specifically, we will construct two copies (one for each mass) of the general expression Σ𝐹 = 𝑚𝑎 or a = 1/(mΣ𝐹) . First, open Simulink and open a new model window. Then drag
two Sum blocks (from the Math Operations library) into your model window and place them
approximately as shown in the figure below.
3
The outputs of each of these Sum blocks represent the sum of the forces acting on each mass.
Multiplying each output signal by 1/M will give us the corresponding acceleration of each mass.
Now drag two Gain blocks (from the Math Operations Library) into your model and attach each
one with a line from the output of one of the Sum blocks. Label these two signals as "Sum_F1"
and "Sum_F2" in order to make your model clearer. This is accomplished by double-clicking in
the space above each of the two signal lines and entering the desired label.
4
These Gain blocks should contain 1/M for each of the masses. We will define the variables M1
and M2 in the MATLAB workspace, so we can just enter the corresponding variable names in
each of the Gain blocks. Double-click on the upper Gain block and enter "1/M1" into the Gain
field. Similarly, enter "1/M2" in the Gain field of the second Gain block.
You will notice that the gains did not appear in the image of the Gain blocks, rather the blocks
display a value of -K-. This is because the blocks are too small on the screen to show the full
variable name inside the triangle. The blocks can be resized so that the actual gain value can be
seen. To resize a block, select it by clicking on it once. Small squares will appear at the corners.
Drag one of these squares to stretch the block. Your model should appear as below.
The outputs of these gain blocks are the accelerations of each of the masses (the train engine and
car). The governing equations we derived above depend on the velocities and displacements of
the masses. Since velocity can be determined by integrating acceleration, and position can be
determined by integrating velocity, we can generate these signals employing integrator blocks.
Drag a total of four Integrator blocks from the Continuous library into your model, two for each
of our two accelerations. Connect these blocks and label the signals as shown below.
Specifically, the first integrator takes the acceleration of mass 1 ("x1_ddot") as an input and
generates the velocity of mass 1 ("x1_dot"). The second integrator then takes this velocity and
outputs the displacement of the first mass ("x1"). The same pattern holds for the integrators for
the second mass.
Now, drag two Scopes from the Sinks library into your model and connect them to the outputs of
these integrators. Label them "x1" and "x2".
5
Now we are ready to add the forces acting on each mass. First, we need to adjust the inputs on
each Sum block to represent the proper number of forces (we will worry about the signs later).
Since there is a total of three forces acting on mass 1, double-click on the corresponding Sum
block and change the List of signs field to "|+++". The symbol "|" serves as a spacer. There are
only 2 forces acting on mass 2, therefore, we can leave that Sum block alone for now.
The first force acting on mass 1 is just the input force, F. Drag a Signal Generator block from
the Sources library and connect it to the uppermost input of the corresponding Sum block. Label
this signal as "F".
The next force acting on mass 1 is the rolling resistance force. Recall that this force is modeled
as follows:
6
(3) 𝐹𝑟𝑟,1 = 𝜇𝑔𝑀1𝑥1̇
To generate this force, we can tap off the velocity signal and multiply by an appropriate gain.
Drag a Gain block into your model window. Tap off the "x1_dot" signal and connect it to the
input of this new Gain block (draw this line in several steps if necessary). Connect the output of
the Gain block to the second input of the Sum block. Double-click the Gain block and enter
"mu*g*M1" into the Gain field. The rolling resistance force, however, acts in the negative
direction. Therefore, change the list of signs of the Sum block to "|+-+". Next, resize the Gain
block to display the full gain and label the output of the Gain block "Frr1". Your model should
now appear as follows.
The last force acting on mass 1 is the spring force. Recall that this force is equal to the following.
(4) 𝐹𝑠 = 𝑘(𝑥1 − 𝑥2)
Therefore, we need to generate a signal (𝑥1 − 𝑥2) which we can then be multiplied by a gain k to
create the force. Drag a Subtraction block (or a Sum block or an Addition block) below the rest
of your model. In order to change the direction of this block, right-click on the block and choose
Format > Flip block from the resulting menu. Alternatively, you can select the block then hit
Ctrl-I. Now, tap off the "x2" signal and connect it to the negative input of the Subtract block.
Also, tap off the "x1" signal and connect it to the positive input. This will cause signal lines to
cross. Lines may cross, but they are only actually connected where a small block appears (such
as at a tap point).
7
Now, we can multiply this difference by the spring constant to generate the spring force. Drag a
Gain block into your model to the left of the Subtraction block. Change the value of the Gain
block to "k" and connect the output of the Subtract block to its input. Then connect the output of
the Gain block to the third input of the Sum block for mass 1 and label the signal "Fs". Since the
spring force acts on mass 1 in the negative direction, it is necessary to again change the list of
signs of the Sum block to "|+--". Your model should appear as follows:
We can now apply forces to mass 2. For the first force, we will use the same spring force we just
generated, except that it is applied to mass 2 in the positive direction. Simply tap off the spring
force signal "Fs" and connect it to the first input of the Sum block for mass 2.
8
The last force applied to mass 2 is its rolling resistance force. This force is generated in an
analogous manner to the rolling resistance force applied to mass 1. Tap off the signal "x2_dot"
and multiply it by a Gain block with value "mu*g*M2". Then connect the output of the Gain
block to the second input of the corresponding Sum block and label the signal "Frr2". Changing
the second input of the Sum block to be negative will lead to the following model.
Now the model is complete. We simply need to supply the proper input and define the output of
interest. The input to the system is the force generated by the engine. Within the Simulink
model, we have already defined the force to be the output of a Signal Generator block. The
output of the system, which we will observe and ultimately try to control, will be the velocity of
the train engine. Add another Scope block to your model from the Sinks library. Tap a line from
the "x1_dot" signal and connect it to the Scope block. Label this scope as "x1_dot" and your
model should appear as in the following.
9
Now, the model is complete and should be saved. Provide a screen capture with your name
embedded in the diagram for the lab report.
Running the model
Before running the model, we need to assign numerical values to each of the variables used in
the model. For the train system, we will employ the following values.
M1 = 1 kg
M2 = 0.5 kg
k = 1 N/sec
F = 1 N
μ = 0.02 sec/m
g = 9.8 m/s^2
Create a new m-file and enter the following commands.
M1 = 1;
M2 = 0.5;
k = 1;
F = 1;
mu = 0.02;
g = 9.8;
Execute your m-file in the MATLAB command window to define these values. Simulink will
recognize these MATLAB variables for use in the model.
Now, we need to give an appropriate input to the engine. Double-click on the Signal Generator
block (outputs "F"). Select square from the Wave form drop-down menu and set the
10
Frequency field to equal "0.001". You may leave the Units as the default Hertz. Also enter "-1"
into the Amplitude field (positive amplitude steps negative before stepping positive).
The last step before running the simulation is to select an appropriate simulation time. To view
one cycle of the 0.001 Hz square wave, we should simulate the model for 1000 seconds. Select
Parameters from the Simulation menu at the top of the model window and change the Stop
Time field to "1000". Close the dialog box.
Now, run the simulation and open the "x1_dot" scope to examine the velocity output (hit
autoscale). The input was a square wave with two steps, one positive and one negative.
Physically, this means that the engine first went forward, then backward. The velocity output
reflects this.
Provide a screen capture with your
name embedded in the diagram for
the lab report.
11
In this page we derived the mathematical model for the train system from first principles and
then represented the derived equations within Simulink. An alternative option that is now
available is to represent a dynamic system employing the physical modeling tool Simscape.
Simscape is an addition to Simulink that allows a user to model a system employing blocks that
represent physical quantities (and objects) such as inertias and joints, or resistances and
inductors. Employing Simscape allows the user to simulate a physical system without deriving
the governing mathematical equations. U. of Toledo presently does not support Simscape.
Save your results.
Simulink Control
Introduction: Simulink Control
The open-loop plant model
Implementing a PID controller in Simulink
Running the closed-loop model
Extracting a model into MATLAB
Controller design within Simulink
The open-loop plant model
In the Introduction: Simulink Modeling page we demonstrated how Simulink can be employed to
simulate a physical system. More generally, Simulink can also simulate the complete control
system, including the control algorithm in addition to the physical plant. As mentioned
previously, Simulink is especially useful for generating the approximate solutions of
mathematical models that may be prohibitively difficult to solve "by hand." For example,
consider that you have a nonlinear plant. A common approach is to generate a linear
approximation of the plant and then use the linearized model to design a controller using
analytical techniques. Simulink can then be employed to simulate the performance of your
controller when applied to the full nonlinear model. Simulink can be employed for generating the
linearized model and MATLAB can be employed for designing the controller as described in the
other Introduction pages. Various control design facilities of MATLAB can also be accessed
directly from within Simulink. We will demonstrate both approaches in this page.
Recall the Simulink model of the toy train system derived in the Introduction: Simulink
Modeling page and pictured below.
12
Assuming that the train only travels in one dimension (along the track), we want to apply control
to the train engine so that it starts and comes to rest smoothly, and so that it can track a constant
speed command with minimal error in steady state.
Implementing a PID controller in Simulink
Let us first create the structure for simulating the train system in unity feedback with a PID
controller. In order to make our Simulink model more understandable, we will first save the train
model into its own subsystem block. To accomplish this, delete the three scope blocks and
replace each one by an Out1 block from the Sinks library. Label each Out1 block with the
corresponding variable name, "x1_dot", "x1", and "x2". Then delete the Signal Generator block
and replace it with an In1 block from the Sources library. Label this input "F" for the force
generated between the train engine and the railroad track. Your model should now appear as
follows:
13
Next select all of the blocks in your model (Ctrl A) and rt click from the model to choose
Create Subsystem (Ctrl G). With a little rearranging and relabeling, your model will appear as
shown below.
Now we can add a controller to our system. We will employ a PID controller which can be
implemented using a PID Controller block from the Continuous library. Placing this block in
series with the train subsystem, your model will appear as follows. In the following, we model
the controller as generating the force "F" directly. This neglects the dynamics with which the
train engine generates the torque applied to the wheels, and subsequently neglects the dynamics
of how the force is generated at the wheel/track interface. This simplified approach is taken at
this point since we only wish to introduce the basic functionality of Simulink for controller
design and analysis.
14
Double-clicking on the PID Controller block, we will initially set the Integral (I) gain field
equal to 0 and will leave the Proportional (P) and Derivative (D) gains as their defaults of 1
and 0, respectively. Next add a Sum block from the Math Operations library. Double-click on
this block and modify the List of signs field to "|+-". Since we wish to control the velocity of the
toy train engine, we will feedback the engine's velocity. This is accomplished by 4ring a line off
of the "x1_dot" signal and connecting it to the negative sign of the Sum block. The output of the
Sum block will be the velocity error for the train engine and should be connected to the input of
the PID Controller block. Connecting the blocks as described and adding labels, your model
should appear as follows.
Next add a Signal Builder block from the Sources library to represent the velocity commanded to
the train. Since we wish to design a controller to bring the train smoothly up to speed and
smoothly to rest, we will test the system with a velocity command that steps up to 1 m/s followed
by a step back down to 0 m/s (recall that our system is a toy train). To generate this type of
command signal, double-click on the Signal Builder block. Then choose Change time range
from the Axes menu at the top of the block's dialog window. Set the Max time field to "300"
seconds. Next, set the step up to occur at 10 seconds and the step down to occur at 150 seconds.
This is accomplished by clicking on the corresponding portions of the signal graph (left and right
vertical lines) and either dragging the line to the desired position, or entering the desired time in
the T field at the bottom of the window. When done, your signal should appear as follows.
15
Also add a Scope block from the Sinks library and use it to replace the Out1 block for the train's
velocity. Relabeling the blocks, your model will appear as follows.
We are now ready to run the closed-loop simulation.
Running the closed-loop model
Before running the model, we need to assign numerical values to each of the variables used in
the model. For the train system, we will employ the following values.
M1 = 1 kg
M2 = 0.5 kg
k = 1 N/sec
F = 1 N
μ = 0.02 sec/m
g = 9.8 m/s^2
Create a new m-file and enter the following commands.
M1 = 1;
M2 = 0.5;
k = 1;
F = 1;
mu = 0.02;
g = 9.8;
Execute your m-file in the MATLAB command window to define these values. Simulink will
recognize these MATLAB variables for use in the model. Next we need to set the time for which
our simulation will run to match the time range of the command from the Signal Builder block.
This is accomplished by selecting Parameters from the Simulation menu at the top of the
model window and changing the Stop Time field to "300". Now, run the simulation and open the
"x1_dot" scope to examine the velocity output (hit autoscale). The result as shown below
demonstrates that the closed-loop system is unstable for this controller.
16
(Capture this for Lab Report)
Since the performance achieved above is unsatisfactory, we need to redesign our controller. We
will first demonstrate how to extract a model from Simulink into MATLAB for analysis and
design. Then we will demonstrate how to design the control from directly within Simulink.
Extracting a model into MATLAB
The Simulink Control Design toolbox offers the functionality to extract a model from Simulink
into the MATLAB workspace. This is especially useful for complicated or nonlinear simulation
models. This is also useful for generating discrete-time (sampled) models. For this example, let
us extract a continuous-time model of our train subsystem. First we need to identify the inputs
and outputs of the model we wish to extract. The input to the train system is the force F. We can
designate this fact by right-clicking on the signal representing "F" (output of the PID block) and
choosing Linearization Points > Input Point from the resulting menu. Likewise, we can
designate the output of the train system by right-clicking on the "x1_dot" signal and choosing
Linearization Points > Output Point from the resulting menu. These inputs and outputs will
now be indicated by small arrow symbols as shown in the following figure. Since we wish to
extract a model of the train by itself, without control, we need to further delete the feedback
signal, otherwise we will extract the closed-loop model from F to �̇�1. Your model should now
appear as follows:
17
We can now extract the model by opening the Linear Analysis Tool. This is accomplished by
selecting Control Design > Linear Analysis from under the Analysis menu at the top of the
model window. Following these steps will open the window shown below.
This tool generates an LTI object from a (possibly nonlinear) Simulink model and allows you to
specify the point about which the linearization is performed. Since our Simulink model is already
linear, our choice of operating point will have no effect and we can leave it as the default Model
Initial Condition. In order to generate the linearized model, select the Linearize button in
the above figure, which is indicated by the green triangle. The Linear Analysis Tool window
should now appear as shown below.
18
Capture the Step Plot below for report:
Inspecting the above, the step response of the linearized model was automatically generated.
Comparing this step response to the one generated by the simulation of the open-loop train
system in the Introduction: Simulink Modeling page, you can see that the responses are identical.
This makes sense since the simulation model was already linear. Additionally, the linearization
process generated the object linsys1 shown in the Linear Analysis Workspace above. This
LTI object can be exported for use within MATLAB by simply dragging the object into the
MATLAB Workspace window immediately above the Linear Analysis Workspace window.
Having extracted this model, we can now employ all of the facilities that MATLAB offers for
controller design. For example, let us employ the following commands to generate and analyze
the closed-loop system reflecting the Simulink model created above. Report your results below:
sys_cl = feedback(linsys1,1);
pole(sys_cl)
ans =
-1.5261
0.0000
0.0670 + 1.1977i
0.0670 - 1.1977i
19
Examination of the above demonstrates that the closed-loop system in its current state has poles
with positive real part and, therefore, is unstable. This agrees with the result of our closed-loop
simulation from above. We can then employ MATLAB to design a new controller. Instead, we
will demonstrate how to access some of MATLAB's functionality from directly within Simulink.
Controller design within Simulink
Rather than performing the controller design in MATLAB, we can also launch interactive tools
to tune our controller from within Simulink. One manner in which this can be done is to double-
click on the PID Controller in the model and select the Tune button to launch the PID Tuner
GUI. Rather than do this, we will launch the more general Simulink Control Design GUI by
selecting Control Design > Compensator Design from under the Analysis menu located at the
top of the model window. Following these steps will open the Control and Estimation Tools
Manager window shown below.
The first thing that needs to be done is to identify the controller block that is to be tuned. This is
accomplished by first clicking on the Select Blocks button, and then selecting the PID Controller
block from the resulting window as shown below. Next click the OK button. Note that
controllers represented in other types of blocks (Transfer Function, State Space, etc.) can also be
tuned.
20
Before we proceed to tune our controller, we must first identify the inputs and outputs of the
closed-loop system we wish to analyze. This is done in the same manner we did when extracting
a model into MATLAB. Specifically, right-click on the velocity command signal (output of the
Signal Builder block) and choose Linearization Points > Input Point from the resulting menu
to identify the input of our closed-loop system. Similarly, right-click on the train engine velocity
signal ("x1_dot") and select Linearization Points > Output Point from the menu to choose the
output of our system. Your model should now appear as follows where the small arrow symbols
identify the input and output of the model.
Now that we have identified the block to tune and our input and output signals, we can now
commence with tuning the controller. Select the Tune Blocks button in the Control and
Estimation Tools Manager window. This will open the Design Configuration Window shown
below which provides some introduction on how to employ the interactive design tool. In
essence, this GUI is the SISO Design Tool that is available from within MATLAB as well.
21
Clicking the Next button, we will choose the design plots we wish to employ for designing our
controller. In this example, we will employ a root locus design approach and hence will choose a
Plot Type of Root Locus for Plot 1 as shown below. Since the root locus approach to design
employs a plot from the open-loop system for placing the closed-loop poles, we will leave the
choice of Open/Closed Loops as Open Loop 1 (this is our only choice!).
Clicking the Next button again will allow us to choose our analysis plots. We use the step
response plot to assess how well we are able to meet our goal of bringing the train up to speed
smoothly with minimal steady-state error to a constant speed command. Therefore, we will
choose a Plot Type of Step from the drop-down menu under Plot 1 as shown below. We will
also select Plot 1 under the Plot Contents portion of the window for the only system that is
defined. There is only one system available because we have defined only a single input and
single output for our system.
22
Selecting the Next Button will then open the SISO Design Tool with a root locus plot and a step
response plot. The root locus plot shown below displays the closed-loop pole locations of the
train system plant under simple proportional control. Examining the plot, one can see that many
values of loop gain will place closed-loop poles in the right-half plane leading to an unstable
response. Capture the root locus plot for your report as well as the step response:
23
If we decrease the loop gain sufficiently, we can move the closed-loop poles into the left-half
plane and we can stabilize our system. This can be accomplished graphically by "grabbing" the
pink boxes marking the closed-loop pole locations and dragging them toward the open-loop pole
locations (marked by x's). A loop gain of approximately 0.1 will stabilize the system. Examining
the corresponding step response, which will change automatically in response to the gain change
if the Real-Time Update box is checked in the LTI Viewer window, you can see that while the
response is stable its steady-state error is quite large.
Stop Report Here (instructor may add the following but in general, it is not required for this lab)
Recall that adding integral control is one way to reduce the steady-state error for a system. In this
case, adding an integrator via the controller will make the system type 1, where type 1 systems
can track step references with zero steady-state error. Recall the following form of a PI
controller.
(1) 𝐶(𝑠) = 𝐾𝑝 +𝐾𝑖
𝑠=
𝐾𝑝𝑠 + 𝐾𝑖
𝑠
24
Therefore, a PI controller will add an integrator and a zero to our open-loop system. The
integrator can be added to the system by right-clicking in the field of the root locus plot and
selecting Add Pole/Zero > Integrator from the resulting menu. Similarly, the zero can be added
by right-clicking on the root locus plot and selecting Add Pole/Zero > Real zero from the
resulting menu. Then click where along the real axis you wish to place the zero. We will place
the zero just to the right of the plant pole on the real axis. You can move the zero by clicking on
it and dragging it to a new location. Once you have placed the zero, then grab the pink boxes
representing the closed-loop poles and attempt to line the three dominant poles up so that they
have the same real part. There also will be a real closed-loop pole to the left that is "faster" than
the rest, and a closed-loop pole at the origin that is cancelled by a closed-loop zero at the origin.
The resulting root locus plot is shown below.
25
The compensator can also be edited by directly typing in pole and zero locations. This can be
done by choosing Edit Compensator from the Design menu located at the top of the SISO
Design Task window. The window that opens is shown below. We will more precisely place the
zero at -0.15 and will choose a loop gain equal to 0.01.
The resulting closed-loop step response plot is shown below demonstrating that the train engine
is brought to speed smoothly and with zero steady-state error for a constant speed command.
26
The control gains that have been chosen can then be applied to the Simulink model by clicking
the Update Simulink Block Parameters button under the Compensator Editor tab of the
Control and Estimation Tools Manager window (see above). The simulation can then be run
with this newly tuned controller. Clicking on the Scope block for the train engine's velocity and
selecting auto-scale will produce a plot like the one shown below.
27
Overall this response seems to meet our goals of bringing the train up to speed and to rest
smoothly, while maintaining minimal steady-state error. This response matches the result
generated with the SISO Design Tool above because that analysis and the Simulink model used
the exact same linear model.
top related