Backstepping Control with RBF

Abstract

This chapter introduces backstepping controller design with RBF neural network approximation. Several controller design examples for mechanical systems are given, including backstepping controller for inverted pendulum, backstepping controller for single-link flexible joint robot, and adaptive backstepping controller for single-link flexible joint robot.

Appendix

8.1.1 Programs for Sect. 8.2.3

Simulation programs:

Simulink program: chap8_1sim.mdl

S function for control law:chap8_1ctrl.m

function [sys,x0,str,ts] = spacemodel(t,x,u,flag)

switch flag,

case 0,

[sys,x0,str,ts]=mdlInitializeSizes;

case 3,

sys=mdlOutputs(t,x,u);

case {2,4,9}

sys=[];

otherwise

error(['Unhandled flag = ',num2str(flag)]);

end

function [sys,x0,str,ts]=mdlInitializeSizes

global M V x0 fai

sizes = simsizes;

sizes.NumDiscStates = 0;

sizes.NumOutputs = 1;

sizes.NumInputs = 3;

sizes.DirFeedthrough = 1;

sizes.NumSampleTimes = 1;

sys = simsizes(sizes);

x0=[];

str = [];

ts = [0 0];

function sys=mdlOutputs(t,x,u)

k1=35;

k2=15;

x1d=u(1);

dx1d=0.1*pi*cos(pi*t);

ddx1d=-0.1*pi^2*sin(pi*t);

x1=u(2);

x2=u(3);

g=9.8;mc=1.0;m=0.1;l=0.5;

S=l*(4/3-m*(cos(x1))^2/(mc+m));

fx=g*sin(x1)-m*l*x2^2*cos(x1)*sin(x1)/(mc+m);

fx=fx/S;

gx=cos(x1)/(mc+m);

gx=gx/S;

e1=x1-x1d;

de1=x2-dx1d;

x2d=dx1d-k1*e1;

dx2d=ddx1d-k1*de1;

e2=x2-x2d;

ut=(1/gx)*(-k2*e2+dx2d-e1-fx);

sys(1)=ut;

S function for plant:chap8_1plant.m

function [sys,x0,str,ts]=s_function(t,x,u,flag)

switch flag,

case 0,

[sys,x0,str,ts]=mdlInitializeSizes;

case 1,

sys=mdlDerivatives(t,x,u);

case 3,

sys=mdlOutputs(t,x,u);

case {2, 4, 9 }

sys = [];

otherwise

error(['Unhandled flag = ',num2str(flag)]);

end

function [sys,x0,str,ts]=mdlInitializeSizes

sizes = simsizes;

sizes.NumContStates = 2;

sizes.NumDiscStates = 0;

sizes.NumOutputs = 2;

sizes.NumInputs = 1;

sizes.DirFeedthrough = 0;

sizes.NumSampleTimes = 0;

sys=simsizes(sizes);

x0=[pi/60 0];

str=[];

ts=[];

function sys=mdlDerivatives(t,x,u)

g=9.8;mc=1.0;m=0.1;l=0.5;

S=l*(4/3-m*(cos(x(1)))^2/(mc+m));

fx=g*sin(x(1))-m*l*x(2)^2*cos(x(1))*sin(x(1))/(mc+m);

fx=fx/S;

gx=cos(x(1))/(mc+m);

gx=gx/S;

sys(1)=x(2);

sys(2)=fx+gx*u;

function sys=mdlOutputs(t,x,u)

sys(1)=x(1);

sys(2)=x(2);

Plot program: chap8_1plot.m

close all;

figure(1);

subplot(211);

plot(t,y(:,1),'r',t,y(:,3),'k:','linewidth',2);

xlabel('time(s)');ylabel('Position tracking');

legend('Ideal position','Position tracking');

subplot(212);

plot(t,y(:,2),'r',t,y(:,4),'k:','linewidth',2);

xlabel('time(s)');ylabel('Speed tracking');

legend('Ideal speed','Speed tracking');

figure(2);

plot(t,ut(:,1),'k','linewidth',2);

xlabel('time(s)');ylabel('Control input');

8.1.2 Programs for Sect. 8.3.4

