The interior-point-convex algorithm requires all objective and constraint values to be finite.

function sys=mdlOutputs(t,x,u)

global kesi U

n=2;

p=1;

Np=100;

Nc=80;

Row=1;

w=u(1);

wd=u(2);

beta=u(3);

betad=u(4);

detaf=u(5);

kesi=zeros(n+p,1);

kesi(1)=beta;

kesi(2)=w;

kesi(3)=U;

Yd=[betad;wd];

W=kron(ones(Nc,1),detaf);

m=1270+71*2;

a=1.015;

b=1.895;

L=2.91;

Iz=1536.7;

kf=112600;

kr=89500;

v=80/3.6;

Ts=0.01;

%定义状态空间矩阵A，n*n

Ac=[-(kf+kr)/m/v , (-a*kf+b*kr)/m/v/v-1;

(-a*kf+b*kr)/Iz , -(a^2*kf+b^2*kr)/Iz/v];

Bc=[kr/m/v ;

-b*kr/Iz];

Ec=[kf/m/v ;

a*kf/Iz];

Cc=[0 0];

Dc=[0 0];

sysc=ss(Ac,[Bc Ec],Cc,Dc);

sysd = c2d(sysc,Ts);

[A,Bd,~,~,~] = ssdata(sysd);

B=Bd(:,1);

E=Bd(:,2);

%1返回行数，2返回列数

n=size(A,1);

%定义状态空间矩阵B，n*p

p=size(B,2);

A_cell=cell(2,2);

A_cell{1,1}=A;

A_cell{1,2}=B;

A_cell{2,1}=zeros(p,n);

A_cell{2,2}=eye(p,p);

A1=cell2mat(A_cell);

B1=[B;1];

E1=[E;0];

C1=[eye(n,n),zeros(n,p)];

A2_cell=cell(Np,1);

for i=1:1:Np

A2_cell{i,1}=C1*A1^i;

end

A2=cell2mat(A2_cell);

B2_cell=cell(Np,Nc);

for i=1:1:Np

for j=1:1:Nc

if i>=j

B2_cell{i,j}=C1*A1^(i-j)*B1;

else

B2_cell{i,j}=zeros(n,p);

end

end

end

B2=cell2mat(B2_cell);

Yd_cell=cell(Np,1);

for i=1:1:Np

Yd_cell{i,1}=Yd;

end

Ydbar=cell2mat(Yd_cell);

E2_cell=cell(Np,Nc);

for i=1:1:Np

for j=1:1:Nc

if i>=j

E2_cell{i,j}=C1*A1^(i-j)*E1;

else

E2_cell{i,j}=zeros(n,p);

end

end

end

E2=cell2mat(E2_cell);

%定义Q矩阵n*n

Q=eye(Np*n);

%定义R矩阵p*p

R=eye(Nc*p);

H1=(R+B2'*Q*B2)*2;

f1=2*(kesi'*A2'*Q*B2+W'*E2'*Q*B2-Ydbar'*Q*B2);

H_cell=cell(2,2);

H_cell{1,1}=H1;

H_cell{1,2}=zeros(Nc*p,1);

H_cell{2,1}=zeros(1,Nc*p);

H_cell{2,2}=Row;

H=cell2mat(H_cell);

f_cell=cell(1,2);

f_cell{1,1}=f1;

f_cell{1,2}=0;

f=cell2mat(f_cell);

F=f';

A_t=zeros(Nc,Nc);

for i=1:1:Nc

for j=1:1:Nc

if i>=j

A_t(i,j)=1;

else

A_t(i,j)=0;

end

end

end

A_I=kron(A_t,eye(p));

Ut=kron(ones(Nc,1),U);

umax=5*pi/180;

umin=-5*pi/180;

umax_dt=0.0025;

umin_dt=-0.0025;

Umax=kron(ones(Nc,1),umax);

Umin=kron(ones(Nc,1),umin);

Umax_dt=kron(ones(Nc,1),umax_dt);

Umin_dt=kron(ones(Nc,1),umin_dt);

A_cons_cell=cell(2,2);

A_cons_cell{1,1}=A_I;

A_cons_cell{1,2}=zeros(p*Nc,1);

A_cons_cell{2,1}=-A_I;

A_cons_cell{2,2}=zeros(p*Nc,1);

A_cons=cell2mat(A_cons_cell);

B_cons_cell=cell(2,1);

B_cons_cell{1,1}=Umax-Ut;

B_cons_cell{2,1}=-Umin+Ut;

B_cons=cell2mat(B_cons_cell);

lb=[Umin_dt;0];

ub=[Umax_dt;10];

options=optimset('Algorithm','interior-point-convex');

[X,fval,exitflag] =quadprog(H,F,A_cons,B_cons,[],[],lb,ub,[],options);