mpcmove

Optimal control action

Syntax

u = mpcmove(MPCobj,x,ym,r,v)
[u,Info] = mpcmove(MPCobj,x,ym,r,v)
[u,Info] = mpcmove(MPCobj,x,ym,r,v,Options)

Description

u = mpcmove(MPCobj,x,ym,r,v) computes the optimal manipulated variable moves, u(k), at the current time. u(k) is calculated given the current estimated extended state, x(k), the measured plant outputs, ym(k), the output references, r(k), and the measured disturbances, v(k), at the current time k. Call mpcmove repeatedly to simulate closed-loop model predictive control.

[u,Info] = mpcmove(MPCobj,x,ym,r,v) returns additional information regarding the model predictive controller in the second output argument Info.

[u,Info] = mpcmove(MPCobj,x,ym,r,v,Options) overrides default constraints and weights settings in MPCobj with the values specified by Options, an mpcmoveopt object. Use Options to provide run-time adjustment in constraints and weights during the closed-loop simulation.

Input Arguments

MPCobj

mpc object that defines the model predictive controller.

x

mpcstate object that defines the current controller state.

Before you begin a simulation with mpcmove, initialize the controller state using x = mpcstate(MPCobj). Then, modify the default properties of x as appropriate.

If you are using default state estimation, mpcmove expects x to represent x[n|n-1]. The mpcmove command updates the state values in the previous control interval with that information. Therefore, you should not programmatically update x at all. The default state estimator employs a steady-state Kalman filter.

If you are using custom state estimation, mpcmove expects x to represent x[n|n]. Therefore, prior to each mpcmove command, you must set x.Plant, x.Disturbance, and x.Noise to the best estimates of these states (using the latest measurements) at the current control interval.

ym

1-by-nym vector of current measured output values at time k, where nym is the number of measured outputs.

If you are using custom state estimation, set ym = [].

r

Plant output reference values, specified as a p-by-ny array, where p is the prediction horizon of MPCobj and ny is the number of outputs. Row r(i,:) defines the reference values at step i of the prediction horizon.

r must contain at least one row. If r contains fewer than p rows, mpcmove duplicates the last row to fill the p-by-ny array. If you supply exactly one row, therefore, a constant reference applies for the entire prediction horizon.

To implement reference previewing, which can improve tracking when a reference varies in a predictable manner, r must contain the anticipated variations, ideally for p steps.

v

Current and anticipated measured disturbances, specified as a p-by-nmd array, where p is the prediction horizon of MPCobj and nmd is the number of measured disturbances. Row v(i,:) defines the expected measured disturbance values at step i of the prediction horizon.

Modeling of measured disturbances provides feedforward control action. If your plant model does not include measured disturbances, use v = [].

v must contain at least one row. If v contains fewer than p rows, mpcmove duplicates the last row to fill the p-by-nmd array. If you supply exactly one row, therefore, a constant measured disturbance applies for the entire prediction horizon.

To implement disturbance previewing, which can improve tracking when a disturbance varies in a predictable manner, v must contain the anticipated variations, ideally for p steps.

Options

Override values for selected properties of MPCobj, specified as an options object you create with mpcmoveopt. These options apply to the current mpcmove time instant only. Using Options yields the same result as redefining or modifying MPCobj before each call to mpcmove, but involves considerably less overhead. Using Options is equivalent to using an MPC Controller Simulink® block in combination with optional input signals that modify controller settings, such as MV and OV constraints.

Output Arguments

expand all

u

1-by-nu array of optimal manipulated variable moves, where nu is the number of manipulated variables.

mpcmove holds u at its most recent successful solution if the QP solver fails to find a solution for the current time k.

Info

Information regarding the model predictive controller, returned as a structure containing the following fields.

Uopt

Optimal manipulated variable adjustments (moves), returned as a p+1-by-nu array, where p is the prediction horizon of MPCobj and nu is the number of manipulated variables.

The first row of Info.Uopt is identical to the output argument u, which is the adjustment applied at the current time, k. Uopt(i,:) contains the predicted optimal values at time k+i-1, for i = 1,...,p+1. The mpcmove command does not calculate optimal control moves at time k+p, and therefore sets Uopt(p+1,:) to NaN.

Yopt

Predicted output variable sequence, returned as a p+1-by-ny array, where p is the prediction horizon of MPCobj and nx is the number of outputs.

The first row of Info.Yopt contains the current outputs at time k after state estimation. Yopt(i,:) contains the predicted output values at time k+i-1, for i = 1,...,p+1.

Xopt

Predicted state variable sequence, returned as a p+1-by-nx array, where p is the prediction horizon of MPCobj and nx is the number of states.

The first row of Info.Xopt contains the current states at time k as determined by state estimation. Xopt(i,:) contains the predicted state values at time k+i-1, for i = 1,...,p+1.

Topt

Time intervals, returned as a p+1-by-a vector. Topt(1) = 0, representing the current time. Subsequent time steps Topt(i) are given by Ts*(i-1), where Ts = MPCobj.Ts, the controller sampling time.

Use Topt when plotting Uopt, Xopt, or Yopt sequences.

Slack

Slack variable, ε, used in constraint softening, returned as 0 or a positive scalar value.

  • ε = 0 — All constraints were satisfied for the entire prediction horizon.

  • ε > 0 — At least one soft constraint is violated. When more than one constraint is violated, ε represents the worst-case soft constraint violation (scaled by your ECR values for each constraint).

See Optimization Problem for more information.

Iterations — QP solution result