Simulink program: chap8_2sim.mdl

S function for control law: chap8_2ctrl.m

function [sys,x0,str,ts] = MIMO_Tong_s(t,x,u,flag)

switch flag,

case 0,

[sys,x0,str,ts]=mdlInitializeSizes;

case 1,

sys=mdlDerivatives(t,x,u);

case 3,

sys=mdlOutputs(t,x,u);

case {2,4,9}

sys=[];

otherwise

error(['Unhandled flag = ',num2str(flag)]);

end

function [sys,x0,str,ts]=mdlInitializeSizes

global c b k1 k2 node

node=5;

sizes = simsizes;

sizes.NumContStates = 2*node;

sizes.NumDiscStates = 0;

sizes.NumOutputs = 3;

sizes.NumInputs = 5;

sizes.DirFeedthrough = 1;

sizes.NumSampleTimes = 0;

sys = simsizes(sizes);

x0 = [0.1*ones(2*node,1)]; %m(0)>ml

str = [];

ts = [];

c=0.5*[-1 -0.5 0 0.5 1;

-1 -0.5 0 0.5 1];

b=15;

k1=35;k2=35;

function sys=mdlDerivatives(t,x,u)

global c b k1 k2 node

x1d=u(1);

dx1d=0.1*cos(t);

ddx1d=-0.1*sin(t);

x1=u(2);x2=u(3); %Plant states

z=[x1,x2]';

for j=1:1:node

h(j)=exp(-norm(z-c(:,j))^2/(2*b^2));

end

e1=x1-x1d;

de1=x2-dx1d;

x2d=dx1d-k1*e1;

e2=x2-x2d;

dx2d=ddx1d-k1*de1;

Kexi=[e1 e2]';

n=0.1;

Gama1=500;Gama2=0.50;

Gama=[Gama1 0;

0 Gama2];

%dZ=Gama*h*Kexi'-n*Gama*norm(Kexi)*Z;

w_fp=[x(1:node)]'; %fp weight

w_gp=[x(node+1:node*2)]'; %gp weight

for i=1:1:node

sys(i)=Gama(1,1)*h(i)*Kexi(1)-n*Gama(1,1)*norm(Kexi)*w_fp(i); %f estimation

sys(i+node)=Gama(2,2)*h(i)*Kexi(2)-n*Gama(2,2)*norm(Kexi)*w_gp(i); %g estimation

end

function sys=mdlOutputs(t,x,u)

global c b k1 k2 node

x1d=u(1);

dx1d=0.1*cos(t);

ddx1d=-0.1*sin(t);

x1=u(2);x2=u(3);

z=[x1,x2]';

for j=1:1:node

h(j)=exp(-norm(z-c(:,j))^2/(2*b^2));

end

w_fp=[x(1:node)]'; %fp weight

w_gp=[x(node+1:node*2)]'; %gp weight

fp=w_fp*h';

gp=w_gp*h';

e1=x1-x1d;

de1=x2-dx1d;

x2d=dx1d-k1*e1;

e2=x2-x2d;

dx2d=ddx1d-k1*de1;

ut=1/(gp+0.01)*(-e1-fp+dx2d-k2*e2);

sys(1)=ut;

sys(2)=fp;

sys(3)=gp;

S function for plant: chap8_2plant.m

function [sys,x0,str,ts]=s_function(t,x,u,flag)

switch flag,

case 0,

[sys,x0,str,ts]=mdlInitializeSizes;

case 1,

sys=mdlDerivatives(t,x,u);

case 3,

sys=mdlOutputs(t,x,u);

case {2, 4, 9 }

sys = [];

otherwise

error(['Unhandled flag = ',num2str(flag)]);

end

function [sys,x0,str,ts]=mdlInitializeSizes

sizes = simsizes;

sizes.NumContStates = 2;

sizes.NumDiscStates = 0;

sizes.NumOutputs = 4;

sizes.NumInputs = 3;

sizes.DirFeedthrough = 0;

sizes.NumSampleTimes = 0;

sys=simsizes(sizes);

x0=[pi/60 0];

str=[];

ts=[];

function sys=mdlDerivatives(t,x,u)

