jMPC Toolbox

jMPC Reference: Examples/Documentation Examples/Heli_Example.m

Problem Reference: Åkesson, J., MPCtools 1.0 - Reference Manual, Lund Institute of Technology, 2006

Linear System Model

The continuous time state space equation of the helicopter is as follows:

where we have defined the state vector, x, as:

and the output vector, y, as:

and input, u, as:

Control Objectives

The control objective is to control the Elevation & Rotation angles (y₁, y₂) to their respective setpoints, by adjusting Motor 1 and 2 Voltages (u₁, u₂). The Pitch Angle (y₃) is constrained but not controlled to a setpoint.

System Constraints

Both Motor Voltages are constrained as:

⚠ $-3\text{V} \le u_{[1-2]} \le 3\text{V}$

Each axis rotation angle is constrained as follows (in radians):

⚠ $-0.6 \le y_1 \le 0.6$

⚠ $-\text{pi} \le y_2 \le \text{pi}$

⚠ $-1 \le y_3 \le 1$

Linear MPC Simulation

Step 1 - Create the Plant

The first step is to implement the model equations above into MATLAB as a jSS object to create the System Plant. For this example we will ignore the linearization biases on the system, however for similar examples with biases see Examples/linear_examples.m. The parameters are first defined, then the model A, B, C & D matrices are created and passed to the jSS constructor:

Step 2 - Discretize the Plant

Object Plant is now a continuous time state space model, but in order to use it with the jMPC Toolbox, it must be first discretized. A suitable sampling time should be chosen based on the plant dynamics, in this case use 0.12 seconds:

Step 3 - Create Controller Model

Now we have a plant to use for simulation, we also need a controller model for the internal calculation of the controller. The plant does not have to be the same as the controller model, and in real life will not be. However for ease of this simulation, we will define the plant & model to be the same:

Step 4 - Setup MPC Specifications

Following the specifications from this example's reference, enter the following MPC specifications:

Step 5 - Setup Simulation Options

Next we must setup the simulation environment for our controller:

Step 6 - MPC Options

For advanced settings of the MPC controller or simulation you can use the jMPCset function to create the required options structure. For this example we just wish to set the plot titles and axis:

Step 7 - Build the MPC Controller & Simulation Options

Now we have specified all we need to build an MPC controller and Simulation environment, we call the two required constructor functions:

MPC1 is created using the jMPC constructor, where the variables we have declared previously are passed as initialization parameters. simopts is created similarly, except using the jSIM constructor. Both constructors contain appropriate error checking thus the user will be informed of any mistakes when creating either object.

Step 8 - Run the MPC Simulation & Plot Results

With the controller and environment built, we can run the simulation, and plot the results:

The plot produced is shown below:

We can also plot a detail plot (using the 'detail' switch) to better view the output responses with respect to the constraints:

Viewable above is the controlled response with both the elevation angle and rotation angle appearing controlled, with minimal overshoot and fast rise and fall times. Note the pitch angle is constrained as required at ± 1 rad when moving the helicopter around the rotation axis, as was specified.

Linear MPC with Nonlinear Simulation

In order to more accurately verify the controller tuning, we can also create the nonlinear model of the plant, using the non linear differential equations of the helicopter system:

Step 1 - Build Nonlinear ODE Callback Function

As detailed in creating a jNL object, the first step is to write an m-file which contains the above expressions, suitable for use with a MATLAB integrator:

The file, nl_heliUser.m, is saved in a suitable folder on the MATLAB path.

Step 2 - Build the jNL Object

The next step is to build the jNL object, passing the function above as a function handle:

Note we have passed the parameters as a cell array, and also retained the linear C output matrix for now. This could also be a function handle to a nonlinear output function.

Step 3 - Linearize the jNL Object

In order to use the nonlinear plant with our linear MPC controller, we must linearize the ODE function and generate the required linear state space model:

In this instance we have chosen the linearize the ODE expression above about the motor voltages of 0.5V. We have not specified a state to linearize about (only an input), such that function will also automatically determine a steady state to linearize about.

Step 4 - Rebuild jSS Object

The model returned from the linearize function is a MATLAB lti object, and can be automatically converted to a jSS object, and then converted to a discrete model:

Step 5 - Rebuild & Re-Simulate the MPC Controller

The last step is to rebuild the MPC controller & simulation environment, and then re run the simulation:

The output result is shown below:

As viewable in the plot above, the controlled response of the nonlinear system is quite similar to the linear system, however viewing the plots side by side shows the differences (specifically the nonlinearities):

From the nonlinear plot, it is now evident there is significantly more overshoot on the rotation setpoint. This is attributed to the nonlinear equation governing the relationship between the rotation angle, and the pitch angle (sine), which cannot be fully defined a single linearization point. However the control is still reasonable, and would expect to function sufficiently well on a real plant. Note also that further tuning may improve this response, which is left to the reader to implement.