Modeling An Inverted Pendulum

Inverted Pendulum Model
Contents
Problem setup and design requirements ................................................................................................. 3 Force analysis and system equations.................................................................................................... 4 1. Transfer Function ...................................................................................................................... 6 2. State-Space ................................................................................................................................. 7 Matlab representation and the open-loop response ................................................................................ 7 1. Transfer Function ...................................................................................................................... 7 1. State-Space ................................................................................................................................. 9 Solution to the Inverted Pendulum Problem Using PID Control .............................................................. 10 Open-loop Representation ................................................................................................................. 11 Closed-loop transfer function............................................................................................................. 11 Adding the PID controller ................................................................................................................... 12 What happens to the cart's position? .............................................................................................. 15 Lead-lag controller ............................................................................................................................. 17 What happens to the cart's position? .............................................................................................. 20 Transfer Function ........................................................................................................................... 21 Solution to the Inverted Pendulum Problem Using Frequency Response Method .................................. 24 Open-loop Representation ................................................................................................................. 24 Closed-loop response with no compensation ..................................................................................... 25 Closed-loop response with compensation .......................................................................................... 28 What happens to the cart's position? .............................................................................................. 34 Transfer Function ........................................................................................................................... 35 State-space design for the inverted pendulum ....................................................................................... 37 Open-loop poles ............................................................................................................................ 38 LQR design ..................................................................................................................................... 39

Adding the reference input ............................................................................................................ 41 Observer design ............................................................................................................................. 43
Modeling an Inverted Pendulum

Problem setup and design requirements
The cart with an inverted pendulum, shown below, is "bumped" with an impulse force, F. Determine the dynamic equations of motion for the system, and linearize about the pendulum's angle, theta = Pi (in other words, assume that pendulum does not move more than a few degrees away from the vertical, chosen to be at an angle of Pi). Find a controller to satisfy all of the design requirements given below.
For this example, let's assume that

M mass of the cart 0.5 kg m mass of the pendulum 0.5 kg b friction of the cart 0.1 N/m/sec l length to pendulum center of mass 0.3 m I inertia of the pendulum 0.006 kg*m^2 F force applied to the cart x cart position coordinate theta pendulum angle from vertical
For the PID, root locus, and frequency response sections of this problem we will be only interested in the control of the pendulums position. This is because the techniques used in these tutorials can only be applied for a single-input-single-output (SISO) system. Therefore, none of the design criteria deal with the cart's position. For these sections we will assume that the system starts at equilibrium, and experiences an

impulse force of 1N. The pendulum should return to its upright position within 5 seconds, and never move more than 0.05 radians away from the vertical. The design requirements for this system are:
y y
Settling time of less than 5 seconds. Pendulum angle never more than 0.05 radians from the vertical.
However, with the state-space method we are more readily able to deal with a multioutput system. Therefore, for this section of the Inverted Pendulum example we will attempt to control both the pendulum's angle and the cart's position. To make the design more challenging we will be applying a step input to the cart. The cart should achieve it's desired position within 5 seconds and have a rise time under 0.5 seconds. We will also limit the pendulum's overshoot to 20 degrees (0.35 radians), and it should also settle in under 5 seconds. The design requirements for the Inverted Pendulum state-space example are:
y y y
Settling time for x and theta of less than 5 seconds. Rise time for x of less than 0.5 seconds. Overshoot of theta less than 20 degrees (0.35 radians).
Force analysis and system equations

Below are the two Free Body Diagrams of the system.
Summing the forces in the Free Body Diagram of the cart in the horizontal direction, you get the following equation of motion:

Note that you could also sum the forces in the vertical direction, but no useful information would be gained. Summing the forces in the Free Body Diagram of the pendulum in the horizontal direction, you can get an equation for N:
If you substitute this equation into the first equation, you get the first equation of motion for this system:
(1)
To get the second equation of motion, sum the forces perpendicular to the pendulum. Solving the system along this axis ends up saving you a lot of algebra. You should get the following equation:
To get rid of the P and N terms in the equation above, sum the moments around the centroid of the pendulum to get the following equation:
Combining these last two equations, you get the second dynamic equation:
(2)
Since Matlab can only work with linear functions, this set of equations should be linearized about theta = Pi. Assume that theta = Pi + ( represents a small angle from the vertical upward direction). Therefore, cos(theta) = -1, sin(theta) = -, and (d(theta)/dt)^2 = 0. After linearization the two equations of motion become (where u represents the input):

