PID controller in flight stabilization in Drone Programming - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to calculate the proportional term in the PID controller.

Drone Programming

proportional = [1] * error

Drag options to blanks, or click blank then click option'

Akp

Bki

Ckd

Ddt

Attempts:

3 left

💡 Hint

Common Mistakes

Using integral gain 'ki' instead of proportional gain 'kp'.

Using derivative gain 'kd' instead of proportional gain.

Using time delta 'dt' as a gain.

The proportional term is calculated by multiplying the proportional gain kp by the current error.

2fill in blank

medium

Complete the code to update the integral term by adding the current error multiplied by the time delta.

Drone Programming

integral += [1] * error

Drag options to blanks, or click blank then click option'

Adt

Bki

Ckp

Dkd

Attempts:

3 left

💡 Hint

Common Mistakes

Using gain constants instead of time delta.

Not multiplying error by time delta.

Using derivative gain 'kd' here.

The integral term accumulates the error over time, so we multiply the error by the time delta dt before adding it.

3fill in blank

hard

Fix the error in calculating the derivative term which should be the change in error divided by the time delta.

Drone Programming

derivative = (error - [1]) / dt

Drag options to blanks, or click blank then click option'

Aintegral

Berror

Ckp

Dprevious_error

Attempts:

3 left

💡 Hint

Common Mistakes

Using integral instead of previous error.

Using current error instead of previous error.

Dividing by error instead of time delta.

The derivative term measures how fast the error is changing, so we subtract the previous error from the current error.

4fill in blank

hard

Fill both blanks to compute the PID output by summing proportional, integral, and derivative terms multiplied by their gains.

Drone Programming

output = kp * error + [1] + [2]

Drag options to blanks, or click blank then click option'

Aki * integral

Bkd * derivative

Cdt * integral

Derror * kd

Attempts:

3 left

💡 Hint

Common Mistakes

Using time delta instead of gains.

Multiplying error by derivative gain directly.

Forgetting to multiply integral and derivative by their gains.

The PID output sums the proportional term, the integral term multiplied by ki, and the derivative term multiplied by kd.

5fill in blank

hard

Fill all three blanks to update the previous error, calculate the control signal, and apply it to the drone's pitch adjustment.

Drone Programming

previous_error = [1]
control_signal = kp * error + ki * integral + [2]
pitch_adjustment = [3](control_signal)

Drag options to blanks, or click blank then click option'

Aerror

Bkd * derivative

Capply_pitch

Dintegral

Attempts:

3 left

💡 Hint

Common Mistakes

Not updating previous error correctly.

Omitting derivative term in control signal.

Calling wrong function to apply pitch adjustment.

We update previous_error with the current error, calculate the control signal including the derivative term multiplied by kd, and then apply the control signal using the apply_pitch function.

Practice

1. What is the main purpose of a PID controller in drone flight stabilization?

easy

A. To keep the drone balanced by adjusting its movements smoothly

B. To increase the drone's speed to maximum

C. To make the drone fly in a straight line without any control

D. To turn off the drone automatically when battery is low

Solution

1. Step 1: Understand the role of PID controller

   A PID controller uses error, integral, and derivative to adjust movements smoothly.

2. Step 2: Connect PID function to drone stabilization

   This adjustment helps keep the drone balanced and stable during flight.

3. Final Answer:

   To keep the drone balanced by adjusting its movements smoothly -> Option A

4. Quick Check:

   PID controls balance = To keep drone balanced [OK]

Hint: PID controls balance and smooth movement in drones [OK]

Common Mistakes:

• Thinking PID only controls speed
• Confusing PID with battery management
• Assuming PID makes drone fly straight without control

2. Which of the following is the correct way to calculate the derivative term in a PID controller code snippet?

easy

A. derivative = previous_error - current_error * delta_time

B. derivative = current_error + previous_error * delta_time

C. derivative = current_error * previous_error / delta_time

D. derivative = (current_error - previous_error) / delta_time

Solution

1. Step 1: Recall derivative formula in PID

   The derivative term measures how fast error changes: (current_error - previous_error) / delta_time.

