PID a1 1

CENG4480_A4DC motor Control

Using PID

(proportional-integral-derivative) control

PID a1 2

PID (proportional-integral-derivative) control

A more formal and precise method

Used in most modern machines

PID a1 3

Introduction• Control for better performance

• Use PID, choose whatever response you want

Good performanceCriteria depends on users and applications

Too much overshoot/undershoot, not stable

Response too slow

time

Motor speed (w)

required

PID a1 4

values to evaluate a control system

•

Typicallyvalue=10%Depends on application

Rise time Settling time0 time

Target value

overshoot

Steady state error

undershoot

PID a1 5

control method:PID (proportional-integral-derivative) control

•

Required speed=

Wsl_speed_input (u)

IR wheelSpeedencoder

Wsl_speed_measured

+

- speed(w)

Motor

Amplifier K1 and Alter PWM for driver L293

wsl_t_on

I=integral control

delta_speed dt

P=proportional and integral control

delta_speed dt ;

D=derivative control

d(delta_speed)/dt ;

sum

e=error term=delta_speed

PID a1 6

•

control method: Theory of a feedback control system

2 10 20p

p

K

s s K

Required speed=

Wsl_speed_input (u)

IR wheelSpeedencoder

+

-speed(w)

Motor

sumAController:Collect errorto drive the plant

( )

1

1

1

u w AB w

w wAB

u u

wAB AB

uw AB

u AB

e=error term

speed(w)

BPlant: use control parameters to derive the system

PID a1 7

•

( )

p

u w AB w

K e w

P (proportional) control of speed

2 10 20p

p

K

s s K

Required speed=

Wsl_speed_input (u)

IR wheelSpeedencoder

+

- speed(w)

Motor

Kpe sum

1B

speed(w)

Set Kp=A

e=error term

PID a1 8

PD (proportional-derivative) control of speedalternative names Pre-act or rate control

•

2 10 20p

p

K

s s K

Required speed=

Wsl_speed_input (u)

IR wheelSpeedencoder

+

- speed(w)

Motor

Kpe sum

Kd*[d(e)/dt]

1B

A

p d

deK e K w

dt

speed(w)

e=error term

PID a1 9

PID (proportional-derivative-integral) control of speed

•

2 10 20p

p

K

s s K

Required speed=

Wsl_speed_input (u)

IR wheelSpeedencoder

+

- speed(w)

Motor

Kpe sum

1B

AKi*[ (e)dt]

Kd*[d(e)/dt]

( )p d i

deK e K K e dt w

dt

speed(w)

e=error term

PID a1 10

values to evaluate a control system

•

Typicallyvalue=10%Depends on application

Rise time Settling time0 time

Target value

overshoot

Steady state error

undershoot

PID a1 11

Use of PIDcontrol terms are intertwined

http://en.wikipedia.org/wiki/PID_controller• Kp: Proportional Gain - Larger Kp typically means

faster response since the larger the error, the larger the Proportional term compensation. An excessively large proportional gain will lead to process instability and oscillation.

• Ki: Integral Gain - Larger Ki implies steady state errors are eliminated quicker. The trade-off is larger overshoot: any negative error integrated during transient response must be integrated away by positive error before we reach steady state.

• Kd: Derivative Gain - Larger Kd decreases overshoot, but slows down transient response and may lead to instability due to signal noise amplification in the differentiation of the error.

PID a1 12

Reason for proportional controlhttp://www.jashaw.com/pid.html

• Bigger error will give more input to the plant to enable the output to reach the target faster

• Improve risetime

PID a1 13

Reason for Derivative controlor called Pre-act or rate control

http://www.jashaw.com/pid.html

• Adjust output based on the rate of change the error

• Decrease overshoot (caused by the integral term and proportional term)

• But also amplifier noise, may make system unstable.

• See http://www.controlguru.com/wp/p76.html

PID a1 14

Example to show how derivative control reduces overshoot

http://www.controlguru.com/wp/p76.html