g=9.8;mc=1.0;m=0.1;l=0.5;

S=l*(4/3-m*(cos(x(1)))^2/(mc+m));

fx=g*sin(x(1))-m*l*x(2)^2*cos(x(1))*sin(x(1))/(mc+m);

fx=fx/S;

gx=cos(x(1))/(mc+m);

gx=gx/S;

sys(1)=x(2);

sys(2)=fx+gx*u(1);

function sys=mdlOutputs(t,x,u)

g=9.8;mc=1.0;m=0.1;l=0.5;

S=l*(4/3-m*(cos(x(1)))^2/(mc+m));

fx=g*sin(x(1))-m*l*x(2)^2*cos(x(1))*sin(x(1))/(mc+m);

fx=fx/S;

gx=cos(x(1))/(mc+m);

gx=gx/S;

sys(1)=x(1);

sys(2)=x(2);

sys(3)=fx;

sys(4)=gx;

Plot program: chap8_2plot.m

close all;

figure(1);

subplot(211);

plot(t,y(:,1),'r',t,y(:,3),'k:','linewidth',2);

xlabel('time(s)');ylabel('Position tracking');

legend('Ideal position','Position tracking');

subplot(212);

plot(t,y(:,2),'r',t,y(:,4),'k:','linewidth',2);

xlabel('time(s)');ylabel('Speed tracking');

legend('Ideal speed','Speed tracking');

figure(2);

plot(t,ut(:,1),'r','linewidth',2);

xlabel('time(s)');ylabel('Control input');

figure(3);

subplot(211);

plot(t,p(:,3),'r',t,p(:,6),'k:','linewidth',2);

xlabel('time(s)');ylabel('fx and its estimated value');

legend('fx','estiamted fx');

subplot(212);

plot(t,p(:,4),'r',t,p(:,7),'k:','linewidth',2);

xlabel('time(s)');ylabel('gx and its estimated value');

legend('gx','estiamted gx');

8.1.3 Programs for Sect. 8.5.3.1

Programs:

Simulink program: chap8_3sim.mdl

S function for control law and adaptive law: chap8_3ctrl.m

function [sys,x0,str,ts] = MIMO_Tong_s(t,x,u,flag)

switch flag,

case 0,

[sys,x0,str,ts]=mdlInitializeSizes;

case 1,

sys=mdlDerivatives(t,x,u);

case 3,

sys=mdlOutputs(t,x,u);

case {2,4,9}

sys=[];

otherwise

error(['Unhandled flag = ',num2str(flag)]);

end

function [sys,x0,str,ts]=mdlInitializeSizes

global k1 k2 k3 k4

sizes = simsizes;

sizes.NumContStates = 1;

sizes.NumDiscStates = 0;

sizes.NumOutputs = 2;

sizes.NumInputs = 6;

sizes.DirFeedthrough = 1;

sizes.NumSampleTimes = 0;

sys = simsizes(sizes);

x0 = [10]; %Let m(0)>>ml

str = [];

ts = [];

k1=35;k2=35;k3=35;k4=35;

function sys=mdlDerivatives(t,x,u)

global k1 k2 k3 k4

x1d=u(1);

dx1d=cos(t);

ddx1d=-sin(t);

dddx1d=-cos(t);

ddddx1d=sin(t);

x1=u(2);x2=u(3);x3=u(4);x4=u(5); %Plant states

mp=x(1);

e1=x1-x1d;

x2d=dx1d-k1*e1;

e2=x2-x2d;

dx2d=ddx1d-k1*(x2-dx1d);

x3d=dx2d-k2*e2-e1;

dx3d1=dddx1d-k1*(x3-ddx1d)-k2*(x3-dx2d)+dx1d-x2;

e3=x3-x3d;

x4d=dx3d1-k3*e3-e2;

e4=x4-x4d;

dx4d1=ddddx1d-k1*(x4-dddx1d)-k2*(x4-dddx1d+k1*(x3-ddx1d))+ddx1d-x3-k3*(x4-dx3d1)-(x3-dx2d);

ut=(1/mp)*(dx4d1-k4*e4-e3);

eta=150;

ml=1;

if (e4*ut>0)