1. Transfer Function To obtain the transfer function of the linearized system equations analytically, we must first take the Laplace transform of the system equations. The Laplace transforms are:
NOTE: When finding the transfer function initial conditions are assumed to be zero. Since we will be looking at the angle Phi as the output of interest, solve the first equation for X(s),
then substituting into the second equation:
Re-arranging, the transfer function is:
where,
From the transfer function above it can be seen that there is both a pole and a zero at the origin. These can be canceled and the transfer function becomes:
2. State-Space After a little algebra, the linearized system equations equations can also be represented in state-space form:
The C matrix is 2 by 4, because both the cart's position and the pendulum's position are part of the output. For the state-space design problem we will be controlling a multi-output system so we will be observing the cart's position from the first row of output and the pendulum's with the second row.
Matlab representation and the open-loop response

1. Transfer
Function
The transfer function found from the Laplace transforms can be set up using Matlab by inputting the numerator and denominator as vectors. Create an m-file and copy the following text to model the transfer function:
M m b i g l = = = = = = .5; 0.2; 0.1; 0.006; 9.8; 0.3; %simplifies input
q = (M+m)*(i+m*l^2)-(m*l)^2;

num = [m*l/q 0] den = [1 b*(i+m*l^2)/q
-(M+m)*m*g*l/q
-b*m*g*l/q]
Your output should be:

num = 4.5455 den = 1.0000
0.1818
-31.1818
-4.4545
To observe the system's velocity response to an impulse force applied to the cart add the following lines at the end of your m-file:
t=0:0.01:5; impulse(num,den,t) axis([0 1 0 60])
Note: Matlab commands from the control system toolbox are highlighted in red. You should get the following velocity response plot:
As you can see from the plot, the response is entirely unsatisfactory. It is not stable in open loop. You can change the axis to see more of the response if you need to convince yourself that the system is unstable.

1. State-Space Below, we show how the problem would be set up using Matlab for the state-space model. If you copy the following text into a m-file (or into a '.m' file located in the same directory as Matlab) and run it, Matlab will give you the A, B, C, and D matrices for the state-space model and a plot of the response of the cart's position and pendulum angle to a step input of 0.2 m applied to the cart.
M m b i g l = = = = = = .5; 0.2; 0.1; 0.006; 9.8; 0.3;
p = i*(M+m)+M*m*l^2; %denominator for the A and B matricies A = [0 1 0 0; 0 -(i+m*l^2)*b/p (m^2*g*l^2)/p 0; 0 0 0 1; 0 -(m*l*b)/p m*g*l*(M+m)/p 0] B = [ 0; (i+m*l^2)/p; 0; m*l/p] C = [1 0 0 0; 0 0 1 0] D = [0; 0] T=0:0.05:10; U=0.2*ones(size(T)); [Y,X]=lsim(A,B,C,D,U,T); plot(T,Y) axis([0 2 0 100])
You should see the following output after running the m-file:
A = 0 0 0 0 B = 0 1.8182 0 4.5455 C = 1 0 0 0 0 1 0 0 1.0000 -0.1818 0 -0.4545 0 2.6727 0 31.1818 0 0 1.0000 0

D = 0 0
The blue line represents the cart's position and the green line represents the pendulum's angle. It is obvious from this plot and the one above that some sort of control will have to be designed to improve the dynamics of the system. Four example controllers are included with these tutorials: PID, root locus, frequency response, and state space. Select from below the one you would like to use.
Solution to the Inverted Pendulum Problem Using PID Control

The transfer function of the plant for this problem is given below:
where,

