PID controller in flight stabilization in Drone Programming - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of PID controller error calculation

Consider a PID controller for drone pitch stabilization. The error is calculated as the difference between the desired pitch angle and the current pitch angle. Given the following code snippet, what is the output of the error value?

Drone Programming

desired_pitch = 10.0
current_pitch = 7.5
error = desired_pitch - current_pitch
print(error)

A 2.5

B -2.5

C 17.5

D None

💡 Hint

Subtract current pitch from desired pitch to get error.

The error is the difference between desired and current pitch: 10.0 - 7.5 = 2.5.

❓ Predict Output

intermediate

Integral term accumulation in PID controller

In a PID controller, the integral term sums all past errors to reduce steady-state error. Given the code below, what is the value of integral after the loop?

Drone Programming

errors = [0.5, 0.3, -0.2, 0.1]
integral = 0.0
for e in errors:
    integral += e
print(round(integral, 2))

A -0.7

B 0.6

C 0.7

D 0.0

💡 Hint

Add all error values together.

Sum of errors: 0.5 + 0.3 + (-0.2) + 0.1 = 0.7.

🔧 Debug

advanced

Identify the cause of oscillation in PID output

A drone's PID controller code causes oscillations in pitch angle. Which option shows the most likely cause?

Drone Programming

def pid_output(error, integral, derivative, Kp, Ki, Kd):
    return Kp * error + Ki * integral + Kd * derivative

# Given values
error = 2.0
integral = 1.0
derivative = -0.5
Kp = 1.5
Ki = 0.0
Kd = 2.0

output = pid_output(error, integral, derivative, Kp, Ki, Kd)
print(output)

A Kd is negative, causing unstable derivative effect

B Ki is zero, so integral term is ignored causing oscillations

C Derivative value is negative, causing output to oscillate

D Kp is too low to stabilize error

💡 Hint

Integral term helps reduce steady oscillations.

Ki is zero, so the integral term does not help correct steady errors, causing oscillations.

📝 Syntax

advanced

Syntax error in PID controller update function

Which option contains the correct syntax for updating the integral term in a PID controller in Python?

Drone Programming

integral = 0.0
error = 1.2
dt = 0.1

A integral = error * dt +

B integral =+ error * dt

C integral += error / dt

D integral += error * dt

💡 Hint

Use += to add the product of error and dt to integral.

Option D correctly adds error * dt to integral. Option D is a syntax error (wrong operator), C divides instead of multiplies, D ends with an operator causing syntax error.

🧠 Conceptual

expert

Effect of increasing derivative gain (Kd) in PID controller

In a drone's PID controller for flight stabilization, what is the most likely effect of significantly increasing the derivative gain (Kd)?

A It reduces overshoot and smooths the response by reacting to error changes quickly

B It increases steady-state error by ignoring past errors

C It causes the drone to ignore current error and only focus on past errors

D It makes the drone respond slower by reducing the proportional effect

💡 Hint

Derivative gain reacts to how fast error changes.

Increasing Kd helps the controller react to rapid changes in error, reducing overshoot and smoothing the response.

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