dm=(1/eta)*e4*ut;

end

if (e4*ut<=0)

if (mp>ml)

dm=(1/eta)*e4*ut;

else

dm=1/eta;

end

end

sys(1)=dm;

function sys=mdlOutputs(t,x,u)

global k1 k2 k3 k4

x1d=u(1);

dx1d=cos(t);

ddx1d=-sin(t);

dddx1d=-cos(t);

ddddx1d=sin(t);

x1=u(2);x2=u(3);x3=u(4);x4=u(5); %Plant states

mp=x(1);

e1=x1-x1d;

x2d=dx1d-k1*e1;

e2=x2-x2d;

dx2d=ddx1d-k1*(x2-dx1d);

x3d=dx2d-k2*e2-e1;

dx3d1=dddx1d-(k1)*(x3-ddx1d)-(k2)*(x3-dx2d)+dx1d-x2;

e3=x3-x3d;

x4d=dx3d1-k3*e3-e2;

e4=x4-x4d;

dx4d1=ddddx1d-(k1)*(x4-dddx1d)-(k2)*(x4-dddx1d+(k1)*(x3-ddx1d))-(k3)*(x4-dx3d1)-(x3-dx2d)+ddx1d-x3;

ut=(1/mp)*(dx4d1-k4*e4-e3);

sys(1)=ut;

sys(2)=mp;

S function for plant:chap8_3plant.m

function [sys,x0,str,ts]=MIMO_Tong_plant(t,x,u,flag)

switch flag,

case 0,

[sys,x0,str,ts]=mdlInitializeSizes;

case 1,

sys=mdlDerivatives(t,x,u);

case 3,

sys=mdlOutputs(t,x,u);

case {2, 4, 9 }

sys = [];

otherwise

error(['Unhandled flag = ',num2str(flag)]);

end

function [sys,x0,str,ts]=mdlInitializeSizes

sizes = simsizes;

sizes.NumContStates = 4;

sizes.NumDiscStates = 0;

sizes.NumOutputs = 5;

sizes.NumInputs = 1;

sizes.DirFeedthrough = 0;

sizes.NumSampleTimes = 0;

sys=simsizes(sizes);

x0=[0.5 0 0 0];

str=[];

ts=[];

function sys=mdlDerivatives(t,x,u)

m=3.0;

ut=u(1);

sys(1)=x(2);

sys(2)=x(3);

sys(3)=x(4);

sys(4)=m*ut;

function sys=mdlOutputs(t,x,u)

m=3.0;

sys(1)=x(1);

sys(2)=x(2);

sys(3)=x(3);

sys(4)=x(4);

sys(5)=m;

Plot program:chap8_3plot.m

close all;

figure(1);

subplot(211);

plot(t,y(:,1),'r',t,y(:,3),'k:','linewidth',2);

xlabel('time(s)');ylabel('Position tracking');

legend('Ideal position','Position tracking');

subplot(212);

plot(t,y(:,2),'r',t,y(:,4),'k:','linewidth',2);

xlabel('time(s)');ylabel('Speed tracking');

legend('Ideal speed','Speed tracking');

figure(2);

plot(t,ut(:,1),'r','linewidth',2);

xlabel('time(s)');ylabel('Control input');

figure(3);

plot(t,m(:,5),'r',t,m(:,6),'k:','linewidth',2);

xlabel('time(s)');ylabel('m and its estimated value');

legend('m','estiamted m');

8.1.4 Programs for Sect. 8.5.3.2

Simulink program: chap8_4sim.mdl

S function for control law and adaptive law: chap8_4ctrl.m

function [sys,x0,str,ts] = MIMO_Tong_s(t,x,u,flag)

switch flag,

case 0,

[sys,x0,str,ts]=mdlInitializeSizes;

case 1,

sys=mdlDerivatives(t,x,u);

case 3,

sys=mdlOutputs(t,x,u);

case {2,4,9}

sys=[];

otherwise

error(['Unhandled flag = ',num2str(flag)]);

end

function [sys,x0,str,ts]=mdlInitializeSizes

global c b k1 k2 k3 k4 node

node=5;

sizes = simsizes;