• u=setpoint, • wt, motor speed measured• et=u-wt,-----(1)• If u is stable , w rises from

0 to u• Differentiate (1) we get • d(et)/dt = -d(wt)/dt ---(2)• When w is increasing, the

system suppresses its growth, hence reduces overshoot

p d

p d

deK e K w

dtdw

K e K wdt

Setpointu

time

w

speed

PID a1 15

Example to show how derivative control reduces oscillation

• Stable requirement u, changing motor speed w– The robot is moving at a constant speed wu– A small rock hiders its motion, so reduces the motor speed wt,

u=setpoint, – et=u-wt,-----(1), – d(et)/dt = -d(wt)/dt ---(2)– From (1) when wt decreases, e increases, so the system

increases power to the motor to enable wt+1 approach u.– The reverse is also true, e.g. the robot suddenly goes downhill (or

just overcome the small rock) and speed increases, the system should decease the power to the motors.

• Changing requirement u, stable motor speed w– It is also true for a stable w and increasing u, since de/dt=du/dt,

so power is increased to keep up with the required u.

p d

deK e K w

dt

wt-1 wt wt+1

u

rock

PID a1 16

Reason for Integral controlor called automatic reset

http://www.jashaw.com/pid.html• In proportional only control the output cannot reach the target value

(setpoint) without using a bias.• Output=gain*error + bias, E.g.

– w=kp*(u-w) + bias, do the following exercise– without bias u=10, Kp=100, bias=0,so w=>9.99009– With bias u=10, Kp=100, w=10, so B=>10 – Without a computer the bias is set manually

• With the computer, the bias can be calculated by the integral term• Decrease steady state error• It helps the system quickly reaches the set point • But it increases overshoot because of the cumulated term• Integral Windup problem

(http://www.controlguru.com/2008/021008.html)– If error is positive/negative for too long accumulated error will saturate the

system or is over the limit that the system can response to (can damage the motor, ie. when the motor is driven by an analog voltage)

– Solution: Set maximum and minimum values for the integral term

PID a1 17

Example: Step response to evaluate a system-- ask the motor to change from 0 to unit speedhttp://www.engin.umich.edu/group/ctm/PID/PID.html

• Matlab code• Kp=350; • Ki=300; • Kd=50; • num=[Kd Kp Ki]; • den=[1 10+Kd 20+Kp

Ki]; • t=0:0.01:2; • step(num,den,t)

•

Matlab code to valuate the systemtime

speed

Good smooth PIDcontrol result

PID a1 18

Effects (in matlab)

• Reduce Kp

• Kp=100;

• Ki=300;

• Kd=50;

Kp=350;

increase Ki

Ki=3000;

Kd=50;

• Kp=350;

• Ki=300;

• Kd=50;

Kp=350;Ki=300;Reduce KdKd=10;Bad ,

too much overshoot

Too slowSettling time too long

high much overshoot

Best, near to ideal

PID a1 19

General tips for designing a PID controllerhttp://www.engin.umich.edu/group/ctm/PID/PID.html

• When you are designing a PID controller for a given system, follow the steps shown below to obtain a desired response.

• Obtain an open-loop response and determine what needs to be improved. (Step input, see output)

• Add a proportional control (Kp) to improve the rise time • Add a derivative control (Kd) to improve the overshoot • Add an integral control (Ki) to eliminate the steady-state

error • Adjust each of Kp, Ki, and Kd until you obtain a desired

overall response. See the table in the next slide.

PID a1 20

Effects of increasing parametershttp://en.wikipedia.org/wiki/PID_controller

•

Parameter Rise Time Overshoot Settling Time

Steady state error

Kp Decrease

step1

Increase Small Change

Decrease

Ki Decrease Increase Increase Eliminate

step3

Kd Small Change

Decrease

step2

Decrease Small Change

PID a1 21

PID

Implementation

PID a1 22

ISR for PID controlhttp://www.hitex.co.uk/c166/pidex.html

• Main()• {derivative_gain, proportional_gain, integral_gain should be set in the main

program}

• Interrupt service routine ISR() // set a cycle freq , e.g. 1KHz• { • 0) measure error• 1) Calculate Proportional Term • 2) Calculate derivative term• 3) Calculate Integral Term • 4) Sum Up {Proportional+ derivative+ Integral } and use it to control the

output• }

