当当触屏版

get_product_contenthtml 第3章机械手神经网络自适应控制

如果被控对象的数学模型已知，滑模控制器可以使系统输出直接跟踪期望指令，但较大的建模不确定性需要较大的切换增益，这就造成抖振，抖振是滑模控制中难以避免的问题。将滑模控制结合神经网络逼近用于非线性系统的控制中，采用神经网络实现模型未知部分的自适应逼近，可有效地降低模糊增益。神经网络自适应律通过Lyapunov方法导出，通过自适应权重的调节保证整个闭环系统的稳定性和收敛性。RBF神经网络于1988年提出。相比多层前馈BP网络，RBF网络由于具有良好的泛化能力，网络结构简单，避免不必要和冗长的计算而备受关注。关于RBF网络的研究表明RBF神经网络能在一个紧凑集和任意精度下，逼近任何非线性函数［1］。目前，已经有许多针对非线性系统的RBF神经网络控制研究成果发表。3.1一种简单的RBF网络自适应滑模控制3.1.1问题描述
考虑一种简单的动力学系统：
θ¨=f(θ,θ·) u（3.1）
其中，θ为转动角度，u为控制输入。写成状态方程形式为
x·1=x2
x·2=f(x) u（3.2）
其中，x1=θ,x2=θ·,f(x)为未知。角度指令为xd，则误差及其导数为e=x1-xd，e·=x2-x·d定义滑模函数
s=ce e·，c>0（3.3）
则s·=ce· e¨=ce· x·2-x¨d=ce· f(x) u-x¨d由式（3.3）可见，如果s→0，则e→0且e·→0。3.1.2RBF网络原理由于RBF网络具有逼近特性［1］，采用RBF神经网络逼近f(x)，网络算法为
hj=exp‖x-cj‖22b2j（3.4）
f=W*Th(x) ε（3.5）
其中,x为网络的输入，j为网络隐含层第j个节点,h=［hj］T 为网络的高斯基函数输出，W*为网络的理想权值, ε为网络的逼近误差,ε≤εN。网络输入取x=［x1x2］T,则网络输出为
f(x)=W^Th(x)(3.6)
3.1.3控制算法设计与分析
由于f(x)-f^(x)=W*Th(x) ε-W^Th(x)=-W～Th(x) ε。定义Lyapunov函数为
V=12s2 12γW～TW～（3.7）
其中,γ>0，W～=W^-W*。
则
V·=ss·1γW～TW
=s(ce· f(x) u-x¨d) 1γW～TW
设计控制律为
u=-ce·-f^(x) x¨d-ηsgn(s)（3.8）
则
V·=s(f(x)-f^(x)-ηsgn(s)) 1γW～TW
=s(-W～Th(x) ε-ηsgn(s)) 1γW～TW
=εs-ηs W～T1γW-sh(x)
取η>εmax，自适应律为
W=γsh(x)（3.9）
则V·=εs-ηs≤0。可见，控制律中的鲁棒项ηsgn(s)的作用是克服神经网络的逼近误差，以保证系统稳定。由于当且仅当s=0时，V·=0。即当V·≡0时，s≡0。根据LaSalle不变性原理，闭环系统为渐进稳定，即当t→∞时，s→0。系统的收敛速度取决于η。由于V≥0，V·≤0，则当t→∞时，V有界，因此，可以证明W^有界，但无法保证W^收敛于W*。3.1.4仿真实例考虑如下被控对象x·1=x2
x·2=f(x) u

其中，f(x)=10x1x2。被控对象的初始状态取［0.150］，位置指令为xd=sint，控制律采用式（3.8），自适应律采用式（3.9），取γ=1500，η=1.5。根据网络输入x1和x2的实际范围来设计高斯基函数的参数［2］，参数cj和bj取值分别为0.5×［-2-1012］和3.0。仿真程序中为了避免混淆，将s=ce e·中的c写为λ，取λ=10。网络权值中各个元素的初始值取0.10。仿真结果如图31和图32所示。

图31角度和角速度跟踪

图32f(x)及逼近

仿真程序如下：（1） Simulink主程序： chap3_1sim.mdl