sizes.NumContStates = 3*node+1;

sizes.NumDiscStates = 0;

sizes.NumOutputs = 3;

sizes.NumInputs = 7;

sizes.DirFeedthrough = 1;

sizes.NumSampleTimes = 0;

sys = simsizes(sizes);

x0 = [zeros(3*node,1);500]; %m(0)>ml

str = [];

ts = [];

c=[-1 -0.5 0 0.5 1;

-1 -0.5 0 0.5 1;

-1 -0.5 0 0.5 1;

-1 -0.5 0 0.5 1];

b=1.5;

k1=0.35;k2=0.35;k3=0.35;k4=0.35;

function sys=mdlDerivatives(t,x,u)

global c b k1 k2 k3 k4 node

x1d=u(1);

dx1d=cos(t);

ddx1d=-sin(t);

dddx1d=-cos(t);

ddddx1d=sin(t);

x1=u(2);x2=u(3);x3=u(4);x4=u(5); %Plant states

z=[x1,x2,x3,x4]';

for j=1:1:node

h(j)=exp(-norm(z-c(:,j))^2/(2*b^2));

end

th_gp=[x(1:node)]'; %gp weight value

th_dp=[x(node+1:node*2)]'; %dp weight value

th_fp=[x(node*2+1:node*3)]'; %fp weight value

gp=th_gp*h';

dp=th_dp*h';

fp=th_fp*h';

mp=x(3*node+1);

e1=x1-x1d;

x2d=dx1d-k1*e1;

e2=x2-x2d;

dx2d=ddx1d-k1*(x2-dx1d);

x3d=-gp+dx2d-k2*e2-e1;

%D3=dddx1d-k1*(x3-ddx1d)-k2*(x3-dx2d)+dx1d-x2;

dx3d1=dddx1d-k1*(x3-ddx1d)-k2*(x3-dx2d)+dx1d-x2;

e3=x3-x3d;

x4d=dx3d1-dp-k3*e3-e2;

e4=x4-x4d;

%D4=ddddx1d-k1*(x4-dddx1d)-k2*(x4-dddx1d+k1*(x3-ddx1d))+ddx1d-x3-k3*(x4-D3)-(x3-dx2d);

dx4d1=ddddx1d-k1*(x4-dddx1d)-k2*(x4-dddx1d+k1*(x3-ddx1d))+ddx1d-x3-k3*(x4-dx3d1)-(x3-dx2d);

ut=(1/mp)*(-fp+dx4d1-k4*e4-e3);

Kexi=[e1 e2 e3 e4]';

n=0.01;

Gama2=250;Gama3=250;Gama4=250;

Gama=[0 0 0 0;

0 Gama2 0 0;

0 0 Gama3 0;

0 0 0 Gama4];

eta=150;

ml=1;

if (e4*ut>0)

dm=(1/eta)*e4*ut;

end

if (e4*ut<=0)

if (mp>ml)

dm=(1/eta)*e4*ut;

else

dm=1/eta;

end

end

for i=1:1:node

sys(i)=Gama(2,2)*h(i)*Kexi(2)-n*Gama(2,2)*norm(Kexi)*th_gp(i); %g estimation

sys(i+node)=Gama(3,3)*h(i)*Kexi(3)-n*Gama(3,3)*norm(Kexi)*th_dp(i); %d estimation

sys(i+node*2)=Gama(4,4)*h(i)*Kexi(4)-n*Gama(4,4)*norm(Kexi)*th_fp(i); %f estimation

end

sys(3*node+1)=dm;

function sys=mdlOutputs(t,x,u)

global c b k1 k2 k3 k4 node

x1d=u(1);

dx1d=cos(t);

ddx1d=-sin(t);

dddx1d=-cos(t);

ddddx1d=sin(t);

x1=u(2);x2=u(3);x3=u(4);x4=u(5);

z=[x1,x2,x3,x4]';

for j=1:1:node

h(j)=exp(-norm(z-c(:,j))^2/(2*b^2));

end

th_gp=[x(1:node)]'; %gp weight

th_dp=[x(node+1:node*2)]'; %dp weight

th_fp=[x(node*2+1:node*3)]'; %fp weight