QP solution result, returned as a positive integer or one of several values with specific meanings as follows.

  • Iterations > 0 — Number of iterations needed to solve the quadratic programming (QP) problem that determines the optimal sequences.

  • Iterations = 0 — QP problem could not be solved in the allowed maximum number of iterations.

  • Iterations = –1 — QP problem was infeasible. A QP problem is infeasible if no solution can satisfy all the hard constraints.

  • Iterations = –2 — Numerical error occurred when solving the QP problem.

QPCode

QP solution status, returned as one of the following strings:

  • 'feasible' — Optimal solution was obtained (Iterations > 0)

  • 'infeasible' — QP solver detected a problem with no feasible solution (Iterations = –1) or a numerical error occurred (Iterations = –2)

  • 'unreliable' — QP solver failed to converge (Iterations = 0)

Cost — Objective function costnon-negative scalar

Objective function cost, returned as a non-negative scalar value. The cost quantifies the degree to which the controller has achieved its objectives. See Optimization Problem for details.

The cost value is only meaningful when QPCode = 'feasible'.

Examples

expand all

Analyze Closed-Loop Response

Perform closed-loop simulation of a plant with one MV and one measured OV.

Define a plant model and create a model predictive controller with MV constraints.

ts = 2;
Plant = ss(0.8,0.5,0.25,0,ts);
MPCobj = mpc(Plant);
MPCobj.MV(1).Min = -2;
MPCobj.MV(1).Max = 2;
-->The "PredictionHorizon" property of "mpc" object is empty. Trying PredictionHorizon = 10.
-->The "ControlHorizon" property of the "mpc" object is empty. Assuming 2.
-->The "Weights.ManipulatedVariables" property of "mpc" object is empty. Assuming default 0.00000.
-->The "Weights.ManipulatedVariablesRate" property of "mpc" object is empty. Assuming default 0.10000.
-->The "Weights.OutputVariables" property of "mpc" object is empty. Assuming default 1.00000.

Initialize an mpcstate object for simulation. Use the default state properties.

x = mpcstate(MPCobj);
-->Integrated white noise added on measured output channel #1.
-->The "Model.Noise" property of the "mpc" object is empty. Assuming white noise on each measured output channel.

Set the reference signal. There is no measured disturbance.

r = 1;

Simulate the closed-loop response by calling mpcmove iteratively.

t = [0:ts:40];
N = length(t);
y = zeros(N,1);
u = zeros(N,1);
for i = 1:N
		% simulated plant and predictive model are identical
		y(i) = 0.25*x.Plant;
		u(i) = mpcmove(MPCobj,x,y(i),r);
end

y and u store the OV and MV values.

Analyze the result.

[ts,us] = stairs(t,u);
plot(ts,us,'r-',t,y,'b--');
legend('MV','OV');

Modify the MV upper bound as the simulation proceeds using an mpcmoveopt object.

MPCopt = mpcmoveopt;
MPCopt.MVMin = -2;
MPCopt.MVMax = 2;

Simulate the closed-loop response and introduce the real-time upper limit change at eight seconds (the fifth iteration step).

x = mpcstate(MPCobj);
y = zeros(N,1);
u = zeros(N,1);
for i=1:N
		% simulated plant and predictive model are identical
		y(i) = 0.25*x.Plant;
		if i == 5
			MPCopt.MVMax = 1;
		end
		u(i) = mpcmove(MPCobj,x,y(i),r,[],MPCopt);
end

Analyze the result.

[ts,us] = stairs(t,u);
plot(ts,us,'r-',t,y,'b--');
legend('MV','OV');

Evaluate Scenario at Specific Time Instant

Define a plant model.

ts = 2;
Plant = ss(0.8,0.5,0.25,0,ts);

Create a model predictive controller with MV and MVRate constraints. The prediction horizon is ten intervals. The control horizon is blocked.

MPCobj = mpc(Plant, ts, 10, [2 3 5]);
MPCobj.MV(1).Min = -2;
MPCobj.MV(1).Max = 2;
MPCobj.MV(1).RateMin = -1;
MPCobj.MV(1).RateMax = 1;
-->The "Weights.ManipulatedVariables" property of "mpc" object is empty. Assuming default 0.00000.
-->The "Weights.ManipulatedVariablesRate" property of "mpc" object is empty. Assuming default 0.10000.
-->The "Weights.OutputVariables" property of "mpc" object is empty. Assuming default 1.00000.

Initialize an mpcstate object for simulation from a particular state.

x = mpcstate(MPCobj);
x.Plant = 2.8;
x.LastMove = 0.85;
-->Integrated white noise added on measured output channel #1.
-->The "Model.Noise" property of the "mpc" object is empty. Assuming white noise on each measured output channel.

Compute the optimal control at current time.

y = 0.25*x.Plant;
r = 1;
[u,Info] = mpcmove(MPCobj,x,y,r);

Analyze the predicted optimal sequences.

[ts,us] = stairs(Info.Topt,Info.Uopt);
plot(ts,us,'r-',Info.Topt,Info.Yopt,'b--');
legend('MV','OV');

plot ignores Info.Uopt(end) as it is NaN.

Examine the optimal cost.

Info.Cost
ans =

    0.0793

Alternatives

  • Use sim for plant mismatch and noise simulation when not using run-time constraints or weight changes.

  • Use mpctool to graphically and interactively combine model predictive design and simulation.

  • Use the MPC Controller block in Simulink and for code generation.

More About

expand all

Tips

  • mpcmove updates x.

  • If ym, r or v is specified as [], mpcmove uses the appropriate MPCobj.Model.Nominal value instead.

  • To view the predicted optimal behavior for the entire prediction horizon, plot the appropriate sequences provided in Info.

  • To determine the optimization status, check Info.Iterations and Info.QPCode.

Was this topic helpful?