（2）控制律及自适应律S函数： chap3_1ctrl.m
function ［sys,x0,str,ts］ = spacemodel(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 b c lama
sizes = simsizes;
sizes.NumContStates= 5;
sizes.NumDiscStates= 0;
sizes.NumOutputs = 2;
sizes.NumInputs= 4;
sizes.DirFeedthrough = 1;
sizes.NumSampleTimes = 1;
sys = simsizes(sizes);
x0= 0.1*ones(1,5);
str = ［］;
ts= ［0 0］;
c=0.5*［-2 -1 0 1 2;
-2 -1 0 1 2］;
b=3.0;
lama=10;
function sys=mdlDerivatives(t,x,u)
global b c lama
xd=sin(t);
dxd=cos(t);

x1=u(2);
x2=u(3);
e=x1-xd;
de=x2-dxd;
s=lama*e de;

W=［x(1) x(2) x(3) x(4) x(5)］';
xi=［x1;x2］;

h=zeros(5,1);
for j=1:1:5
h(j)=exp(-norm(xi-c(:,j))^2/(2*b^2));
end

gama=1500;
for i=1:1:5
sys(i)=gama*s*h(i);
end

function sys=mdlOutputs(t,x,u)
global b c lama
xd=sin(t);
dxd=cos(t);
ddxd=-sin(t);

x1=u(2);
x2=u(3);
e=x1-xd;
de=x2-dxd;
s=lama*e de;

W=［x(1) x(2) x(3) x(4) x(5)］;
xi=［x1;x2］;

h=zeros(5,1);
for j=1:1:5
h(j)=exp(-norm(xi-c(:,j))^2/(2*b^2));
end
fn=W*h;
xite=1.50;

%fn=10*x1 x2;%Precise f
ut=-lama*de ddxd-fn-xite*sign(s);

sys(1)=ut;
sys(2)=fn;(3) 被控对象S函数： chap3_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 = 3;
sizes.NumInputs= 2;
sizes.DirFeedthrough = 0;
sizes.NumSampleTimes = 0;
sys=simsizes(sizes);
x0=［0.15;0］;
str=［］;
ts=［］;
function sys=mdlDerivatives(t,x,u)
ut=u(1);

f=10*x(1)*x(2);
sys(1)=x(2);
sys(2)=f ut;
function sys=mdlOutputs(t,x,u)
f=10*x(1)*x(2);

sys(1)=x(1);
sys(2)=x(2);
sys(3)=f;(4) 作图程序： chap3_1plot.m
close all;

figure(1);
subplot(211);
plot(t,x(:,1),'r',t,x(:,2),'b','linewidth',2);
xlabel('time(s)');ylabel('position tracking');
subplot(212);
plot(t,cos(t),'r',t,x(:,3),'b','linewidth',2);
xlabel('time(s)');ylabel('speed tracking');

figure(2);
plot(t,f(:,1),'r',t,f(:,3),'b','linewidth',2);
xlabel('time(s)');ylabel('f approximation');3.2基于RBF网络逼近的机械手自适应控制通过对文献［3］的控制方法进行详细推导及仿真分析，研究一类机械臂神经网络自适应控制的设计方法。3.2.1问题的提出设n关节机械手方程为
M(q)q¨ C(q,q·)q· G(q) F(q·) τd=τ（3.10）
其中,M(q)为n×n阶正定惯性矩阵，C(q,q·)为n×n阶惯性矩阵，其中,G(q)为n×1阶惯性向量，F(q·)为摩擦力，τd为未知外加干扰，τ为控制输入。跟踪误差为e(t)=qd(t)-q(t)定义误差函数为
r=e· Λe（3.11）
其中，Λ=ΛT>0，则
q·=-r q·d Λe
Mr·=M(q¨d-q¨ Λe·)=M(q¨d Λe·)-Mq¨
=M(q¨d Λe·) Cq· G F τd-τ
=M(q¨d Λe·)-Cr C(q·d Λe) G F τd-τ
=-Cr-τ f τd（3.12）
其中，f(x)=M(q¨d Λe·) C(qd Λe) G F。在实际工程中，模型不确定项f为未知，为此，需要对不确定项f进行逼近。采用RBF网络逼近f，根据f(x)的表达式，网络输入取x=［eTe·TqTdq·Tdq¨Td］设计控制律为
τ=f^ Kvr（3.13）
其中,f^(x)为RBF网络的估计值。将控制律式（3.13）代入式（3.12），得
Mr·=-Cr-f^-Kvr f τd
=-(Kv C)r f～ τd=-(Kv C)r ζ0（3.14）
其中,f～=f-f^，ζ0=f～ τd。如果定义Lyapunov函数L=12rTMr
则
L·=rTMr· 12rTM·r=-rTKvr 12rT(M·-2C)r rTζ0
L·=rTζ0-rTKvr
这说明在Kv固定条件下，控制系统的稳定依赖于ζ0，即f^对f的逼近精度及干扰τd的大小。采用RBF网络对不确定项f进行逼近。理想的RBF网络算法为
j=g(‖x-ci‖2/b2j)
y=Wφ(x)
其中，x为网络的输入信号，φ=［12…n］,j为隐层节点的个数，i为网络输入的个数。3.2.2基于RBF神经网络逼近的控制器1. 控制器的设计
采用RBF网络逼近f，则RBF神经网络的输出为
f^(x)=W^Tφ(x)（3.15）
取W～=W-W^，‖W‖F≤Wmax设计控制律为
τ=W^Tφ(x) Kvr-?瘙經（3.16）
其中，v为用于克服神经网络逼近误差ε的鲁棒项。将控制律式（3.16）代入式（3.12），得
Mr·=-(Kv C)r W～Tφ(x) (ε τd) ?瘙經=-(Kv C)r ζ1（3.17）
其中，ζ1=W～Tφ(x) (ε τd) ?瘙經。 2. 稳定性及收敛性分析根据控制律式（3.16）中是否有?瘙經(t)项，ε和τd是否存在以及神经网络自适应律设计的不同，系统的收敛性不同。1）取v(t)=0，存在ε和τd的情况定义Lyapunov函数
L=12rTMr 12tr(W～TF-1W～)（3.18）
则L·=rTMr· 12rTM·r tr(W～TF-1W)
将式（3.17）代入上式，得
L·=-rTKvr 12rT(M·-2C)r trW～T(F-1W φrT) rT(ε τd)（3.19）
考虑机械手特性，并取W=-FφrT
即神经网络自适应律为
W=FφrT（3.20）
则L·=-rTKvr rT(ε τd)≤-Kvmin‖r‖2 (εN bd)‖r‖
其中，‖ε‖≤εN，‖τd‖≤bd。当满足下列收敛条件时，L·≤0：
‖r‖≥(εN bd)/Kvmin（3.21）
2）取v(t)=0，ε=0，τd=0的情况Lyapunov函数为
L=12rTMr 12tr(W～TF-1W～)（3.22）
此时控制律和自适应律为
τ=W^Tφ(x) Kvr（3.23）
W=FφrT（3.24）
由式（3.17）知
Mr·=-(Kv C)r W～Tφ(x)
则L·=rTMr· 12rTM·r=-rTKvr≤0
3）取v(t)=0，存在ε和τd，自适应律采取UUB的形式Lyapunov函数和控制律取式（3.22）和式（3.23）。自适应律为
W=FφrT-kF‖r‖W^（3.25）
则根据式（3.19），有L·=-rTKvr 12rT(M·-2C)r trW～T(F-1W φrT) rT(ε τd)
将式（3.25）代入上式，得
L·=-rTKvr trW～T(-φrT k‖r‖W^ φrT) rT(ε τd)
=-rTKvr k‖r‖trW～T(W-W～) rT(ε τd)
由于trW～T(W-W～)=(W～,W)F-‖W‖2F≤‖W～‖F‖W‖F-‖W～‖2F
则
L·≤-Kvmin‖r‖2 k‖r‖‖W～‖F(Wmax-‖W～‖F) (εN bd)‖r‖
=-‖r‖(Kvmin‖r‖ k‖W～‖F(‖W～‖F-Wmax)-(εN bd))
由于
Kvmin‖r‖ k‖W～‖F(‖W～‖F-Wmax)-(εN bd)
=k(‖W～‖F-Wmax/2)2-kW2max/4 Kvmin‖r‖-(εN bd)
则要使L·≤0，需要
‖r‖≥kW2max/4 (εN bd)Kvmin（3.26）
或
‖W～‖F≥Wmax/2 W2max/4 (εN bd)/k（3.27）
4）存在ε和τd，考虑鲁棒项?瘙經(t)设计的情况将鲁棒项v设计为
?瘙經=-(εN bd)sgn(r)（3.28）
控制律取式（3.16），神经网络自适应律取式（3.20）。定义Lyapunov函数为
L=12rTMr 12tr(W～TF-1W～)
则L·=rTMr· 12rTM·r tr(W～TF-1W)
将（3.17）式代入上式，得L·=-rTKvr 12rT(M·-2C)r trW～T(F-1W φrT) rT(ε τd ?瘙經)
则L·=-rTKvr rT(ε τd ?瘙經)由于rT(ε τd ?瘙經)=rT(ε τd) rT?瘙經=rT(ε τd)-‖r‖(εN bd)≤0
则L·≤0针对以上4种情况，由于当L·≡0时，r≡0，根据LaSalle不变性原理，闭环系统渐近稳定，t→∞时，r→0。由于L≥0，L·≤0，则L有界，从而W～有界，但无法保证W～收敛于0。3.2.3针对f(x)中各项分别进行神经网络逼近控制律为
τ=W^Tφ(x) Kvr-?瘙經（3.29）
鲁棒项?瘙經取式（3.28）。由式（3.12）知，被控对象中的f(x)项可写为f(x)=M(q)ζ1(t) C(q,q·)ζ2(t) G(q) F(q·)其中,ζ1(t)=q¨d Λe·，ζ2(t)=q·d Λe。采用RBF神经网络，可以对f(x)中的各项分别进行逼近：
M^(q)=WTMφM(q)
C^(q,q·)=WTVφV(q,q·)
G^(q)=WTGφG(q)
F^(q·)=WTFφF(q·)
则
f^(x)=［WTMζ1(t)WTVζ2(t)WTGWTF］φMφVφGφF（3.30）
其中,φ(x)=φMφVφGφF，WT=［WTMWTVWTGWTF］。自适应律为
WM=FMφMrT-kMFM‖r‖W^M（3.31）
WV=FVφVrT-kVFV‖r‖W^V（3.32）
WG=FGφGrT-kGFG‖r‖W^G（3.33）
WF=FFφFrT-kFFF‖r‖W^F（3.34）
其中，kM>0，kV>0，kG>0，kF>0。稳定性分析如下：定义Lyapunov函数为L=12rTMr 12tr(W～TMF-1MW～M) 12tr(W～TVF-1VW～V)
12tr(W～TGF-1GW～G) 12tr(W～TFF-1FW～F)
则L·=rTMr· 12rTM·r tr(W～TMF-1MWM) tr(W～TVF-1VWV)
tr(W～TGF-1GWG) tr(W～TFF-1FWF)
将式（3.17）代入上式，得
L·=-rTKvr 12rT(M·-2Vm)r rT(ε τd) rT?瘙經 trW～TM(F-1MWM φMrT)
trW～TV(F-1VWV φVrT) trW～TG(F-1GWG φMrT) trW～TF(F-1FWF φFrT)（3.35）
考虑机械手特性，并将神经网络自适应律式（3.31）~式（3.34）代入上式，得

L·=-rTKvr kM‖r‖trW～TM(WM-W～M) kV‖r‖trW～TV(WV-W～V)
kG‖r‖trW～TG(WG-W～G) kF‖r‖trW～TF(WF-W～F) rT(ε τd) rT?瘙經
由于trW～T(W-W～)=(W～,W)F-‖W‖2F≤‖W～‖F‖W‖F-‖W～‖2F
考虑鲁棒项（3.28），则

L·≤-Kvmin‖r‖2 kM‖r‖‖W～M‖F(WMmax-‖W～M‖F)
kV‖r‖‖W～V‖F(WVmax-‖W～V‖F)
kG‖r‖‖W～G‖F(WGmax-‖W～G‖F) kM‖r‖‖W～F‖F(WFmax-‖W～F‖F)
=-‖r‖［Kvmin‖r‖ kM‖W～M‖F(‖W～M‖F-WMmax)
kV‖W～V‖F(‖W～V‖F-WVmax) kG‖W～G‖F(‖W～G‖F-WGmax)
kF‖W～F‖F(‖W～F‖F-WFmax)］
由于k‖W～‖F(‖W～‖F-Wmax)=k(‖W～‖F-Wmax/2)2-kW2max/4
要使L·≤0，需要
‖r‖≥kMW2Mmax/4 kVW2Vmax/4 kGW2Gmax/4 kFW2Fmax/4Kvmin（3.36）
或
‖W～M‖F≥WMmax且‖W～V‖F≥WVmax且‖W～G‖F≥WGmax且‖W～F‖F≥WFmax（3.37）
由式（3.35）可见，由于L·≤0当L·≡0时，r≡0,根据LaSalle不变集原理，当t→∞时，r→0。由于L≥0,L·≤0，则L有界，从而r和W～i有界，但无法保证W～i收敛于零。
3.2.4仿真实例选择二关节机机械臂系统，其动力学模型为M(q)q¨ V(q,q·)q· G(q) F(q·) τd=τ
其中，
M(q)=p1 p2 2p3cosq2p2 p3cosq2
p2 p3cosq2p2V(q,q·)=-p3q·2sinq2-p3(q·1 q·2)sinq2
p3q·1sinq20
G(q)=p4gcosq1 p5gcos(q1 q2)p5gcos(q1 q2)F(q·)=0.2sgn(q·)，τd=［0.1sin(t)0.1sin(t)］T
取p=［p1,p2,p3,p4,p5］=［2.9,0.76,0.87,3.04,0.87］。RBF网络高斯基函数参数的取值对神经网络控制的作用很重要，如果参数取值不合适，将使高斯基函数无法得到有效的映射，从而导致RBF网络无效。故c按网络输入值的范围取值，取bj=0.20，c=0.1-1.5-1-0.500.511.5
-1.5-1-0.500.511.5
-1.5-1-0.500.511.5
-1.5-1-0.500.511.5
-1.5-1-0.500.511.5,网络的初始权值取零，网络输入取z=［ee·qdq·dq¨d］。系统的初始状态为［0.090-0.090］，两个关节的角度指令分别为q1d=01sint，q2d=0.1sint，控制参数取Kv=diag20,20，F=diag1.5,1.5，Λ=diag5,5，在鲁棒项中，取εN=0.20，bd=0.10。采用Simulink和S函数进行控制系统的设计，神经网络权值矩阵中任意元素初值取0.10。总体逼近控制器子程序chap3_9ctrl.m，按3.2.2节第4种情况设计控制律，控制律取式（3.16），v取式（3.28），自适应律取式（3.20）。采用总体逼近控制器，仿真结果如图33~图36所示。

图33关节1及关节2的角度跟踪

图34关节1及关节2的角速度跟踪

图35关节1及关节2的控制输入

图36关节1及关节2的‖f(x)‖及其逼近‖f^(x)‖

仿真程序如下：（1） Simulink主程序： chap3_2sim.mdl

（2）位置指令子程序： chap3_2input.m
function ［sys,x0,str,ts］ = spacemodel(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= 0;
sizes.NumDiscStates= 0;
sizes.NumOutputs = 6;
sizes.NumInputs= 0;
sizes.DirFeedthrough = 0;
sizes.NumSampleTimes = 1;
sys = simsizes(sizes);
x0= ［］;
str = ［］;
ts= ［0 0］;
function sys=mdlOutputs(t,x,u)
qd1=0.1*sin(t);
d_qd1=0.1*cos(t);
dd_qd1=-0.1*sin(t);
qd2=0.1*sin(t);
d_qd2=0.1*cos(t);
dd_qd2=-0.1*sin(t);

sys(1)=qd1;
sys(2)=d_qd1;
sys(3)=dd_qd1;
sys(4)=qd2;
sys(5)=d_qd2;
sys(6)=dd_qd2;（3）总体逼近控制器子程序： chap3_2ctrl.m

function ［sys,x0,str,ts］ = spacemodel(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 node c b Fai

node=7;
c=0.1*［-1.5 -1 -0.5 0 0.5 1 1.5;
-1.5 -1 -0.5 0 0.5 1 1.5;
-1.5 -1 -0.5 0 0.5 1 1.5;
-1.5 -1 -0.5 0 0.5 1 1.5;
-1.5 -1 -0.5 0 0.5 1 1.5］;
b=10;
Fai=5*eye(2);

sizes = simsizes;
sizes.NumContStates= 2*node;
sizes.NumDiscStates= 0;
sizes.NumOutputs = 3;
sizes.NumInputs= 11;
sizes.DirFeedthrough = 1;
sizes.NumSampleTimes = 0;
sys = simsizes(sizes);
x0= 0.1*ones(1,2*node);
str = ［］;
ts= ［］;
function sys=mdlDerivatives(t,x,u)
global node c b Fai
qd1=u(1);
d_qd1=u(2);
dd_qd1=u(3);
qd2=u(4);
d_qd2=u(5);
dd_qd2=u(6);

q1=u(7);
d_q1=u(8);
q2=u(9);
d_q2=u(10);

q=［q1;q2］;

e1=qd1-q1;
e2=qd2-q2;
de1=d_qd1-d_q1;
de2=d_qd2-d_q2;
e=［e1;e2］;
de=［de1;de2］;
r=de Fai*e;

qd=［qd1;qd2］;
dqd=［d_qd1;d_qd2］;
dqr=dqd Fai*e;
ddqd=［dd_qd1;dd_qd2］;
ddqr=ddqd Fai*de;

z1=［e(1);de(1);qd(1);dqd(1);ddqd(1)］;
z2=［e(2);de(2);qd(2);dqd(2);ddqd(2)］;
for j=1:1:node
h1(j)=exp(-norm(z1-c(:,j))^2/(b*b));
h2(j)=exp(-norm(z2-c(:,j))^2/(b*b));
end

F=1.5*eye(node);

for i=1:1:node
sys(i)=1.5*h1(i)*r(1);
sys(i node)=1.5*h2(i)*r(2);
end

function sys=mdlOutputs(t,x,u)
global node c b Fai

qd1=u(1);
d_qd1=u(2);
dd_qd1=u(3);
qd2=u(4);
d_qd2=u(5);
dd_qd2=u(6);

q1=u(7);
d_q1=u(8);
q2=u(9);
d_q2=u(10);

q=［q1;q2］;

e1=qd1-q1;
e2=qd2-q2;
de1=d_qd1-d_q1;
de2=d_qd2-d_q2;
e=［e1;e2］;
de=［de1;de2］;
r=de Fai*e;

qd=［qd1;qd2］;
dqd=［d_qd1;d_qd2］;
dqr=dqd Fai*e;
ddqd=［dd_qd1;dd_qd2］;
ddqr=ddqd Fai*de;

z=［e;de;qd;dqd;ddqd］;
W_f1=［x(1:node)］';
W_f2=［x(node 1:node*2)］';

z1=［e(1);de(1);qd(1);dqd(1);ddqd(1)］;
z2=［e(2);de(2);qd(2);dqd(2);ddqd(2)］;
for j=1:1:node
h1(j)=exp(-norm(z1-c(:,j))^2/(b*b));
h2(j)=exp(-norm(z2-c(:,j))^2/(b*b));
end

fn=［W_f1*h1';
W_f2*h2'］;
Kv=20*eye(2);

epN=0.20;
bd=0.1;
v=-(epN bd)*sign(r);
tol=fn Kv*r-v;

fn_norm=norm(fn);

sys(1)=tol(1);
sys(2)=tol(2);
sys(3)=fn_norm;
(4) 被控对象子程序： chap3_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
global p g
sizes = simsizes;
sizes.NumContStates= 4;
sizes.NumDiscStates= 0;
sizes.NumOutputs = 5;
sizes.NumInputs=3;
sizes.DirFeedthrough = 0;
sizes.NumSampleTimes = 0;
sys=simsizes(sizes);
x0=［0.09 0 -0.09 0］;
str=［］;
ts=［］;

p=［2.9 0.76 0.87 3.04 0.87］;
g=9.8;
function sys=mdlDerivatives(t,x,u)%From Ge book program
global p g

M=［p(1) p(2) 2*p(3)*cos(x(3)) p(2) p(3)*cos(x(3));
p(2) p(3)*cos(x(3)) p(2)］;
V=［-p(3)*x(4)*sin(x(3)) -p(3)*(x(2) x(4))*sin(x(3));
p(3)*x(2)*sin(x(3))0］;
G=［p(4)*g*cos(x(1)) p(5)*g*cos(x(1) x(3));
p(5)*g*cos(x(1) x(3))］;
dq=［x(2);x(4)］;
F=0.2*sign(dq);
told=［0.1*sin(t);0.1*sin(t)］;

tol=u(1:2);

S=inv(M)*(tol-V*dq-G-F-told);

sys(1)=x(2);
sys(2)=S(1);
sys(3)=x(4);
sys(4)=S(2);
function sys=mdlOutputs(t,x,u)
global p g
M=［p(1) p(2) 2*p(3)*cos(x(3)) p(2) p(3)*cos(x(3));
p(2) p(3)*cos(x(3)) p(2)］;
V=［-p(3)*x(4)*sin(x(3)) -p(3)*(x(2) x(4))*sin(x(3));
p(3)*x(2)*sin(x(3))0］;
G=［p(4)*g*cos(x(1)) p(5)*g*cos(x(1) x(3));
p(5)*g*cos(x(1) x(3))］;
dq=［x(2);x(4)］;
F=0.2*sign(dq);
told=［0.1*sin(t);0.1*sin(t)］;

qd1=sin(t);
d_qd1=cos(t);
dd_qd1=-sin(t);
qd2=sin(t);
d_qd2=cos(t);
dd_qd2=-sin(t);
qd1=0.1*sin(t);
d_qd1=0.1*cos(t);
dd_qd1=-0.1*sin(t);
qd2=0.1*sin(t);
d_qd2=0.1*cos(t);
dd_qd2=-0.1*sin(t);

q1=x(1);
d_q1=dq(1);
q2=x(3);
d_q2=dq(2);
q=［q1;q2］;
e1=qd1-q1;
e2=qd2-q2;
de1=d_qd1-d_q1;
de2=d_qd2-d_q2;
e=［e1;e2］;
de=［de1;de2］;
Fai=5*eye(2);
dqd=［d_qd1;d_qd2］;
dqr=dqd Fai*e;
ddqd=［dd_qd1;dd_qd2］;
ddqr=ddqd Fai*de;
f=M*ddqr V*dqr G F;
f_norm=norm(f);

sys(1)=x(1);
sys(2)=x(2);
sys(3)=x(3);
sys(4)=x(4);
sys(5)=f_norm;(5) 绘图子程序： chap3_2plot.m
close all;

figure(1);
subplot(211);
plot(t,x1(:,1),'r',t,x1(:,2),'b');
xlabel('time(s)');ylabel('position tracking for link 1');
subplot(212);
plot(t,x2(:,1),'r',t,x2(:,2),'b');
xlabel('time(s)');ylabel('position tracking for link 2');

figure(2);
subplot(211);
plot(t,dx1(:,1),'r',t,dx1(:,2),'b');
xlabel('time(s)');ylabel('speed tracking for link 1');
subplot(212);
plot(t,dx2(:,1),'r',t,dx2(:,2),'b');
xlabel('time(s)');ylabel('speed tracking for link 2');

figure(3);
subplot(211);
plot(t,tol1(:,1),'r');
xlabel('time(s)');ylabel('control input of link 1');
subplot(212);
plot(t,tol2(:,1),'r');
xlabel('time(s)');ylabel('control input of link 2');

figure(4);
plot(t,f(:,1),'r',t,f(:,2),'b');
xlabel('time(s)');ylabel('f and fn');参考文献

［1］J.Park, I.W.Sandberg. Universal Approximation Using Radial Basis Function Networks［J］. Neural Computation, 1991, 3(2)： 246257.
［2］刘金琨.RBF神经网络自适应控制MATLAB仿真.北京：清华大学出版社，2014.
［3］Lewis F L,Liu K, Yesildirek A. Neural Net Robot Controller with Guaranteed Tracking. Performance. IEEE Transactions on Neural Networks, 1995, 6(3)： 703715.