PID a1 23

Checking overflow

• Checking overflow of terms is essential to make the system reliable

PID a1 24

1) Calculate Proportional Term (Kp=proportional_gain) http://www.hitex.co.uk/c166/pidex.html

• To make sure the error term does not overflow• /*** Calculate Proportional Term ***/• proportional_term_temp = ((long)this_error * (long)proportional_gain) ; • /*** Check For Proportional Term Out Of Range & Apply Saturation ***/

if(proportional_term_temp > (long)((long)32767 * Inputs_Scale_Factor)) {

proportional_term = 32767 ; } else {

if(proportional_term_temp <= (long)((long)-32768 * Inputs_Scale_Factor)) {

proportional_term = -32768 ; } else { proportional_term =

(short)((long)proportional_term_temp/Inputs_Scale_Factor) ; }

}

PID a1 25

2) Calculate derivative term (Kd=derivative_gain)

• //The derivative term is simply calculated /*** Calculate Derivative Term ***/derivative_term = ((long)(this_error - PID.last_error) * derivative_gain)/(long)Inputs_Scale_Factor ;

Motor2 10 20

p

p

K

s s K

Required speed=

Wsl_speed_input (u)

IR wheelSpeedencoder

+

- speed(w)

Motor

Kp sum

Kd*d(e)/dt 1B

A

e=error tem

PID a1 26

3) Calculate Integral Term (Ki=integral_gain)

• /*** Find Accumulated Error ***/ acc_error_temp = ((long)PID.accumulated_error) + (long)this_error ;

/*** Check For Accumulated Error Out Of Range ***/

if(acc_error_temp > (long)32767) { // Is error > maximum value?

acc_error_temp = 32767 ;

// Limit to max +ve value

}

if(acc_error_temp < (long)-32768) {

// Is error < minimum value?

acc_error_temp = -32768 ;

// Limit to max -ve value }

PID.accumulated_error = (short) acc_error_temp ;

PID a1 27

Calculate Integral Term -- calculate and check for overflow

• /*** Calculate Integral Term ***/

integral_term_temp = ((long)PID.accumulated_error * (long)integral_gain) ;

/*** Check For Integral Term Out Of Range & Apply Saturation ***/

if(integral_term_temp > (long)((long)32767 * Inputs_Scale_Factor)) { integral_term = 32767 ; } else {

if(integral_term_temp <= (long)((long)-32768 * Inputs_Scale_Factor))

{ integral_term = -32768 ; } else { integral_term = integral_term_temp/Inputs_Scale_Factor ;

} }

Integral Windup problemIf error is positive/negative for too long accumulated error will saturate the system

Solution: Set maximum and minimum values for the integral term

PID a1 28

4) Sum Up Control Terms

• /*** Sum Up Control Terms ***/ • control_output_temp = (long) integral_term ; • control_output_temp += (long)derivative_term ; • control_output_temp += (long) proportional_term ;

• /* Limit Value Of Control Term */ • if(control_output_temp > 32767) • { control_output_temp = 32767 ; } • else • {

if(control_output_temp < 0)

• { control_output_temp = 0 ; • } • }

PID a1 29

PID Tuning

• Tune (adjust manually)– proportional_gain (Kp), – integral_gain (Ki)– derivative_gain (Kd),

• Set constant speed V1 for a while (5 seconds) and stop at T1

– Record the speed by the computer after T1 and see if it is ok

• Yes (accept Kp,Ki,Kd)• No (tune again)

Motor speed V1

(V1)/2

Accepted performance

unstable

done

PID a1 30

Summary

• Studies PID control theory and implementation