Control instructions in MATLAB and Simulink (2023)

Contents

Open loop plant model

uIntroduction: Modeling in Simulinkwe showed how Simulink can be used to simulate a physical system. More generally, Simulink can simulate a complete operating system, including the operating algorithm, in addition to the physical installation. As mentioned earlier, Simulink is particularly useful for generating approximate solutions to mathematical models that can be extremely difficult to solve "by hand". For example, consider that we have a non-linear installation. A common approach is to generate a linear approximation of the installation and then use the linearized model to design the controller using analytical techniques. Simulink can then be used to simulate the performance of your controller when applied to a completely non-linear model. Simulink can be used to generate a linearized model, and MATLAB can be used to design a controller, as described on other Introduction pages. Several MATLAB controller design capabilities are also available directly from Simulink. On this page, we will demonstrate both approaches.

Think of a model of the Simulink toy train system, carried out inIntroduction: Modeling in Simulinkpage and picture below.

You can generate this model yourself or download the finished model by right-clicking on itHerethen selectSave link as.... Assuming the train runs in only one dimension (along the track), we want to control the locomotive so that it starts and stops smoothly and can follow a given constant speed with minimal parking errors.

Implementation of the PID controller in Simulink

First, let's create a structure that simulates a train system in a unique feedback loop with a PID controller. To make our Simulink model easier to understand, we first store the train model in its own subsystem block. To achieve this, remove the three range blocks and replace each block with an Out1 block from the Sinks library. Label each Out1 block with the appropriate variable name, "x1_dot", "x1" and "x2". Then remove the signal generator block and replace it with the In1 block from the resource library. Label this element with an "F" for the force generated between the train's locomotive and the rail. Your model should now look like this.

Then select all blocks in your model (Ctrl A) and selectSelection subsystemright-click in the model window. After a little editing and marking, your model should look like the one shown below.

Now we can add the controller to our system. We will be using a PID controller which can be implemented with a PID controller block from the Continuous library. Putting this block in series with the train subsystem, your model will look like this. Below we model the regulator so that it directly generates the force "F". This ignores the dynamics by which the train engine produces torque applied to the wheels and then ignores the dynamics of power generation at the wheel/rail interface. This simplified approach has been chosen at this point because we only want to introduce the basic functionality of Simulink for driver design and analysis.

By double-clicking on the PID controller block, we will pre-set itintegral(s)will gain a square of 0 and leaveProportional (P)Iderivative (D)get the default values ​​1 and 0 respectively. Then add a sum block from the math operations library. Double click on this block and customizeCharacter listfield to "|+-". Since we want to control the motor speed of the toy train, we return the motor speed. This is done by touching the "x1_dot" signal line and connecting it to the minus sign of the sum block. The output of the sum block is the speed error for the train motor and must be connected to the input of the PID control block. By connecting the blocks as described and adding labels, your model should look like this.

Then add a Signal Builder block from the source library to display the speed set for the train. Since we want to design a controller that smoothly accelerates the train and smoothly stops it, we test the system with the command to increase the speed to 1 m/s and then go back to 0 m/s (remember that our system istoys-train). Double-click the Signal Builder block to generate this type of command signal. Then selectChange the time rangevanshaftsmenu at the top of the block dialog. organize somethingmaximum timefield for "300" seconds. Then set the step up to 10 seconds and the step down to 150 seconds. This is achieved by clicking on the relevant parts of the signal graph (left and right vertical lines) and dragging the line to the desired position or entering the desired timeTbox at the bottom of the window. When you're done, your signal should look like this.

Also add a Scope block from the Sinks library and use it to replace the Out1 train speed block. If you change the block labels, your model will look like this.

We are now ready to run the closed loop simulation. If you want to skip the steps above, you can right-click to download the finished modelHerethen selectSave link as....

Run the closed-loop model

Before running the model, we need to assign numeric values ​​to each of the variables used in the model. We will use the following values ​​for the train system.

Create a new onem-bestandand enter the following commands.

M1 = 1; M2 = 0,5; k = 1; fa = 1; mu = 0,02; g = 9,8;

Run the 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 amount of time our simulation will run to match the timeframe of the Signal Builder block command. This is achieved through selectionModel configuration parametersvanSimulationmenu at the top of the model view and editstop timefield for "300". Now run the simulation and open the "x1_dot" range to examine the output speed. The result below shows that the closed-loop system is stable for this controller.

Since the performance achieved above is unsatisfactory due to steady state error, let's see how to redesign our controller. First, we'll show you how to extract a Simulink model into MATLAB for analysis and design. Next, we'll show you how to design a controller directly in Simulink.

Model extraction in MATLAB

The Simulink Control Design tool provides the functionality to extract models from Simulink to the MATLAB workspace. This is especially useful for complex or non-linear simulation models. It is also useful for generating discrete-time (sampled) models. For this example, let's extract the continuous time model of our train subsystem. First we need to identify the inputs and outputs of the model we want to extract. The input to the train system is power. We can highlight this fact by right-clicking on the signal representing "F" (PID block output) and selecting itLinear Analysis Points > Open Loop Inputfrom the resulting menu. Similarly, we can highlight the output of the train system by right-clicking on the "x1_dot" signal and selectingLinear Analysis Points > Open Loop Outputfrom the resulting menu. These inputs and outputs are now indicated by small arrow symbols as shown in the image below. Also, since we only want to extract the train model, no control, we need to clear the feedback signal, otherwise we will extract the closed loop modelAct. Your model should now look like this.

Now we can extract the model by opening itLinear analysis tool. This is achieved through selectionControl Design > Linear AnalysisbelowAnalyzingmenu at the top of the model window. After these steps, the following window will open.