The design criteria (with the pendulum receiving a 1N impulse force from the cart) are:
y y
Settling time of less than 5 seconds. Pendulum should not move more than 0.05 radians away from the vertical.
Open-loop Representation
The first thing to do when using PID control in Matlab is to find the transfer function of the system and to check to see if it makes sense. The transfer function found from the Laplace transforms for the output Phi (the pendulum's angle) can be set up using Matlab by inputting the numerator and denominator as vectors. Create an m-file (or a '.m' file located in the same directory as Matlab) and copy the following text to model the transfer function:
q = (M+m)*(i+m*l^2)-(m*l)^2; num = [m*l/q 0] den = [1 b*(i+m*l^2)/q
-(M+m)*m*g*l/q
-b*m*g*l/q]

num = 4.5455 den = 1.0000
0.1818
-31.1818
-4.4545
Closed-loop transfer function

The control of this problem is a little different than the standard control problems you may be used to. Since we are trying to control the pendulum's position, which should return to the vertical after the initial disturbance, the reference signal we are tracking should be zero. The force applied to the cart can be added as an impulse disturbance. The schematic for this problem should look like the following.
It will be easier to determine the appropriate transfer function to enter into Matlab if we first rearrange the schematic as follows:
Now, we can find the closed-loop transfer function.
Adding the PID controller

This closed-loop transfer function can be modeled in Matlab by copying the following code to the end of your m-file (whether your using the transfer function from the Laplace transforms or from the state-space representation):
kd = 1; k = 1; ki = 1; numPID = [kd k ki]; denPID = [1 0]; numc = conv(num,denPID) denc = polyadd(conv(denPID,den),conv(numPID,num))
Note: Non-standard Matlab commands used in this example are highlighted in green.

The function polyadd is not in the Matlab toolbox. You will have to copy it to a new m-file to use it. This transfer function assumes that both derivative and integral control will be needed along with proportional control. This does not have to be the case. If you wanted to start with PI control, just remove the kd term from numPID. If you wanted to start with PD control, just remove the ki term from numPID and change denPID to equal[1]. Assuming you do not change the PID control, you should get the following closed-loop numerator and denominator in the Matlab command window:
numc = 4.5455 denc = 1.0000 0 0
4.7273
-26.6363
0.0910
Now we can begin the actual control of this system. First let's see what the impulse response looks like with the numbers we already have. Enter the following code to the end of your m-file:
t=0:0.01:5; impulse(numc,denc,t) axis([0 1.5 0 40])
You should get the following velocity response plot from the impulse disturbance:
This response is still not stable. Let's start by increasing the proportional control to the system. Increase the k variable to see what effect it has on the response. If you set k=100, and set the axis to axis([0, 2.5, -0.2, 0.2]), you should get the following velocity response plot:
The settling time is acceptable at about 2 seconds. Since the steady-state error has already been reduced to zero, no more integral control is needed. You can remove the integral gain constant to see for yourself that the small integral control is needed. The overshoot is too high, so that must be fixed. To alleviate this problem, increase the kd variable. With kd=20, you should get a satisfactory result. You should now see the following velocity response plot:

As you can see, the overshoot has been reduced so that the pendulum does not move more than 0.05 radians away from the vertical. All of the design criteria have been met, so no further iteration is needed. What happens to the cart's position? At the beginning on this solution page, the block diagram for this problem was given. The diagram was not entirely complete. The block representing the the position was left out because that variable was not being controlled. It is interesting though, to see what is happening to the cart's position when the controller for the pendulum's angle is in place. To see this we need to consider the actual system block diagram:
Rearranging a little bit, you get the following block diagram:
The feedback loop represents the controller we have designed for the pendulum's. The transfer function from the cart's position to the impulse force, with the PID feedback controller which we designed, is given as follows:
Recall that den1=den2 if the pole/zero at the origin that was cancelled is added back in. So the transfer function from X to F can be simplified to:
Now that we have the transfer function for the entire system, let's take a look at the response. First we need the transfer function for the cart's position. To get this we need to go back to the laplace transforms of the system equations and find the transfer function from X(s) to U(s). Below is this transfer function:
where,
The pole/zero at the origin cancelled out of the transfer function for Phi, has been put back in. So that now den1 = den2, making calculations easier. Now, create a new mfile and run it in the command window:
q = (M+m)*(i+m*l^2)-(m*l)^2; num1 = [m*l/q 0 0]; den1 = [1 b*(i+m*l^2)/q num2 = [(i+m*l^2)/q den2 = den1 kd = 20; k = 100; ki = 1; numPID = [kd k ki]; denPID = [1 0]; numc = conv(num2,denPID); 0
-(M+m)*m*g*l/q
-b*m*g*l/q
0];
-m*g*l/q];

denc = polyadd(conv(denPID,den2),conv(numPID,num1)); t=0:0.01:5; impulse(numc,denc,t)
As you can see, the cart moves in the negative direction with a constant velocity. So although the PID controller stabilizes the angle of the pendulum, this design would not be feasible to implement on an actual physical system.
Lead-lag controller
The solution to this problem is to add another pole far to the left of the other poles and zeros. To keep the right number of asymptotes, another zero should be added as well. The placement of the added pole and zeros is not important except that the pole should be relatively large and the zeros should be relatively small. Try the m-file below to see what effect the poles and zeros have on the root locus. The polyadd function needs to be copied to the directory you are running Matlab in.
q = (M+m)*(i+m*l^2)-(m*l)^2; num = [m*l/q 0]; den = [1 b*(i+m*l^2)/q
-(M+m)*m*g*l/q
-b*m*g*l/q];

z1 p1 z2 p2 = = = = 3; 0; 4; 50;
numlag = [1 z1]; denlag = [1 p1]; numlead = [1 z2]; denlead = [1 p2]; num3 = conv(conv(num, numlead), numlag); den3 = conv(conv(den, denlead), denlag);
rlocus(num3,den3) sigrid(0.92)
axis([-50 50 -50 50]) figure rlocus(num3,den3) sigrid(0.92) axis([-10 10 -10 10]) [k,poles]=rlocfind(num3,den3) figure numc = conv(conv(num,denlead),denlag); denc = polyadd(k*num3,den3); impulse(numc,denc) axis([0 2 -0.05 0.05])
The poles and zeros were found by trial and error. The only things to keep in mind was that one pole had to be at the origin, the other had to be far to the left, and the two zeros had to be small. Furthermore, I found that if the two zeros were close together and to the right of the farthest left plant pole, the response was better. You should see first the following root locus plot with the zeros and poles listed above:
The second plot should be of the same root locus magnified a little so that the root locus around the origin can be seen.

When prompted to pick a location on the root locus, chose a spot on the multiple roots just before they return to the real axis. Your velocity response to the impulse disturbance should look similar to the following:
The response now meets all of the requirements, so no further iteration is needed. What happens to the cart's position? At the beginning on this solution page, the block diagram for this problem was given. The diagram was not entirely complete. The block representing the the position was left out because that part was not being controlled. It would be interesting though, to see what is happening to the cart's position when the controller for the pendulum's angle is in place. To see this, we need to consider the actual system block diagram:
The feedback loop represents the controller we have designed for the pendulum. The transfer function from the cart's position to the impulse force, with the feedback controller which we designed, is given as follows:
Recall that den1=den2 if the pole/zero at the origin that was canceled is added back in. So the transfer function from X to F can be simplified to:
Transfer Function Now that we have the transfer function for the entire system, let's take a look at the response. First we need the transfer function for the cart's position. To get this we need to go back to the laplace transforms of the system equations and find the transfer function from X(s) to U(s). Below is this transfer function:
where,

The pole/zero at the origin canceled out of the transfer function for Phi, has been put back in. So that now den1 = den2, making calculations easier. Now, create a new mfile and run it in the command window:
q = (M+m)*(i+m*l^2)-(m*l)^2; num1 = [m*l/q 0 0]; den1 = [1 b*(i+m*l^2)/q num2 = [(i+m*l^2)/q den2 = den1 z1 p1 z2 p2 = = = = 3; 0; 4; 50; 0
-(M+m)*m*g*l/q
-b*m*g*l/q
0];
-m*g*l/q];
numlag = [1 z1]; denlag = [1 p1]; numlead = [1 z2]; denlead = [1 p2]; num3 = conv(conv(num1, numlead), numlag); den3 = conv(conv(den1, denlead), denlag); subplot(1,1,1);rlocus(num3,den3) axis([-10 10 -10 10]) [k,poles]=rlocfind(num3,den3) numc = conv(conv(num1,denlead),denlag); denc = polyadd(k*num3,den3); t=0:0.01:6; subplot(2,1,1); impulse(numc,denc,t) axis([0 6 -0.05 0.05]) num4 = conv(num2,den3); den4 = polyadd(conv(den1,den3),k*conv(den1,num3)); subplot(2,1,2); impulse(num4,den4,t) axis([0 6 -0.1 0.1])
If you select the point on the root locus you selected before (near the real axis), you should see the following plot:
The top curve represents the pendulum's angle, and the bottom curve represents the cart's position. As you can see, the cart moves, is stabilized at near zero for almost five seconds, and then goes unstable. It is possible that friction (which was neglected in the modeling of this problem) will actually cause the cart's position to be stabilized. Keep in mind that if this is in fact true, it is due more to luck than to anything else, since the cart's position was not included in the control design.

Solution to the Inverted Pendulum Problem Using Frequency Response Method
The transfer function of the plant for this problem is given below:
where,
Note: There is a pole/zero cancellation in this transfer function. In previous examples these were removed from the transfer function. However, in this example they will be left in for reasons that will become clear later. The design criteria (with the pendulum receiving a 1N impulse force from the cart) are:
y y
Settling time of less than 5 seconds. Pendulum should not move more than 0.05 radians away from the vertical.
Open-loop Representation
The frequency response method uses the bode command in Matlab to find the frequency response for a system described by a transfer function in bode form. The transfer function found from the Laplace transforms for the output Phi (the pendulum's angle) can be set up using Matlab by inputting the numerator and denominator as vectors. Create an m-file (or a '.m' file located in the same directory as Matlab) and copy the following text to model the transfer function:

M m b i g l = = = = = = .5; 0.2; 0.1; 0.006; 9.8; 0.3; %simplifies input -b*m*g*l/q 0]
q = (M+m)*(i+m*l^2)-(m*l)^2; num = [m*l/q 0 0] den = [1 b*(i+m*l^2)/q
-(M+m)*m*g*l/q

num = 4.5455 den = 1.0000
0.1818
-31.1818
-4.4545
Closed-loop response with no compensation

We will now design an inverted pendulum controller for an impulse force using Nyquist diagrams (we cannot use Bode plots because the system is unstable in open loop). Let's begin by looking at the block diagram for this system:
If you try to model this system in Matlab, you will have all sorts of problems. The best way to use Matlab to solve this problem is to first change the schematic to something that can be modeled much more easily. Rearranging the picture, you can get the following new schematic:

Now we can begin our design. First, we will look at the poles and zeros of this function:
x = roots(num) y = roots(den) x = 0 0 y = 0 -5.6041 5.5651 -0.1428
As you already know, we have a pole-zero cancellation at the origin, as well as one positive, real pole in the right-half plane. This means that we will need one anticlockwise encirclement of -1 in order to have a stable closed-loop system (Z = P + N; P = 1, N = -1). The following m-file will be very useful for designing our controller. Please note that you will need the function polyadd.m to run this m-file. Copy and paste the function from your browser to a m-file in your directory (make sure the function command starts in the first column of the m-file). Note: Non-standard Matlab commands used in this example are highlighted in green.
function[ ] = pend() clf figure(1) clf %define TF num = [4.5455 den =[1.0000 figure(1) 0 0]; -31.1818 -4.4545
0.1818
0];
%ask numc denc k
user for controller = input('numc?.........'); = input('denc?.........'); = input('K?............');
%view compensated system bode bode(k*conv(numc,num), conv(denc,den)) %view compensated system nyquist figure(2) subplot (2,1,1) nyquist(k*conv(numc,num), conv(denc,den))

%view compensated CL system impulse response subplot(2,1,2) clnum = conv(num,denc); temp1 = k*conv(numc,num); temp2 = conv(denc, den); clden = polyadd(temp1,temp2); impulse (clnum,clden)
Note: Matlab commands from the control system toolbox are highlighted in red. With this m-file we will now view the uncompensated system's Nyquist diagram by setting the controller numerator, denominator and gain equal to one. Enter pend at the command prompt, and enter 1 for numc, denc, and K. You should see the following plots in your screen:
numc?.........1 denc?.........1 K?............1
Closed-loop response with compensation

The system is unstable in closed loop (no encirclements of -1). Our first step will be to add an integrator to cancel the extra zero at the origin (we will then have two poles and two zeros at the origin). Use the pend command again.
numc?.........1 denc?.........[1 0] K?............1
Notice that the nyquist diagram encircles the -1 point in a clockwise fashion. Now we have two poles in the right-half plane (Z= P + N = 1 + 1). We need to add phase in order to get an anti-clockwise encirclement. We will do this by adding a zero to our controller. For starters, we will place this zero at -1.
numc?.........[1 1] denc?.........[1 0] K?............1
as you can see, this wasn't enough phase. The encirclement around -1 is still clockwise. We are going to need to add a second zero.
numc?.........conv([1 1],[1 1]) denc?.........[1 0] K?............1
We still have one clockwise encirclement of the -1 point. However, if we add some gain, we can make the system stable by shifting the nyquist plot to the left, moving the anti-clockwise circle around -1, so that N = -1. help impulse
numc?.........conv([1 1],[1 1]) denc?.........[1 0] K?............10
As you can see, the system is now stable. We can now concentrate on improving the response. We can modify the poles of the controller in order to do this. We have to keep in mind that small poles (close to the origin) will affect the response at small frequencies, while larger poles (farther from the origin) will affect the response at high frequencies. When designing via frequency response, we are interested in obtaining simple plots, since they will be easier to manipulate in order to achieve our design goal. Therefore, we will use these concepts to 'flatten' the frequency response

(bode plot). At the same time, you will notice that the nyquist diagram will take an oval shape. If we try different combinations of poles and gains, we can get a very reasonable response. (Enter the command axis([0 5 -0.05 0.1]) after the pend command.)
numc?.........conv([1 1.1],[1 5]) denc?.........[1 0] K?............10
Our response has met our design goals. Feel free to vary the parameters and observe what happens. What happens to the cart's position? At the beginning on this solution page, the block diagram for this problem was given. The diagram was not entirely complete. The block representing the the position was left out because that variable was not being controlled. It is interesting though, to see what is happening to the cart's position when the controller for the pendulum's angle is in place. To see this we need to consider the actual system block diagram:
The feedback loop represents the controller we have designed for the pendulum. The transfer function from the cart's position to the impulse force, with the frequency response feedback controller which we designed, is given as follows:
Recall that den1=den2 (the two transfer functions G1 and G2 differ in numerator alone), so the transfer function from X to F can be simplified to:
Transfer Function Now that we have the transfer function for the entire system, let's take a look at the response. First we need the transfer function for the cart's position. To get this we need to go back to the laplace transforms of the system equations and find the transfer function from X(s) to U(s). Below is this transfer function:
where,

The pole/zero at the origin canceled out of the transfer function for Phi, has been put back in. So that now den1 = den2, making calculations easier. Now, create a new mfile and run it in the command window:
q = (M+m)*(i+m*l^2)-(m*l)^2; num1 = [m*l/q 0 0]; den1 = [1 b*(i+m*l^2)/q num2 = [(i+m*l^2)/q den2 = den1; 0
-(M+m)*m*g*l/q
-b*m*g*l/q
0];
-m*g*l/q];
k = 10; numcontroller = conv([1 1.1],[1 5]); dencontroller = [1 0]; numc = conv(numx,dencontroller); denc = polyadd(conv(dencontroller,den),k*conv(numcontroller,num)); t=0:0.01:100; impulse(numc,denc,t)
As you can see, the cart moves in the negative direction and stabilizes at about -0.18 meters. This design might work pretty well for the actual controller, assuming that the

cart had that much room to move in. Keep in mind, that this was pure luck. We were not trying to design to stabilize the cart's position, and the fact that we have is a fortunate side effect.
State-space design for the inverted pendulum

The state equations for this problem are:
The design criteria for this system with the cart receiving a 0.2 m step input are as follows:
y y y y
Settling time for x and theta of less than 5 seconds. Rise time for x of less than 1 second. Overshoot of theta less than 20 degrees (0.35 radians). Steady-state error within 2%.
As you may have noticed if you went through some of the other inverted pendulum examples the design criteria for this example are different. In the other other examples we were dealing with an impulse and not a step input. Also, we were only concerned with the pendulums angle and disregarded the cart's position in the design of the controller. However, for an inverted pendulum it is unrealistic to consider just the single output system. Using state-space methods it is relatively simple to work with a multi-output system, so in this example we will design a controller with both the pendulum angle and the cart position in mind. This problem can be solved using full state feedback. The schematic of this type of control system is shown below:
Open-loop poles In this problem R represents the commanded step input to the cart. The 4 states represent the position and velocity of the cart and the angle and angular velocity of the pendulum. The output y contains both the position of the cart and the angle of the pendulum. We want to design a controller so that when an step input is given to the system, the pendulum should be displaced, but eventually return to zero (i.e. the vertical) and the cart should move to it's new commanded position. To view the system's open-loop response please refer to the inverted pendulum modeling Page The first step in designing this type of controller is to determine the open-loop poles of the system. Enter the following lines of code into a m-file (or a '.m' file located in the same directory as Matlab):
M m b i g l = = = = = = 0.5; 0.2; 0.1; 0.006; 9.8; 0.3;
p = i*(M+m)+M*m*l^2; %denominator A = [0 1 0 0; 0 -(i+m*l^2)*b/p (m^2*g*l^2)/p 0; 0 0 0 1; 0 -(m*l*b)/p m*g*l*(M+m)/p 0]; B = [0; (i+m*l^2)/p; 0; m*l/p]; C = [1 0 0 0; 0 0 1 0]; D = [0;0]; p = eig(A)
The Matlab command window should output the following text as a result:
p = 0 -0.1428

5.5651 -5.6041
As you can see, there is one right-half-plane pole at 5.5651. This should confirm your intuition that the system is unstable in open loop. LQR design The next step in the design process is to assume that we have full-state feedback (i.e. that we can measure all four states), and find the vector K which determines the feedback control law. This can be done in a number of ways. If you know the desired closed-loop poles, you can use the place or acker command. Another option is to use the lqr function; this will give you the optimal controller (under certain assumptions; consult your textbook for more details). The lqr function allows you to choose two parameters, R and Q, which will balance the relative importance of the input and state in the cost function that you are trying to optimize. The simplest case is to assume R=1, and Q=C'*C. You may notice that we are using both outputs (the pendulum's angle and the cart's position). Essentially, the lqr method allows for the control of both outputs. In this case, it is pretty easy to do. The controller can be tuned by changing the nonzero elements in the Q matrix to get a desirable response. Note: Matlab commands from the control system toolbox are highlighted in red. To find the structure of Q, enter the following into the Matlab command window:
C'*C
You should see the following in the command window:

ans = 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0
The element in the 1,1 position will be used to weight the cart's position and the element in the 3,3 position will be used to weight the pendulum's angle. The input weighting R will remain at 1. Now that we know what the Q matrix should look like we can experiment to find the K matrix that will give us a good controller. We will go ahead and find the K matrix and plot the response all in one step so that changes can be made in the control and be seen automatically in the response. Enter the following text into your m-file:
x=1; y=1;

Q=[x 0 0 0; 0 0 0 0; 0 0 y 0; 0 0 0 0]; R = 1; K = lqr(A,B,Q,R) Ac = [(A-B*K)]; Bc = [B]; Cc = [C]; Dc = [D]; T=0:0.01:5; U=0.2*ones(size(T)); [Y,X]=lsim(Ac,Bc,Cc,Dc,U,T); plot(T,Y) legend('Cart','Pendulum')
You should get the following value for K and a response plot:
K = -1.0000 -1.6567 18.6854 3.4594
The curve in green represents the pendulum's angle, in radians and the curve in blue represents the cart's position in meters. As you can see, this plot is not satisfactory. The pendulum and cart's overshoot appear fine, but their settling times need improvement and the cart's rise time needs to go down. As I'm sure you have noticed the cart is not near the desired location but has in fact moved in the other direction. This error will be dealt with in the next section and right now we will focus on the settling and rise times. Go back to your m-file and change the x and y variables to see if you can get a better response. You will find that increasing x makes the settling and

rise times go down, and lowers the angle the pendulum moves. Using x=5000 and y=100, the following value of K and step response were found:
K = -70.7107 -37.8345 105.5298 20.9238
You may have noted that if you increased x and y even higher, you could improve the response even more. The reason this plot was chosen was because it satisfied the design requirements while keeping x and y as small as possible. In this problem, x and y have been used to describe the relative weight of the tracking error in the cart's position and pendulum's angle versus the control effort. The higher x and y are, the more control effort is used, but the smaller the tracking error. The system response has a settling time under 2 seconds. Adding the reference input Now we want to get rid of the steady-state error. In contrast to the other design methods, where we feedback the output and compare it to the reference input to compute an error, with a full-state feedback controller we are feeding back all the states. We need to compute what the steady-state value of the states should be, multiply that by the chosen gain K, and use a new value as our reference for computing the input. This can be done by adding a constant gain Nbar after the reference. The schematic below shows this relationship:
Nbar can be found using the user-defined function rscale (copy it to the directory that your m-file is in). Delete the lsim line and copy the following to your m-file and run it to view the step response with Nbar added.
Cn=[1 0 0 0]; Nbar=rscale(A,B,Cn,0,K) Bcn=[Nbar*B]; [Y,X]=lsim(Ac,Bcn,Cc,Dc,U,T); plot(T,Y) legend('Cart','Pendulum')
Note: Non-standard matlab commands are highlighted in green. A different C had to be used because the rscale function will not work for multiple outputs. However, the Nbar found is correct, as you can see from the output below:
Nbar = -70.7107
Now, the steady-state error is within our limits, the rise and settling times are met and the pendulum's overshoot is within range of the design criteria. Observer design This response is good, but was found assuming full-state feedback, which most likely will not be a valid assumption. To compensate for this, we will next design a fullorder estimator to estimate those states that are not measured. A schematic of this kind of system is shown below, without Nbar:
To begin, we must first find the controller poles. To do this copy the following code to the end of your m-file:
p = eig(Ac)

If you changed the weighting factors x and y above to x=5000 and y=100, you should see the following poles in the Matlab command window:
p = -8.4910 -8.4910 -4.7592 -4.7592 + + 7.9283i 7.9283i 0.8309i 0.8309i
We want to design estimator poles that are about 4-10 times as fast as slowest pole, say at -40. We will use the place command in Matlab to find the L vector (note that acker would also work). Remember that theplace command cannot have all the desired poles at the same location. Delete from the lsim command on and enter the following text to the end of your m-file to find the L matrix:
P = [-40 -41 -42 -43]; L = place(A',C',P)'
We are using both outputs (the angle of the pendulum and the position of the cart) to design the observer. The system is not observable using only the angle of the pendulum as output; you can check this in Matlab by computing rank(obsv(A,C(2,:))). This should make sense to you: if you can only measure the angle of the pendulum, you cannot determine what the position of the cart will be. You should see the following in the Matlab window:
L = 1.0e+03 * 0.0826 1.6992 -0.0014 -0.0762 -0.0010 -0.0402 0.0832 1.7604
Now we will combine the control-law design with the estimator design to get the compensator. The response should be similar to the one from the control-law design. To set up the compensator copy the following code to the end of your m-file:
Ace = [A-B*K B*K; zeros(size(A)) (A-L*C)]; Bce = [ B*Nbar; zeros(size(B))]; Cce = [Cc zeros(size(Cc))]; Dce = [0;0]; T = 0:0.01:5; U = 0.2*ones(size(T)); [Y,X] = lsim(Ace,Bce,Cce,Dce,U,T); plot(T,Y)

legend('Cart','Pendulum')
After running this m-file, you should output the following step response simulation plot:
This response is about the same as before. All of the design requirements have been met with the minimum amount of control effort, so no more iteration is needed. As you can see, it is much easier to control multi-input or multi-output systems with the state space method than with any other of the methods.

Modeling An Inverted Pendulum

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Modeling An Inverted Pendulum

Diunggah oleh

Hak Cipta:

Format Tersedia

Inverted Pendulum Model

Inverted Pendulum Model

Inverted Pendulum Model