Controller design by R.L. Typical setup: C(s) Gp(s) Root Locus Based Controller Design Goal: Select poles and zero of C(s) so that R.L. pass through desired region Select K corresponding to a good choice of dominant pole pair

Types of classical controllers Proportional control Needed to make a specific point on RL to be closed-loop system dominant pole Proportional plus derivative control (PD control) Needed to “bend” R.L. into the desired region Lead control Similar to PD, but without the high frequency noise problem; max angle contribution limited to < 75 deg Proportional plus Integral Control (PI control) Needed to “eliminate” a non-zero steady state tracking error Lag control Needed to reduce a non-zero steady state error, no type increase PID control When both PD and PI are needed, PID = PD * PI Lead-Lag control When both lead and lag are needed, lead-lag = lead * lag

Proportional control design Draw R.L. for given plant Draw desired region for poles from specs Pick a point on R.L. and in desired region Use ginput to get point and convert to complex # Compute K using abs and polyval Obtain closed-loop TF Obtain step response and compute specs Decide if modification is needed nump=…; denp= …; sys_p=tf(nump,denp); rlocus(sys_p); sys_cl = feedback(sys_c*sys_p,1); use your program from several weeks ago to do all these

PD controller design Design steps: From specs, draw desired region for pole. Pick from region, not on RL Compute Select Select: [x,y]=ginput(1); pd=x+j*y; Gpd=evalfr(sys_p,pd) phi=pi - angle(Gpd) z=abs(real(pd))+abs(imag(pd)/tan(phi)); Kd=1/abs(pd+z)/abs(Gpd); Kp=z*Kd;

From specs draw region for desired c.l. poles Select pd from region Approximation to PD Same usefulness as PD Lead Control: Draw R.L. for G From specs draw region for desired c.l. poles Select pd from region Let Pick –z somewhere below pd on –Re axis Let Select [x,y]=ginput(1); pd=x+j*y; Gpd=evalfr(sys_p,pd) phi=pi - angle(Gpd) [x,y]=ginput(1); z=abs(x); phi1=angle(pd+z); phi2=phi1-phi; p=abs(real(pd))+abs(imag(pd)/tan(phi2)); K=abs((pd+p)/(pd+z)/Gpd); sys_c=tf(K*[1 z],[1 p]); Hold on; rlocus(sys_c*sys_p);

Alternative Lead Control Draw R.L. for G From specs draw region for desired c.l. poles Select pd from region Let Select phipd=angle(pd); phi1=(phipd+phi)/2; phi2=phi1-phi;

Lag Design steps Draw R.L. for G(s). From specs, draw desired pole region Select pd on R.L. & in region Get With that K, compute error constant (Kpa, Kva, Kaa) from KG(s) From specs, compute Kpd, Kvd, Kad sys_ol = sys_c*sys_p; [nol,dol]=tfdata(sys_ol,'v'); dn0=dol(dol~=0); Kact=nol(end)/dn0(end); Kdes = 1/ess;

If K#a > K#d , done else: pick Re-compute Closed-loop simulation & tuning as necessary z=-real(pd)/…; p=z*Kact/Kdes/(1+…); 0.05 or 0.1

PI Design steps First design: design PD for G(s)/s Second design: Draw R.L. for G(s) From specs, draw desired region Pick pd on R.L. & in region i. Choose ii. Choose Simulate & tune

C(s) G (s) Example: Want:

Sol:. G(s) is type 1 Since we want finite ess to unit acc, Sol: G(s) is type 1 Since we want finite ess to unit acc, we need the compensated system to be type 2 C(s) needs to have in it

Draw R.L., it passes through the desired region. Pick pd on R.L. & in Region pick pd = – 180 + j160 Now choose z to meet Ka:

Also:

Pick z = 0.03 Do step resp. of closed-loop: Is it good enough?

Design goal:

If tr = 0.0105 not satisfactory we need to reduce tr by ≈ 5%

Overall controller design R(s) E(s) C(s) U(s) Gp(s) Y(s) Draw R.L. for G(s), hold graph Draw desired region for closed-loop poles based on desired specs If R.L. goes through region, pick pd on R.L. and in region. Go to step 7.

Pick pd in region (near corner but inside region for safety margin) Compute angle deficiency: a. PD control, choose zpd such that then

b. Lead control: choose zlead, plead such that You can select zlead & compute plead. Or you can use the “bisection” method to compute z and p. Then

Compute overall gain: If there is no steady-state error requirement, go to 14. With K from 7, evaluate error constant that you already have:

The 0, 1, 2 should match p, v, a This is for lag control. For PI:

Compute desired error const. from specs: For PI : set K*a = K*d & solve for zpi For lag : pick zlag & let

Re-compute K Get closed-loop T.F. Do step response analysis. If not satisfactory, go back to 3 and redesign.

If we have both PI and PD we have PID control:

If we have both Lead and Lag, we have lead-lag control:

Lead-lag design example Too much overshoot, too slow & ess to ramp is too large. R(s) E(s) C(s) U(s) Gp(s) Y(s)

Draw R.L. for G(s) & the desired region

Clearly R.L. does not pass through desired region. need PD or lead. Let’s do lead. Pick pd in region

Now choose zlead & plead. Could use bisection. Let’s pick zlead to cancel plant pole s + 0.5

Use our formula to get plead Now compute K : Now evaluate error constant Kva

Could re-compute K, but let’s skip: do step response.

Control System Implementation R(s) E(s) C(s) U(s) Gp(s) Y(s) disturbance input Reference Command output error Controller control Actuator Plant + _ plant input Sensor noise

PC-in-the-loop Control disturbance input Reference Command PC I/O output D/A power Amp Actuator Plant Signal Conditioner and amplifier A/D Sensor All control algorithms implemented in PC (could be Matlab Real-Time) Needs data acquisition system, including A/D and D/A Needs power amplifier

m-Controller based control disturbance input Reference Command m-Controller I/O output power Amp Actuator Plant Signal Conditioner and amplifier Sensor Very similar architecture to PC-in-the-loop control All control algorithms implemented in m-controller m-controller has its own A/D and D/A, but make sure resolution is OK Still needs power amplifier, because m-controller outputs weak signal

Power electronic based control disturbance input Reference Command Difference amplifier output Op Amp circuit Actuator Plant Sensor Analog operation, fast Inexpensive All algorithms in circuit hardware No sampling and aliasing issues

Difference Amplifier Example circuit: R2 R1 r + − e y R3 R4

Op-amp controller circuit: Proportional: − + e − + u

Integral: C1 R4 R1 R3 − + e − + u

Derivative control: R2 R4 C1 R3 − + e − + u

PD controller: R2 R4 C1 R3 − + e − + u R1

PI controller: R2 C1 R4 R1 R3 − + e − + u

PID controller: R2 C2 R4 R1 R3 − + e − + u C1

Lead or lag controller: − + e − + u C1

If R1C1 > R2C2 then z < p This is lead controller If R1C1 < R2C2 then z > p This is lag controller

Lead-lag controller: R2 C2 R4 R6 R1 C1 R5 − + e − + u R3