A Model Predictive Control Design Tool with Python - Full code explanation

Introduction

Happy New Year everyone, it's Vinayak here. In this tutorial, you will learn how to design a Model Predictive Controller (MPC) in Python and even test it. Using a quadratic optimization tool, you can validate that the controller works, enabling you to use it in your projects and assignments. Let's get started.

Introduction

Every software project has something called a class diagram that puts together all your classes in one diagram so you can understand how they interact with each other. Let's outline the system and the necessary classes used for designing an MPC.

System Class

• Attributes:

  • nmpr: Dimensions (number of states, inputs, outputs, and set points)
  • Matrices: A, B, C, Ac, Bc, H
  • u, rset, e, zpr: Inputs, set points, error, and predicted outputs
  • dt, x, y, z: Discrete time parameters, states, outputs, set points
  • qr: Weighting matrices for the MPC controller
  • input_limits: Dictionary with actuator input limits
  • num_abs, num_inc: Absolute constraints and incremental constraints

• Methods:

  • update_dimensions
  • update_continuous_state_model
  • update_initial_conditions
  • discretize
  • step_sim
  • update_mpc_parameters
  • update_constraints

MPC Design Class

• Attributes:
  • np: Prediction horizon
  • H_inv, K: Feedback gain and multiplier
  • M, G: Constraint model matrices
  • F, G (internal MPC matrices)
  • EMPC: Efficient MPC method (inherits from MPC Design)

Quadratic Programming Class

This class involves the composition of the MPC design, integrating the quadratic optimization parameters.

• Attributes:
  • W, Z: Number of iterations, Error, and Lagrange multiplier
  • Choices between:
    • HQP: Hildretz Quadratic Programming method
    • PQP: Parallel Quadratic Programming

Functions

find_stability

Takes in feedback gain and MPC matrix (a-BKF) to compute and plot eigenvalues for open-loop and closed-loop systems.

check_constraints

Checks to ensure that constraints (Mu < G) are satisfied and activates the quadratic optimizer if the constraints are not met.

Implementing the System Class

Import relevant libraries such as NumPy and the control systems toolbox, initialize attributes, set up methods to update dimensions, continuous state model, and discretization:

import numpy as np
import control as ct
from scipy.linalg import eigvals, inv

class System:
    def __init__(self):
        self._initial_defaults()
        self._update_dimensions()
        self._update_continuous_state_model()
        self._update_initial_conditions()
        self._discretize_dt()
        self._step_sim()
        self._update_mpc_parameters()
        self._update_constraints()
   
    # Initialization and methods as described in the script

Designing the MPC

Initialize necessary matrices, compute internal model parameters like eigenvalues, constraints, and feedback gains:

import numpy as np

class MPCDesign:
    def __init__(self):
        self.F = np.zeros((N, M))
        self.G = np.zeros((N, M))
        self.H = np.zeros((M, M))
        self.K = np.zeros((M, N))
        self.M_con = np.zeros((constraints, inputs))
        self.G_con = np.zeros(constraints)

    def initialize_internal_model(self, system, constraints):
        # Eigenvalue decomposition and inversion process
        pass

## Introduction
class EfficientMPC(MPCDesign):
    pass

## Introduction

Implementing the Quadratic Programming

Choose either Hildretz Quadratic Programming (HQP) or Parallel Quadratic Programming (PQP):

import numpy as np

class QuadraticProgramming:
    def __init__(self, mpc_design):
        self.w, self.z = 0, 0
        self.e = 1e-6  # tolerance

    def hqp_algorithm(self, constraints, H_inv, f):
        while not self._has_converged():
            self._update_lagrange()
            self._calculate_error()

Running an Example

Define your example system and input parameters:

1. Initialize the system and define matrices.
2. Update initial conditions, constraints, and discretization.
3. Select and run the optimization method, iterate and print results.

## Introduction

s = System()
s.update_dimensions(5, 2, 5, 2)
s.update_continuous_state_model(A, B, C, H, X0)
s.update_initial_conditions(U0, rset)
s.discretize(0.05)
s.update_mpc_parameters(Q, R)
s.update_constraints(u_max, u_min, u_incremental, num_inputs)

## Introduction
empc = EfficientMPC()
empc.initialize_internal_model(system=s)
empc.set_constraints(s)
empc.set_optimizer(hqp_algorithm)
results = empc.run_iterations(10)

Outputs and Analysis

Print out the unconstrained and constrained inputs, plot the error against iterations to analyze convergence:

empc.print_iterations(results)
results.plot_errors()

Keywords

• Model Predictive Control (MPC)
• Quadratic Optimization
• Python
• Constraint Checking
• System Dynamics
• State Space Model
• Eigenvalues
• Feedback Gain
• Discretization
• Optimization Algorithms (HQP, PQP)

FAQ

Q1: What is the role of the class System in this implementation? A1: The System class initializes and updates the system states, inputs, outputs, and other parameters required for state-space modeling in both continuous and discrete domains.

Q2: What are the primary differences between HQP and PQP optimization methods? A2: HQP is faster and converges quickly but is slightly more complex, while PQP involves simpler operations and is easier to understand but might take more iterations to converge.

Q3: Can the MPC tool designed be used for any system? A3: Yes, by defining the system matrices and parameters appropriately, you can utilize the MPC tool for any linear time-invariant system.

Q4: What is the importance of the find_stability function? A4: It evaluates system stability by checking the eigenvalues of the state matrix, crucial for analyzing open-loop and closed-loop system behavior.

Q5: How does the tool handle constraints on input parameters? A5: The tool checks constraints each iteration and adjusts inputs using the specified optimization method to ensure all constraints are met.

This article details the creation of an MPC tool in Python, providing a comprehensive explanation of the classes, methods, and optimization techniques involved. The example implementation helps to understand the practical aspects of using the tool, including system design, constraints handling, and optimization within a model predictive control framework.