This tool generates an LTI object from a (possibly non-linear) Simulink model and allows you to specify a point around which linearization is performed. Since our Simulink model is already linear, our operating point selection is unaffected and we can leave it as the defaultInitial state of the model. Select to generate a linearized modelStepin the image above, which is marked with a small green triangle. TheLinear analysis toola window should now appear as shown below.

Checking the above automatically generated the step response of the linearized model. If we compare this step response with the response generated by simulating the open loop train system in the programIntroduction: Modeling in Simulinkthe website shows that the answers are identical. This makes sense since the simulation model was already linear. In addition, the linearization process generated an objectlinsys1shown inWorkspace for linear analysisabove. This LTI object can be exported for use in MATLAB by simply exporting the object toMATLAB workspaceOfLinear analysis toolwindow.

After unpacking this model, we can now use all the possibilities offered by MATLAB to design a controller. For example, let's use the commands below to generate and analyze a closed-loop system that reflects the Simulink model created above.

sys_cl = loopback (linsys1,1); p = pool (sys_cl) z = zero (sys_cl)

p = -0,9237 + 0,0000i 0,0000 + 0,0000i -0,2342 + 1,6574i -0,2342 - 1,6574i

z = -0.0980 + 1.4108i -0.0980 - 1.4108i 0.0000 + 0.0000i

If you check the above, you will see that there is a zero outage at the source. In addition, the other poles have a negative real part, and the two "slowest" poles are composite. This shows that the loop system in its current form is stable and that the dominant poles are underdamped. This is consistent with the result of our closed-loop simulation above. We could then use MATLAB to design a new controller to dampen oscillations in the response, for example. In this case, we prefer to show how some MATLAB functions can be accessed directly in Simulink.

Controller design in Simulink

We can run interactive tools to tune our controller in Simulink. One way to do this is to double-click and select the PID controller in the modelPleasestart buttonTuner PIDtools. Instead, let's start more generallyOperating systems designertool by selectingOperating Design > Operating System DesignerbelowAnalyzingmenu at the top of the model window. After these steps, the following window will open.

The first thing to do is identify the controller block that needs to be configured. You do this by first clicking a buttonAdd blocksand then in the window that appears, select the PID controller block as shown below. Then clickAgreeknob. Note that controllers represented by other types of blocks (transfer function, state space, etc.) can also be tuned.

Before we start tuning our controller, we first need to identify the inputs and outputs of the closed-loop system we want to analyze. This is done in a similar way to how we extracted the linearized model in MATLAB. Right click on the speed command signal (Signal Builder block output) and selectLinear Analysis Points > Input Distortionfrom the resulting menu to identify the input of our closed loop system. Then right click on the train engine speed signal ("x1_dot") and selectLinear Analysis Points > Output Measurementfrom the output selection menu of our system. Your model should now look like this, with small arrows pointing to the inputs and outputs of the model.

Now that we have identified the settings block and our inputs and outputs, we can start configuring the controller. To chooseAgreeu buttonEdit architecturewindow. We should now see the window below.

By clickingAdjustment methodsuse the button to select the drawings that we want to use to design our controller. In this example, we use the root locus design approach and will choose accordinglyLocus main editorpod belowGraphics adjustmentas shown above. The root locus design approach uses a diagram representing all possible poles of a closed loop as a parameter (loop gain) ranging from zero to infinity. In particular, we make the following choiceSelect Reply to editwindow and selectGrunt.

We should then get a root locus diagram as shown below, showing all possible pole locations in a closed-loop closed-loop train system under simple proportional control. By examining the graph, you can see that all loop gain values ​​will place the closed loop poles in the left half of the plane, indicating a stable response.

If we reduce the loop gain sufficiently, we can move the closed loop poles further to the left half of the plane and we can change the efficiency of our system. This can be achieved by graphically grabbing the pink boxes representing the position of the closed-loop bars and dragging them to the position of the open-loop bars (markedX'With). By clicking, we can check the corresponding step response in a closed loopnew episodebelowCONTROL SYSTEMtab and selectA new step. When the next window appears, we selectNew input-output responsevanOdaberite answer to the plotdrop-down menu as shown.

We then specify the inputs and outputs within the frameworkA new stage of drawingwindow as shown below.

Then clickGruntknob. From the resulting closed-loop step response, it can be seen that the response is stable but with some stationary error.

Recall that adding integral control is one way to reduce the stationary error of a closed loop system. In this case, adding the integrator via the driver makes the system type 1 where type 1 systems can follow step references without steady state error. Call the following form of the PI controller.

(1)

Checking this equation shows that the PI controller adds an integrator and zero to our open loop system. An integrator can be added to the system by right-clicking on the root site field and selectingAdd Pool/Zero > Integratorfrom the resulting menu. Similarly, zero can be added by right-clicking on the root spot graph and selectingAdd pole/zero > true zerofrom the resulting menu. Then click on the right axis where you want to put the zero. You can move the zero by clicking and dragging it to a new location. The compensator can also be edited by entering the pole and zero position directly. This can be achieved by right-clicking on the home page diagram and selectingEdit compensatorfrom the resulting menu. The window that will open is shown below. We set the integrator, real zero, to -0.15 and select a loop gain of 0.05.

Below is a closed-loop response diagram showing a smooth stop of the train engine without the idle fault for a constant speed command.

The selected control gains can then be applied to the Simulink model by clickingUpdate blocksbutton insideCONTROL SYSTEMtab as shown above. The simulation can then be run with this newly configured driver. Clicking on the Scope block for the train engine speed will give you a graph similar to the one shown below.

Overall, this response seems to meet our goals of getting the train up to speed and back to a smooth stop while keeping the stationary error to a minimum. This answer matches the result generated byOperating systems designerabove, because this analysis and the Simulink model used exactly the same linear model.

Released with MATLAB® 9.2