【Practical Exercise】Designing a Basic PID Controller with MATLAB

# 1. Fundamental Principles of PID Controllers

A PID controller is a classical feedback control algorithm widely used in industrial process control, robotic control, and other fields. Its fundamental principles are as follows:

***Proportional Control (P):** Controls based on the current value of the error, with greater control output as the error increases.
***Integral Control (I):** Controls based on the accumulated value of errors, with greater control output the longer the error persists.
***Differential Control (D):** Controls based on the rate of change of the error, with greater control output as the rate of error change increases.

By combining these three control methods, the PID controller can achieve precise control of a system.

# 2. Implementing a PID Controller in MATLAB

### 2.1 Algorithm Implementation of the PID Controller

The PID controller algorithm consists of three components: proportional control, integral control, and differential control.

#### 2.1.1 Proportional Control

Proportional control is the simplest form of control, with the output being proportional to the input error. The implementation code for proportional control in MATLAB is as follows:

function u = P(e, Kp)
     % Proportional control algorithm
     %
     % Inputs:
     %    e: Error
     %    Kp: Proportional gain
     %
     % Outputs:
     %    u: Control output

     u = Kp * e;
end

**Code Logic Analysis:**

This function takes error `e` and proportional gain `Kp` as inputs and calculates the control output `u`. The control output is proportional to the error, with the proportional gain `Kp` controlling the proportional coefficient.

**Parameter Description:**

- `e`: Error, representing the difference between the system's desired output and actual output.
- `Kp`: Proportional gain, used to adjust the proportional relationship between control output and error.

#### 2.1.2 Integral Control

Integral control can eliminate steady-state errors, with the output being proportional to the integral of the error. The implementation code for integral control in MATLAB is as follows:

function u = I(e, Ki, dt)
     % Integral control algorithm
     %
     % Inputs:
     %    e: Error
     %    Ki: Integral gain
     %    dt: Sampling time
     %
     % Outputs:
     %    u: Control output

     persistent integral_error;
     if isempty(integral_error)
         integral_error = 0;
     end

     integral_error = integral_error + e * dt;
     u = Ki * integral_error;
end

**Code Logic Analysis:**

This function takes error `e`, integral gain `Ki`, and sampling time `dt` as inputs and calculates the control output `u`. The control output is proportional to the integral of the error, with the integral gain `Ki` controlling the integral coefficient. The function uses a `persistent` variable `integral_error` to store the integral of the error, thus implementing the integral operation.

**Parameter Description:**

- `e`: Error, representing the difference between the system's desired output and actual output.
- `Ki`: Integral gain, used to adjust the proportional relationship between control output and the integral of the error.
- `dt`: Sampling time, indicating the interval at which the control algorithm is executed.

#### 2.1.3 Differential Control

Differential control can increase the system's response speed, with the output being proportional to the rate of change of the error. The implementation code for differential control in MATLAB is as follows:

function u = D(e, Kd, dt)
     % Differential control algorithm
     %
     % Inputs:
     %    e: Error
     %    Kd: Differential gain
     %    dt: Sampling time
     %
     % Outputs:
     %    u: Control output

     persistent derivative_error;
     if isempty(derivative_error)
         derivative_error = 0;
     end

     derivative_error = (e - derivative_error) / dt;
     u = Kd * derivative_error;
end

**Code Logic Analysis:**

This function takes error `e`, differential gain `Kd`, and sampling time `dt` as inputs and calculates the control output `u`. The control output is proportional to the rate of change of the error, with the differential gain `Kd` controlling the differential coefficient. The function uses a `persistent` variable `derivative_error` to store the previous error, thus implementing the differential operation.

**Parameter Description:**

- `e`: Error, representing the difference between the system's desired output and actual output.
- `Kd`: Differential gain, used to adjust the proportional relationship between control output and the rate of change of error.
- `dt`: Sampling time, indicating the interval at which the control algorithm is executed.

# 3.1 Establishing a System Model

In the simulation of a PID controller, it is necessary to establish a system model to represent the controlled obj