gp=th_gp*h';

dp=th_dp*h';

fp=th_fp*h';

mp=x(node*3+1);

e1=x1-x1d;

x2d=dx1d-k1*e1;

e2=x2-x2d;

dx2d=ddx1d-k1*(x2-dx1d);

x3d=-gp+dx2d-k2*e2-e1;

%D3=dddx1d-(k1)*(x3-ddx1d)-(k2)*(x3-dx2d)+dx1d-x2;

dx3d1=dddx1d-(k1)*(x3-ddx1d)-(k2)*(x3-dx2d)+dx1d-x2;

e3=x3-x3d;

x4d=dx3d1-dp-k3*e3-e2;

e4=x4-x4d;

%D4=ddddx1d-(k1)*(x4-dddx1d)-(k2)*(x4-dddx1d+(k1)*(x3-ddx1d))-(k3)*(x4-D3)-(x3-dx2d)+ddx1d-x3;

dx4d1=ddddx1d-(k1)*(x4-dddx1d)-(k2)*(x4-dddx1d+(k1)*(x3-ddx1d))-(k3)*(x4-dx3d1)-(x3-dx2d)+ddx1d-x3;

ut=(1/mp)*(-fp+dx4d1-k4*e4-e3);

sys(1)=ut;

sys(2)=gp;

sys(3)=mp;

S function for plant: chap8_4plant.m

function [sys,x0,str,ts]=MIMO_Tong_plant(t,x,u,flag)

switch flag,

case 0,

[sys,x0,str,ts]=mdlInitializeSizes;

case 1,

sys=mdlDerivatives(t,x,u);

case 3,

sys=mdlOutputs(t,x,u);

case {2, 4, 9 }

sys = [];

otherwise

error(['Unhandled flag = ',num2str(flag)]);

end

function [sys,x0,str,ts]=mdlInitializeSizes

sizes = simsizes;

sizes.NumContStates = 4;

sizes.NumDiscStates = 0;

sizes.NumOutputs = 6;

sizes.NumInputs = 3;

sizes.DirFeedthrough = 0;

sizes.NumSampleTimes = 0;

sys=simsizes(sizes);

x0=[0 0 0 0];

str=[];

ts=[];

function sys=mdlDerivatives(t,x,u)

M=0.2;L=0.02;I=1.35*0.001;K=7.47;J=2.16*0.1;

g=9.8;

gx=-x(3)-M*g*L*sin(x(1))/I-(K/I)*(x(1)-x(3));

fx=(K/J)*(x(1)-x(3));

m=1/J;

ut=u(1);

sys(1)=x(2);

sys(2)=x(3)+gx;

sys(3)=x(4);

sys(4)=fx+m*ut;

function sys=mdlOutputs(t,x,u)

M=0.2;L=0.02;I=1.35*0.001;K=7.47;J=2.16*0.1;

g=9.8;

gx=-x(3)-M*g*L*sin(x(1))/I-(K/I)*(x(1)-x(3));

m=1/J;

sys(1)=x(1);

sys(2)=x(2);

sys(3)=x(3);

sys(4)=x(4);

sys(5)=gx;

sys(6)=m;

Plot program: chap8_4plot.m

close all;

figure(1);

subplot(211);

plot(t,y(:,1),'r',t,y(:,3),'k:','linewidth',2);

xlabel('time(s)');ylabel('Position tracking');

legend('Ideal position','Position tracking');

subplot(212);

plot(t,y(:,2),'r',t,y(:,4),'k:','linewidth',2);

xlabel('time(s)');ylabel('Speed tracking');

legend('Ideal speed','Speed tracking');

figure(2);

plot(t,ut(:,1),'r','linewidth',2);

xlabel('time(s)');ylabel('Control input');

figure(3);

subplot(211);

plot(t,p(:,5),'r',t,p(:,8),'k:','linewidth',2);

xlabel('time(s)');ylabel('gx and its estimated value');

legend('gx','estiamted gx');

subplot(212);

plot(t,p(:,6),'r',t,p(:,9),'k:','linewidth',2);

xlabel('time(s)');ylabel('m and its estimated value');

legend('m','estiamted m');