DataDrivenMPC
Description
A data-driven model predictive controller uses on a nonparametric model that relies on input/output time-domain data to directly (that is without explicit system identification) solve an MPC problem in real-time. To synthesize a data-driven MPC controller you use using data collected from an open loop experiment on the plant at a nominal operating point, using a persistently exciting input. All inputs are manipulated variables and all the outputs are measured.
Creation
Description
Input Arguments
Properties
Object Functions
Examples
In this example you create a DataDrivenMPC object, validate its internal model, and then simulate the controller in closed loop.
Create a plant model and collect input and output data
To collect input and output data, first define random, strictly causal, continuous-time plant with two outputs, three inputs, and four states. For more information on creating random systems, see rss.
nx = 4; ny = 2; nu = 3; sys = rss(nx,ny,nu); sys.D = 0;
Note that for data-driven MPC design, all inputs must be manipulated variables.
Define an initial state.
x0 = zeros(4,1);
Define a sampling time of 0.1 seconds and define a column time vector of 100 samples starting from t = 1 second.
Ts = 0.1; N = 100; t = (1:N)'*Ts;
Create a random input signal. Inputs with a random component are typically persistently exciting.
dataU = (0.5-rand(length(t),nu))*2;
To collect output data, simulate the plant model using the lsim function. Supply as argument the plant model, the input data, the time vector, and the initial state created in the previous steps.
dataY = lsim(sys,dataU,t,x0);
If you have already have plant input and output data collected from experiments, then this step not necessary, as you can directly use your existing data to design your data-driven MPC controller.
Create a data-driven MPC controller
Create a DataDrivenMPC object using the input and output data as well as the sample time.
ddobj = DataDrivenMPC(dataU,dataY,Ts)
ddobj =
DataDrivenMPC with properties:
Ts: 0.1000
FutureSteps: 1
PastSteps: 1
PlantOrder: 1
Dimensions: [1×1 struct]
PersistentExcitation: [1×1 struct]
ManipulatedVariables: [1×1 mpc.internal.ddmpc.ManipulatedVariables]
OutputVariables: [1×1 mpc.internal.ddmpc.OutputVariables]
Weights: [1×1 mpc.internal.ddmpc.Weights]
Optimization: [1×1 mpc.internal.ddmpc.Optimization]
Set the number of steps used for prediction, FutureSteps, the number of steps used for estimation, PastSteps, and the plant order. The software uses the plant order to check whether the input data is sufficiently long and persistently exciting.
ddobj.FutureSteps = 21; ddobj.PastSteps = 4; ddobj.PlantOrder = nx;
Check the PersistentExcitation property to make sure the last two properties are true. If not, you might need to provide more data (assuming the number of prediction and estimation steps does not change) or redesign the excitation signal.
ddobj.PersistentExcitation
ans = struct with fields:
NumberOfSamples: 100
MinimumNumberOfSamples: 115
HankelDepth: 25
MaximumHankelDepth: 21
IsDataSufficient: 0
IsPersistentlyExciting: 0
HankelConditionNumber: 12.5931
Define bounds for the manipulated variables and their rate.
ddobj.ManipulatedVariables.Min = -5*ones(1,nu); ddobj.ManipulatedVariables.Max = 5*ones(1,nu); ddobj.ManipulatedVariables.RateMin = -0.5*ones(1,nu); ddobj.ManipulatedVariables.RateMax = 0.5*ones(1,nu);
Validate prediction model
Create a time vector for validation.
L = ddobj.PastSteps + ddobj.FutureSteps; t_val = (1:L)'*Ts;
Create a random input signal for validation.
dataU_val = (0.5-rand(L,nu))*2;
To collect output data for validation, simulate the plant model you created in the first step, using the validation input data, time vector and initial state as additional input arguments.
dataY_val = lsim(sys,dataU_val,t_val,x0);
Use the checkPrediction function to check whether the internal model in ddobj can predict the validation output data.
checkPrediction(ddobj,dataU_val,dataY_val);
The predicted output acceptably matches the validation output (dataY_val).
Simulate the controller in closed loop
Use a step as a reference signal for all outputs.
ref = ones(1,ny);
Perform a closed loop simulation using the internal prediction model. For more information, see sim.
sim(ddobj,N/2,ref);
The controller is able to track the reference.
Calculate optimal input move
Create a step reference signal for all outputs over ddobj.FutureSteps steps.
yref = repmat(ref,ddobj.FutureSteps,1);
Create a state object.
stateobj = DataDrivenMPCState(ddobj);
To calculate the optimal input move use mpcmove. Supply as input arguments the DataDrivenMPC object, the state object, the measured plant inputs and outputs at the previous control interval and the reference signal.
mv = mpcmove(ddobj,stateobj,zeros(nu,1),zeros(ny,1),yref)
mv = 3×1
-0.5000
0.5000
0.5000
You can simulate the controller in closed loop against a linear or nonlinear plant using mpcmove in a for loop.
Version History
Introduced in R2026a
