Integral Control for Disturbance Rejection

1. The Integral Controller for Disturbance Rejection

Recall the integral control structure we designed for reference tracking. The core idea was to integrate the error signal, e = r - y, and feed this integral back into the control input. This forces the controller to work until the error is driven to zero. It turns out this mechanism is exactly what we need to combat constant disturbances.

The block diagram below illustrates this architecture.

Let's quickly re-establish the augmented system for this controller. We introduce a new state, z, which is the integral of the error:

Since y = Cx, we have ż = r - Cx.

Our original plant is now affected by a disturbance d:

The control law uses feedback from both the original states x and the new integral state z:

Combining these gives us the complete dynamics of the closed-loop system in the presence of a disturbance.

2. Why Integral Control Works: A Steady-State Analysis

To understand why this controller rejects disturbances, let's analyze its behavior in steady-state. In steady-state, all derivatives are zero (ẋ = 0 and ż = 0).

From ż_ss = 0, we immediately get:

This is a powerful result. It states that at steady-state, the output must equal the reference. The presence of the constant disturbance d does not appear in this equation at all! The integrator has forced the steady-state error to zero, regardless of the disturbance.

So, what happened to the disturbance? The control input u has adjusted to cancel it out. Let's look at the steady-state equation for ẋ:

Solving for u_ss:

(Assuming B is invertible for simplicity of illustration; the principle holds more generally).

The steady-state control input u_ss is composed of two parts: one part (-B⁻¹(Ax_ss)) holds the system at the desired state, and the other part (-d) actively cancels the disturbance. The integral state z automatically grows or shrinks until the control input u provides exactly the right amount of effort to achieve this cancellation.

This concept is also discussed in the "State feedback and Observer Feedback" document from our last lesson.

3. Designing the Integral-Augmented Controller

The design process is identical to the one we used for reference tracking. The goal is to find the gain matrix K_a = [K_p, K_i] that places the poles of the augmented system in desirable locations, ensuring stability and good performance.

The following video provides a step-by-step guide to this process using pole placement.

Let's summarize the design steps from the video:

1. Form the Augmented System:
   Given the original plant (A, B, C), we construct the augmented matrices A_aug and B_aug for a single-output system:

   $$A_{aug}=\left[\begin{array}{cc}A& 0\\ -C& 0\end{array}\right],B_{aug}=\left[\begin{array}{c}B\\ 0\end{array}\right]$$

   The augmented system has n+1 states, where n is the number of original states. For a MIMO system with p outputs, you would add p integrators, making A_aug an (n+p) x (n+p) matrix.

2. Check Controllability:
   Before proceeding, you must verify that the augmented pair (A_aug, B_aug) is controllable. If it's not, you cannot arbitrarily place the closed-loop poles. A lack of controllability here often points to structural issues in the system, such as a zero at the origin (s=0) in the plant's transfer function, which would cancel the integrator's pole.

3. Choose Desired Pole Locations:
   Select n+1 desired locations for the closed-loop poles (p_desired). These locations determine the performance of the closed-loop system (e.g., settling time, damping). A common strategy is to use a Butterworth pattern, as shown in the video.

4. Calculate the Gain Matrix:
   Use a pole placement function like acker (for single-input) or place (for multi-input) in MATLAB to find the gain K_a:
   Ka = acker(A_aug, B_aug, p_desired) or Ka = place(A_aug, B_aug, p_desired)

   The resulting gain K_a is partitioned into the proportional and integral gains:

   $$K_a=\left[\begin{array}{cc}{K}_p& K_i\end{array}\right]$$

4. Alternative Design using LQR

Pole placement requires you to choose specific pole locations, which can sometimes feel arbitrary. An alternative and more systematic approach is to use the Linear Quadratic Regulator (LQR) method on the augmented system. Here, you specify performance by tuning the weighting matrices Q and R rather than picking pole locations.

The following video demonstrates this exact process, including building a Simulink model to test the controller. This is highly relevant to your practical goals.

Application to Your Rotary Inverted Pendulum

These techniques are directly applicable to your project. The rotary inverted pendulum is susceptible to constant disturbances like friction in the main rotary joint and biases in the motor. An integral controller is essential for holding the pendulum perfectly upright or the arm at a precise angle.

The Edukit resource page you've seen before contains a tutorial and MATLAB code specifically for this.

Conclusion

Today we've armed our state-feedback controller with a powerful tool for robustness. By augmenting our system with an integrator on the error signal, we've created a controller that can automatically reject the effects of unknown constant disturbances.

Key Takeaways:

• Integral action forces the steady-state error (r-y) to zero.
• By forcing the error to zero, the controller implicitly computes and applies a control effort that cancels out any constant input disturbance.
• The design procedure involves creating an augmented system (A_aug, B_aug) where A_aug = [A, 0; -C, 0] and B_aug = [B; 0].
• The controller gain K_a = [K_p, K_i] can be found by applying standard methods like pole placement or LQR to this augmented system.

Preview of the Next Lesson:
We have now designed two major types of controllers: a simple state feedback regulator and an integral-augmented regulator. In the next lesson, we will put them to the test. We will simulate and compare the tracking and disturbance rejection performance of these different designs to see the benefits of integral action firsthand.