PID controller in flight stabilization in Drone Programming - Step-by-Step Execution

Concept Flow - PID controller in flight stabilization

Read current angle

↓

Calculate error = target - current

↓

Calculate P term = Kp * error

↓

Calculate I term = I term + Ki * error * dt

↓

Calculate D term = Kd * (error - last_error) / dt

↓

Calculate output = P + I + D

↓

Send output to motors

↓

Update last_error = error

↩Loop back to Read current angle

The PID controller reads the current angle, calculates error, computes proportional, integral, and derivative terms, combines them to get output, sends output to motors, then repeats.

Execution Sample

Drone Programming

error = target_angle - current_angle
P = Kp * error
I += Ki * error * dt
D = Kd * (error - last_error) / dt
output = P + I + D
last_error = error

This code calculates the PID output to adjust the drone's angle towards the target.

Execution Table

Step	target_angle	current_angle	error	P	I	D	output	last_error
1	10	7	3	0.6	0.03	0	0.63	0
2	10	8	2	0.4	0.05	-0.3	0.15	3
3	10	9	1	0.2	0.06	-0.3	-0.04	2
4	10	9.5	0.5	0.1	0.065	-0.5	-0.335	1
5	10	9.8	0.2	0.04	0.067	-0.3	-0.193	0.5
Exit	10	9.8	0.2	0.04	0.067	-0.3	-0.193	0.2

💡 Loop ends after 5 steps for demonstration; in real use, it runs continuously.

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	After 5
error	0	3	2	1	0.5	0.2
P	0	0.6	0.4	0.2	0.1	0.04
I	0	0.03	0.05	0.06	0.065	0.067
D	0	0	-0.3	-0.3	-0.5	-0.3
output	0	0.63	0.15	-0.04	-0.335	-0.193
last_error	0	3	2	1	0.5	0.2

Key Moments - 3 Insights

Why does the derivative term (D) become negative when error decreases?

Because D depends on the change in error (error - last_error). When error decreases, this difference is negative, making D negative as shown in steps 2 and 3 in the execution_table.

Why does the integral term (I) keep increasing even when error gets smaller?

Integral term sums all past errors over time, so even small errors add up gradually, as seen increasing from 0.03 to 0.067 across steps in the execution_table.

Why do we update last_error at the end of each step?

We update last_error to remember the previous error for the next derivative calculation, ensuring D term reflects error change correctly, as shown in the last column of execution_table.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what is the value of the derivative term (D)?

A 0.5

B 0

C -0.5

D 0.06

💡 Hint

Check the 'D' column at step 3 in the execution_table.

At which step does the output first become negative?

A Step 3

B Step 2

C Step 4

D Step 5

💡 Hint

Look at the 'output' column in execution_table to find when it goes below zero.

If the target_angle was increased, how would the error values change in the execution_table?

A Error values would decrease

B Error values would stay the same

C Error values would increase

D Error values would become negative

💡 Hint

Error = target_angle - current_angle, so increasing target_angle increases error.

Concept Snapshot

PID Controller in Flight Stabilization:
- Calculate error = target - current angle
- P = Kp * error (reacts to current error)
- I += Ki * error * dt (reacts to accumulated error)
- D = Kd * (error - last_error) / dt (reacts to error change rate)
- Output = P + I + D sent to motors
- Update last_error for next step
- Repeat continuously for stable flight

Full Transcript

This visual execution shows how a PID controller helps stabilize a drone's flight by adjusting motor outputs based on the difference between the target and current angles. Each step calculates the error, then computes proportional, integral, and derivative terms. These terms combine to form the output that controls the motors. The integral term accumulates over time, while the derivative term reacts to how quickly the error changes. The last_error variable updates each step to track error changes. The process repeats continuously to keep the drone balanced.

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