2. Step 2: Match formula with options

   derivative = (current_error - previous_error) / delta_time matches the correct derivative calculation formula exactly.

3. Final Answer:

   derivative = (current_error - previous_error) / delta_time -> Option D

4. Quick Check:

   Derivative = error change over time [OK]

Hint: Derivative = change in error divided by time [OK]

Common Mistakes:

• Adding errors instead of subtracting
• Multiplying errors incorrectly
• Ignoring division by delta_time

3. Given this Python-like pseudocode for a PID controller update step:

error = target_angle - current_angle
integral += error * dt
derivative = (error - last_error) / dt
output = Kp * error + Ki * integral + Kd * derivative
last_error = error
print(round(output, 2))

If target_angle = 10, current_angle = 7, last_error = 2, integral = 5, dt = 1, Kp = 1, Ki = 0.1, and Kd = 0.05, what is the printed output?

medium

A. 4.65

B. 5.15

C. 3.85

D. 6.00

Solution

1. Step 1: Calculate error, integral, and derivative

   error = 10 - 7 = 3
   integral = 5 + 3 * 1 = 8
   derivative = (3 - 2) / 1 = 1

2. Step 2: Calculate output using PID formula

   output = 1 * 3 + 0.1 * 8 + 0.05 * 1 = 3 + 0.8 + 0.05 = 3.85
   print(round(3.85, 2)) prints 3.85

3. Final Answer:

   3.85 -> Option C

4. Quick Check:

   PID output = 3.85 [OK]

Hint: Calculate error, integral, derivative stepwise [OK]

Common Mistakes:

• Forgetting to update integral before output
• Mixing up last_error and error in derivative
• Rounding errors or ignoring dt

4. Identify the error in this PID controller snippet and choose the correct fix:

integral = 0
dt = 0.1
error = target - current
integral += error
output = Kp * error + Ki * integral * dt + Kd * (error - last_error) / dt

medium

A. Multiply integral by dt before adding error: integral += error * dt

B. Remove dt multiplication from Ki term: output = Kp * error + Ki * integral + Kd * (error - last_error) / dt

C. Divide integral by dt in output: output = Kp * error + Ki * (integral / dt) + Kd * (error - last_error) / dt

D. Add dt to derivative term: output = Kp * error + Ki * integral * dt + Kd * (error - last_error) * dt

Solution

1. Step 1: Check integral update

   Integral should accumulate error over time, so multiply error by dt when adding: integral += error * dt.

2. Step 2: Verify output formula

   Ki term multiplies integral, which already includes dt, so no extra dt needed in output.

3. Final Answer:

   Multiply integral by dt before adding error: integral += error * dt -> Option A

4. Quick Check:

   Integral update needs dt multiplication [OK]

Hint: Integral sums error over time, multiply error by dt [OK]

Common Mistakes:

• Adding error directly to integral without dt
• Multiplying integral by dt twice
• Changing derivative term incorrectly

5. You want to tune a PID controller to make a drone respond faster but avoid overshooting. Which tuning approach is best?

hard

A. Increase Kp a lot, keep Ki and Kd low

B. Increase Kd, keep Kp moderate, reduce Ki

C. Increase Kp moderately, increase Ki slightly, decrease Kd

D. Set all constants to zero and increase gradually

Solution

1. Step 1: Understand tuning effects

   Kp controls speed of response, Ki removes steady error, Kd reduces overshoot by damping.

2. Step 2: Choose tuning to speed up and reduce overshoot

   Increasing Kd helps reduce overshoot, moderate Kp keeps response fast but stable, reducing Ki avoids windup.

3. Final Answer:

   Increase Kd, keep Kp moderate, reduce Ki -> Option B

4. Quick Check:

   More Kd reduces overshoot, moderate Kp speeds response [OK]

Hint: Use Kd to reduce overshoot, moderate Kp for speed [OK]

Common Mistakes:

• Increasing Kp too much causing oscillations
• Ignoring Kd's role in damping
• Setting all constants to zero initially