第3章
CHAPTER 3


机械手神经网络自适应控制






如果被控对象的数学模型已知，滑模控制器可以使系统输出直接跟踪期望指令，但较大的建模不确定性需要较大的切换增益，这就造成抖振，抖振是滑模控制中难以避免的问题。
将滑模控制结合神经网络逼近用于非线性系统的控制中，采用神经网络实现模型未知部分的自适应逼近，可有效地降低切换增益。神经网络自适应律通过Lyapunov方法导出，通过自适应权重的调节保证整个闭环系统的稳定性和收敛性。
RBF(Radial Basis Function，径向基函数)神经网络于1988年提出。相比多层前馈BP
（Back Propagation，反向传播）网络，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)

取η>εN，自适应律为

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（x）+τd（3.12）

其中，f(x)=M(q¨d+Λe·)+C(qd+Λe)+G+F。
在实际工程中，模型不确定项f（x）为未知，为此，需要对不确定项f（x）进行逼近。
采用RBF网络逼近f（x），根据f(x)的表达式，网络输入取
x=［eTe·TqTdq·Tdq¨Td］
设计控制律为

τ= f^（x）+Kvr（3.13）

其中，f^(x)为RBF网络的估计值。
将控制律式（3.13）代入式（3.12），得

Mr·=-Cr-f^（x）-Kvr+f（x）+τd

=-(Kv+C)r+f～（x）+τd=-(Kv+C)r+ζ0（3.14）

其中，f～（x）=f（x）-f^（x），ζ0=f～+τd。
如果定义Lyapunov函数
L=12rTMr

则

L·=rTMr·+12rTM·r=-rTKvr+12rT(M·-2C)r+rTζ0

=rTζ0-rTKvr

这说明在Kv固定条件下，控制系统的稳定依赖于ζ0，即f^对f的逼近精度及干扰τd的大小。
采用RBF网络对不确定项f进行逼近。理想的RBF网络算法为 

j=g(‖x-ci‖2/b2j)

y=Wφ(x)

其中，x为网络的输入信号，φ（x）=［12…n］,j为隐层节点的个数，i为网络输入的个数。
3.2.2基于RBF网络逼近的控制器
1. 控制器的设计

采用RBF网络逼近f（x），则RBF神经网络的输出为

f^(x)= W^Tφ
(x)（3.15）

取
W～=W-W^，‖W‖F≤Wmax
设计控制律为

τ= W^Tφ(x)+Kvr-�瘙
經（3.16）

其中，�瘙
經为用于克服神经网络逼近误差ε的鲁棒项。
将控制律式（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） 取�瘙
經(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)设计的情况
将鲁棒项�瘙
經设计为

�瘙
經=-(ε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）

考虑L·≤0时，如取kV足够大，
当t→∞时，r→0，从而e→0，
e·→0
。由于L≥0,L·≤0，则L有界，从而
r和W～M、W～V、W～G、
W～F有界，但无法保证W～M、W～V、W～G、
W～F收敛于零。

3.2.4仿真实例
选择二关节机机械臂系统，其动力学模型为
M(q)q¨+V(q,q·)q·+G(q)+F(q·)+τd=τ


其中，

M(q)=p1+p2+2p3cosq2p2+p3cosq2

p2+p3cosq2p2
V(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)

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］Park J,Sandberg I W.Universal approximation using radial basis function networks［J］.Neural Computation,1991,3(2)： 246257.

［2］刘金琨.RBF神经网络自适应控制MATLAB仿真［M］.北京： 清华大学出版社，2014.

［3］Lewis F L,Liu K,Yesildirek A.Neural net robot controller with guaranteed tracking.performance
［J］.IEEE Transactions on Neural Networks, 1995, 6(3)： 703715.