diff --git a/B1.m b/B1.m new file mode 100644 index 0000000..949518b --- /dev/null +++ b/B1.m @@ -0,0 +1,186 @@ +function [sys,x0,str,ts] = B1(t,x,u,flag) +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 %连续状态计算 + sys=mdlDerivatives(t,x,u); + case {2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag)); +end + +function [sys,x0,str,ts]=mdlInitializeSizes %系统的初始化 +global c b kv kp +sizes = simsizes; +sizes.NumContStates = 10; %设置系统连续状态的变量 W V +sizes.NumDiscStates = 0; %设置系统离散状态的变量 +sizes.NumOutputs = 6; %设置系统输出的变量 +sizes.NumInputs = 10; %设置系统输入的变量 +sizes.DirFeedthrough = 1; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 1; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = 0.1 * ones(1, 10); % 系统初始状态变量 代表W和V向量 +str = []; % 保留变量，保持为空 +ts = [0 0]; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 +% 神经网络采用4 - 5 - 2结构 +c = 1 * [-2 -1 -0 1 2; + -2 -1 -0 1 2; + -2 -1 -0 1 2; + -2 -1 -0 1 2]; % 高斯函数的中心点矢量 维度 IN * MID 4*5 +b = 3; % 高斯函数的基宽 维度node * 1 5*1 b的选择很重要 b越大 网路对输入的映射能力越大 +alph = 3; +kp = [alph^2 0; 0 alph^2]; +kv = [2 * alph 0;0 2*alph]; + +function sys = mdlDerivatives(t,x,u) %该函数仅在连续系统中被调用，用于产生控制系统状态的导数 +global c b kv kp +% 仿真中应根据网络输入值的有效映射范围来设计 c和b 从而保证有效的高斯映射 不合适的b或c均会导致结果不正确 +node = 5; +Q = 50 * eye(4); +A = [zeros(2,2) eye(2,2); -kp -kv]; % 4*4 +P = lyap(A' , Q); % 4*4 +B = [0 0;0 0;1 0;0 1]; + +qd1 = u(1); +qd2 = u(2); +d_qd1 = u(3); +d_qd2 = u(4); +q1 = u(5); +q2 = u(6); +dq1 = u(7); +dq2 = u(8); + +e1 = q1 - qd1; % e = q - qd +e2 = q2 - qd2; +de1 = dq1 - d_qd1; +de2 = dq2 - d_qd2; + +W = [x(1) x(2) x(3) x(4) x(5); x(6) x(7) x(8) x(9) x(10)]'; +Input = [e1; e2; de1; de2]; +h = zeros(node , 1); %5*1矩阵 +for i =1:node + h(i) = exp(-(norm(Input - c(:,i))^2) / (2*b^2)); +end +gama = 20; +dw = gama * h * Input' * P * B; +dw = dw'; +for i = 1:1:5 + sys(i) = dw(1,i); + sys(i+5) = dw(2,i); +end + +% 参数的定义 +% v = 13.33; +% a1 = 8.98; +% a2 = 8.75; +% g = 9.8; +% +% M = [v+a1+2*a2*cos(q2) a1+a2*cos(q2); +% a1+a2*cos(q2) a1]; +% Q = 50 * eye(4); +% +% +% k1 = 0.001; +% method = 1; +% +% % W权值的更新 +% if method == 1 % 自适应方法一 +% dw = gama * h * Input' * P * B; +% for i = 1:node*2 +% sys(i) = dw(i); +% end +% else % 自适应方法二 +% dw = gama * h * Input' * P * B + k1 * gama * norm(Input) * [W V]; +% for i = 1:node*2 +% sys(i) = dw(i); +% end +% end + + +function sys = mdlOutputs(t,x,u) %产生（传递）系统输出 +global c b kv kp +node = 5; +% 角度跟踪指令 +qd1 = u(1); +qd2 = u(2); +d_qd1 = u(3); +d_qd2 = u(4); +q1 = u(5); +q2 = u(6); +dq1 = u(7); +dq2 = u(8); +ddq1 = u(9); +ddq2 = u(10); +dd_qd1 = -0.1*pi*0.5*pi*sin(0.5*pi*t); +dd_qd2 = 0.1*pi*0.5*pi*cos(0.5*pi*t); +ddq = [ddq1; ddq2]; +dd_qd = [dd_qd1; dd_qd2]; + +e1 = q1 - qd1; % e = q - qd +e2 = q2 - qd2; +de1 = dq1 - d_qd1; +de2 = dq2 - d_qd2; +e = [e1; e2]; +de = [de1; de2]; + +% 参数的定义 +v = 13.33; +a1 = 8.98; +a2 = 8.75; +g = 9.8; + +M = [v+a1+2*a2*cos(q2) a1+a2*cos(q2); + a1+a2*cos(q2) a1]; +C = [-a2*dq2*sin(q2) -a2*(dq1 + dq2)*sin(q2); + a2*dq1*sin(q2) 0]; +G = [15*g*cos(q1)+8.75*g*cos(q1+q2); + 8.75*g*cos(q1+q2)]; + +dq = [dq1; dq2]; + +tol1 = M*(dd_qd - kv*de - kp*e) + C * dq + G; + +deltam = 0.2*M; +deltac = 0.2*C; +deltag = 0.2*G; + +d1 = 2; +d2 = 3; +d3 = 6; +d = d1 + d2 * norm([e1;e2]) + d3 * norm([de1; de2]); +f = inv(M) * (deltam * ddq + deltac * dq + deltag + d); + +Input = [e1; e2; de1; de2]; +h = zeros(node , 1); %5*1矩阵 +for i =1:node + h(i) = exp(-(norm(Input - c(:,i))^2) / (2*b^2)); +end + +W = [x(1) x(2) x(3) x(4) x(5); x(6) x(7) x(8) x(9) x(10)]'; +fn = W' * h; +tol2 = -M * fn; +tol = tol1 + tol2; + +sys(1) = tol(1); +sys(2) = tol(2); +sys(3) = f(1); +sys(4) = fn(1); +sys(5) = f(2); +sys(6) = fn(2); + + + + + + + + + + + + diff --git a/B2.m b/B2.m new file mode 100644 index 0000000..2fa9b67 --- /dev/null +++ b/B2.m @@ -0,0 +1,97 @@ +function [sys,x0,str,ts] = B2(t,x,u,flag) +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 %连续状态计算 + sys=mdlDerivatives(t,x,u); + case {2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag)); +end + +function [sys,x0,str,ts]=mdlInitializeSizes %系统的初始化 +sizes = simsizes; +sizes.NumContStates = 4; %设置系统连续状态的变量 +sizes.NumDiscStates = 0; %设置系统离散状态的变量 +sizes.NumOutputs = 4; %设置系统输出的变量 +sizes.NumInputs = 2; %设置系统输入的变量 +sizes.DirFeedthrough = 0; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = [0.6 0.3 0.5 0.5]; % 系统初始状态变量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 + + +function sys=mdlDerivatives(t,x,u) %该函数仅在连续系统中被调用，用于产生控制系统状态的导数 +persistent ddx1 ddx2 +if t == 0 + ddx1 = 0; + ddx2 = 0; +end +% 角度跟踪指令 +qd1 = 1+0.2*sin(0.5*pi*t); +qd2 = 1-0.2*cos(0.5*pi*t); +dqd1 = 0.1*pi*cos(0.5*pi*t); +dqd2 = 0.1*pi*sin(0.5*pi*t); + +e1 = x(1) - qd1; +e2 = x(3) - qd2; +de1 = x(2) - dqd1; +de2 = x(4) - dqd2; + +q1 = x(1); +q2 = x(3); +dq1 = x(2); +dq2 = x(4); + +% 参数的定义 +v = 13.33; +a1 = 8.98; +a2 = 8.75; +g = 9.8; + +M = [v+a1+2*a2*cos(q2) a1+a2*cos(q2); + a1+a2*cos(q2) a1]; +C = [-a2*dq2*sin(q2) -a2*(dq1 + dq2)*sin(q2); + a2*dq1*sin(q2) 0]; +G = [15*g*cos(q1)+8.75*g*cos(q1+q2); + 8.75*g*cos(q1+q2)]; +deltam = 0.2*M; +deltac = 0.2*C; +deltag = 0.2*G; + +d1 = 2; +d2 = 3; +d3 = 6; +d = d1 + d2 * norm([e1;e2]) + d3 * norm([de1; de2]); +tol(1) = u(1); %力矩1 +tol(2) = u(2); %力矩2 + +dq = [x(2); x(4)]; +ddq = [ddx1; ddx2]; +f = inv(M) * (deltam * ddq + deltac * dq + deltag + d); + +ddx = inv(M) * (tol' - C* dq - G) + f; + +sys(1) = x(2); +sys(2) = ddx(1); +sys(3) = x(4); +sys(4) = ddx(2); +ddx1 = ddx(1); +ddx2 = ddx(2); + + +function sys=mdlOutputs(t,x,u) %产生（传递）系统输出 +sys(1) = x(1); %q1 +sys(2) = x(2); %dq1 +sys(3) = x(3); %q2 +sys(4) = x(4); %dq2 + + + diff --git a/Book2221.asv b/Book2221.asv new file mode 100644 index 0000000..4d92958 --- /dev/null +++ b/Book2221.asv @@ -0,0 +1,65 @@ +function [sys,x0,str,ts] = Book2221(t,x,u,flag) +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case {1,2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag)); +end + +function [sys,x0,str,ts]=mdlInitializeSizes %系统的初始化 +sizes = simsizes; +sizes.NumContStates = 4; %设置系统连续状态的变量 +sizes.NumDiscStates = 0; %设置系统离散状态的变量 +sizes.NumOutputs = 1; %设置系统输出的变量 +sizes.NumInputs = 2; %设置系统输入的变量 +sizes.DirFeedthrough = 1; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = []; % 系统初始状态变量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 +% 权值初值的选择 +% 神经网络PID控制器 2-5-1结构 +global W C B e_new e_past e_past_past +C = [-1 -0.5 0 0.5 1; + -10 -5 0 5 10]; %2*5 中心矢量 +B = [1.5 1.5 1.5 1.5 1.5]; %1*5 基宽度参数 +W= rand(1,5); +e_new = 0; +e_past = e_new; +e_past_past = e_past; + + +function sys=mdlOutputs(t,x,u) %产生（传递）系统输出 +global W C B e_new e_past e_past_past +alpha = 0.05; %惯性系数 +xite = 0.5; %学习效率 +u_in = u(1); +y_out = u(2); +some = [u_in; y_out; y_error]; +h = zeros(5,1); +for j = 1:5 + h(j) = exp(-(norm((some - C(:,j)),2)/(2* B(j)^2))); %6*1矩阵 径向基函数 +end +% RBF的网络输出ym +ym = W * h; + +% 权值的调整 +for i = 1:5 + deltaW(i) = xite * (y_out - ym) * h(i); +end +for i = 1:5 + W(i) = W(i) + deltaW(i) + alpha*(W(i)) +end +% 更新值 + + + + + diff --git a/Book2221.slx b/Book2221.slx new file mode 100644 index 0000000..fca0bff Binary files /dev/null and b/Book2221.slx differ diff --git a/Book2221_controller.m b/Book2221_controller.m new file mode 100644 index 0000000..1683d7d --- /dev/null +++ b/Book2221_controller.m @@ -0,0 +1,69 @@ +function [sys,x0,str,ts] = Book2221_controller(t,x,u,flag) +% RBF神经网络自适应控制刘金琨例题2.2.2.1仿真 +% 基于梯度下降法的RBF神经网络逼近 +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case {1,2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag)); +end + +function [sys,x0,str,ts]=mdlInitializeSizes %系统的初始化 +sizes = simsizes; +sizes.NumContStates = 0; %设置系统连续状态的变量 +sizes.NumDiscStates = 0; %设置系统离散状态的变量 +sizes.NumOutputs = 1; %设置系统输出的变量 +sizes.NumInputs = 2; %设置系统输入的变量 +sizes.DirFeedthrough = 1; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = []; % 系统初始状态变量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 +% 权值初值的选择 +% 神经网络PID控制器 2-5-1结构 +global W_new W_past C B +C = [-1 -0.5 0 0.5 1; + -10 -5 0 5 10]; %2*5 中心矢量 +B = [1.5 1.5 1.5 1.5 1.5]; %1*5 基宽度参数 +W_new = rand(1,5); +W_past = W_new; + + +function sys = mdlOutputs(t,x,u) %产生（传递）系统输出 +global W_new W_past C B +alpha = 0.05; %惯性系数 +xite = 0.5; %学习效率 +u_in = u(1); +y_out = u(2); +some = [u_in; y_out]; +h = zeros(5,1); +for j = 1:5 + h(j) = exp(-norm(some - C(:,j))^2/(2 * B(j)^2)); %6*1矩阵 径向基函数 +end +% RBF的网络输出ym +ym = W_new * h; + +% 权值的调整 更新值 +deltaW_new = zeros(1,5); +for i = 1:5 + deltaW_new(i) = xite * (y_out - ym) * h(i); +end + +for i = 1:5 + W_new(i) = W_new(i) + deltaW_new(i) + alpha*(W_new(i) - W_past(i)); +end + +sys(1) = ym; + +W_past = W_new; + + + + diff --git a/Book2222.slx b/Book2222.slx new file mode 100644 index 0000000..7d239f8 Binary files /dev/null and b/Book2222.slx differ diff --git a/Book2222_controller.m b/Book2222_controller.m new file mode 100644 index 0000000..c9492da --- /dev/null +++ b/Book2222_controller.m @@ -0,0 +1,86 @@ +function [sys,x0,str,ts] = Book2222_controller(t,x,u,flag) +% 基于梯度下降法的RBF神经网络逼近 +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case {1,2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag)); +end + +function [sys,x0,str,ts]=mdlInitializeSizes %系统的初始化 +sizes = simsizes; +sizes.NumContStates = 0; %设置系统连续状态的变量 +sizes.NumDiscStates = 0; %设置系统离散状态的变量 +sizes.NumOutputs = 1; %设置系统输出的变量 +sizes.NumInputs = 2; %设置系统输入的变量 +sizes.DirFeedthrough = 1; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = []; % 系统初始状态变量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 +% 权值初值的选择 +% 神经网络PID控制器 2-5-1结构 +global W_new W_past C_new C_past B_new B_past +C_new = [-1 -0.5 0 0.5 1; + -10 -5 0 5 10]; %2*5 中心矢量 +C_past = C_new; +B_new = [3 3 3 3 3]; %1*5 基宽度参数 +B_past = B_new; +W_new = rand(1,5); %权值取0-1的随机值 +W_past = W_new; + + +function sys = mdlOutputs(t,x,u) %产生（传递）系统输出 +global W_new W_past C_new C_past B_new B_past +alpha = 0.05; %惯性系数 +xite = 0.15; %学习效率 +u_in = u(1); +y_out = u(2); +some = [u_in; y_out]; +h = zeros(5,1); +for j = 1:5 + h(j) = exp(-(norm(some - C_new(:,j))^2/(2* B_new(j)^2))); %5*1矩阵 径向基函数 +end +% RBF的网络输出ym +ym = W_new * h; + +% 权值的调整 更新值 +deltaW = zeros(1,5); +for i = 1:5 + deltaW(i) = xite * (y_out - ym) * h(i); +end +for i = 1:5 + W_new(i) = W_new(i) + deltaW(i) + alpha*(W_new(i) - W_past(i)); +end + +% 基宽带参数b的修正 +deltab = zeros(1,5); +for i = 1:5 + deltab(i) = xite * (y_out - ym) * W_new(i) * h(i) * (norm(some - C_new(:,i))^2 / B_new(i)^3); + B_new(i) = B_new(i) + deltab(i) + alpha*(B_new(i) - B_past(i)); +end + +% 中心矢量c的修正 +deltac = zeros(2,5); +for j = 1:2 + for i = 1:5 + deltac(j,i) = xite * (y_out - ym) * W_new(i) * h(i) * ((some(j) - C_new(j,i)) / B_new(i)^2); + C_new(j,i) = C_new(j,i) + deltac(j,i) + alpha*(C_new(j,i) - C_past(j,i)); + end +end + +sys(1) = ym; + +W_past = W_new; +B_past = B_new; +C_past = C_new; + + + diff --git a/Book321.slx b/Book321.slx new file mode 100644 index 0000000..580759a Binary files /dev/null and b/Book321.slx differ diff --git a/Book321_controller.m b/Book321_controller.m new file mode 100644 index 0000000..d77218d --- /dev/null +++ b/Book321_controller.m @@ -0,0 +1,104 @@ +function [sys,x0,str,ts] = Book321_controller(t,x,u,flag) +% RBF神经网络自适应控制刘金琨例题3.2.1仿真 +% 基于RBF神经网络的模型参考自适应控制 +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case {1,2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag)); +end + +function [sys,x0,str,ts]=mdlInitializeSizes %系统的初始化 +sizes = simsizes; +sizes.NumContStates = 0; %设置系统连续状态的变量 +sizes.NumDiscStates = 0; %设置系统离散状态的变量 +sizes.NumOutputs = 1; %设置系统输出的变量 +sizes.NumInputs = 3; %设置系统输入的变量 +sizes.DirFeedthrough = 1; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = []; % 系统初始状态变量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1 = -1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 +% 权值初值的选择 +% 神经网络PID控制器 2-7-1结构 +global W_new W_past C_new C_past B_new B_past yk_new yk_past ut_new ut_past some +C_new = [-3 -2 -1 0 1 2 3; + -3 -2 -1 0 1 2 3; + -3 -2 -1 0 1 2 3]; %3*7 中心矢量 +C_past = C_new; +B_new = [2 2 2 2 2 2 2]; %1*7 基宽度参数 +B_past = B_new; +% W_new = rand(1,7); %权值取0-1的随机值 +W_new = [-0.0316 -0.0421 -0.0318 0.0068 0.0454 -0.0381 -0.0381]; +W_past = W_new; +yk_new = 0; +yk_past = yk_new; +ut_new = 0; +ut_past = ut_new; +some = [0 0 0]'; + +function sys = mdlOutputs(t,x,u) %产生（传递）系统输出 +global W_new W_past C_new C_past B_new B_past yk_new yk_past ut_new ut_past some +% if t>0 +% 神经网络PID控制器 2-6-1结构 +alpha = 0.05; %惯性系数 +xite = 0.35; %学习效率 +IN = 3; +Mid = 7; +Out = 1; + +yd = u(1); +ec = u(2); +yk_new = u(3); + +h = zeros(Mid, 1); +for j = 1:Mid + h(j) = exp(-(norm(some - C_new(:,j))^2/(2* B_new(j)^2))); %7*1矩阵 径向基函数 +end +% RBF的网络输出ym +ut_new = W_new * h; +dyu = sign((yk_new - yk_past)/(ut_new - ut_past)); + +% 权值的调整 更新值 +deltaW = zeros(1,Mid); +for i = 1:Mid + deltaW(i) = xite * ec * dyu * h(i); +end +W_new = W_new + deltaW + alpha*(W_new - W_past); + +% 基宽带参数b的修正 +% deltab = zeros(1,Mid); +% for i = 1:Mid +% deltab(i) = xite * dyu * W_new(i) * h(i) * (norm(some - C_new(:,i))^2 / B_new(i)^3); +% B_new(i) = B_new(i) + deltab(i) + alpha*(B_new(i) - B_past(i)); +% end + +% 中心矢量c的修正 +% deltac = zeros(IN, Mid); +% for i = 1:IN +% for j = 1:Mid +% deltac(i,j) = xite * dyu * W_new(j) * h(j) * ((some(i) - C_new(i,j)) / B_new(j)^2); +% C_new(i,j) = C_new(i,j) + deltac(i,j) + alpha*(C_new(i,j) - C_past(i,j)); +% end +% end + +sys(1) = ut_new; +some = [u(1); u(2); u(3)]; +W_past = W_new; +B_past = B_new; +C_past = C_new; +ut_past = ut_new; +yk_past = yk_new; +% else +% sys(1) = ut_new; +% end + + + diff --git a/Book331.slx b/Book331.slx new file mode 100644 index 0000000..9feaf2c Binary files /dev/null and b/Book331.slx differ diff --git a/Book331.slx.r2016a b/Book331.slx.r2016a new file mode 100644 index 0000000..1aaa777 Binary files /dev/null and b/Book331.slx.r2016a differ diff --git a/Book331_Controller.m b/Book331_Controller.m new file mode 100644 index 0000000..d982d63 --- /dev/null +++ b/Book331_Controller.m @@ -0,0 +1,84 @@ +function [sys,x0,str,ts] = Book331_Controller(t,x,u,flag) +switch flag + case 0 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 + sys=mdlDerivatives(t,x,u); + case {2,4,9} + sys=[]; + case 3 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag)); +end + +function [sys,x0,str,ts]=mdlInitializeSizes %系统的初始化 +sizes = simsizes; +sizes.NumContStates = 0; %设置系统连续状态的变量 +sizes.NumDiscStates = 0; %设置系统离散状态的变量 +sizes.NumOutputs = 1; %设置系统输出的变量 +sizes.NumInputs = 2; %设置系统输入的变量 +sizes.DirFeedthrough = 1; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = []; % 系统初始状态变量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 +global W_past W_new V_new V_past c b ut_new ut_past +% 神经网络采用1-6-1结构 +W_new = [0.5; 0.5; 0.5; 0.5; 0.5; 0.5]; %6*1矩阵 +W_past = W_new; +V_new = [0.5; 0.5; 0.5; 0.5; 0.5; 0.5]; %6*1矩阵 +V_past = V_new; +c = [0.5 0.5 0.5 0.5 0.5 0.5]; +b = [5;5;5;5;5;5]; +ut_new = 0; +ut_past = ut_new; + +function sys=mdlOutputs(t,x,u) %产生（传递）系统输出 +global W_past W_new V_new V_past c b ut_new ut_past +% 神经网络采用1-6-1结构 +xitew = 0.15; %学习速率1 +xitev = 0.5; %学习速率2 +alfa = 0.05; %动量因子 +IN = 1; +Mid = 6; +Out = 1; +yd = u(1); +yk = u(2); + +some = [u(1); u(2)]; +h = zeros(1,6); %1*6矩阵 +for i =1:Mid + h(i) = exp(-(norm(yk - c(:,i))^2) / (2*b(i)^2)); +end +ut1 = h * W_new; +ut2 = h * V_new; + +ut_new = -(ut1/ut2) + (yd/ut2); +sys(1) = ut_new; + +% 权值的修正 +deltaw = zeros(6,1); +for i = 1:6 + deltaw(i) = xitew * (yk - yd) * h(i); +end +W_new = W_new + deltaw + alfa*(W_new - W_past); + +deltav = zeros(6,1); +for i = 1:6 + deltav(i) = xitev * (yk - yd) * h(i) * ut_new; +end +V_new = V_new + deltav + alfa*(V_new - V_past); + +W_past = W_new; +V_past = V_new; +ut_past = ut_new; + + + + + + diff --git a/Book4131.slx b/Book4131.slx new file mode 100644 index 0000000..526c665 Binary files /dev/null and b/Book4131.slx differ diff --git a/Book4131_Controller.m b/Book4131_Controller.m new file mode 100644 index 0000000..0491391 --- /dev/null +++ b/Book4131_Controller.m @@ -0,0 +1,83 @@ +function [sys,x0,str,ts] = Book4131_Controller(t,x,u,flag) +switch flag + case 0 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 + sys=mdlDerivatives(t,x,u); + case {2,4,9} + sys=[]; + case 3 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag)); +end + +function [sys,x0,str,ts]=mdlInitializeSizes %系统的初始化 +sizes = simsizes; +sizes.NumContStates = 0; %设置系统连续状态的变量 +sizes.NumDiscStates = 0; %设置系统离散状态的变量 +sizes.NumOutputs = 2; %设置系统输出的变量 +sizes.NumInputs = 2; %设置系统输入的变量 +sizes.DirFeedthrough = 1; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = []; % 系统初始状态变量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 +global W +% 神经网络采用2-5-1结构 IN = 2 MID = 5 OUT = 1 +% 初始权值 +W = [0 ; 0 ; 0 ; 0 ; 0]'; %MID * OUT矩阵 1*5 + +function sys = mdlOutputs(t,x,u) %产生（传递）系统输出 +global W +% 神经网络采用2-5-1结构 +IN = 2; +Mid = 5; +Out = 1; + +Q = [500 0; 0 500]; +kd = 50; +kp = 30; +gama = 1200; %gama为正常数 +b = 0.2; % 高斯函数的基宽 维度MID * 1 1*1 +c = [-2 -1 0 1 2; + -2 -1 0 1 2]; % 高斯函数的中心点矢量 维度 IN * MID 2*5 + +e = u(1); +de = u(2); + +some = [u(1); u(2)]; +h = zeros(Mid , 1); %5*1矩阵 +for i =1:Mid + h(i) = exp(-(norm(some - c(:,i))^2) / (2*b^2)); +end +fx_refer = W * h; +gx = 133; +ddyd = -0.1 * sin(t); %跟踪信号的二阶导数 +K = [kp ;kd]; +E = [e ; de]; + +% 控制率ut +ut = 1/(gx)*(-fx_refer + ddyd + K' * E); + +sys(1) = ut; +sys(2) = fx_refer; + +% 自适应律的设计 +fai = [0 1; -kp -kd]; +P = lyap(fai', Q); %P为对称正定矩阵且满足Lyapunov方程 +B = [0; 1]; +dw = zeros(1, 5); +for i = 1:5 + dw(i) = -gama * E' * P * B * h(i); % 1*1 * 1*2 * 2*2 *2*1 * 1*1 +end +dt = 0.001; % 仿真步长 +W = W + dw * dt; + + + + + diff --git a/Book4131_Plant.m b/Book4131_Plant.m new file mode 100644 index 0000000..bf9a3e8 --- /dev/null +++ b/Book4131_Plant.m @@ -0,0 +1,48 @@ +function [sys,x0,str,ts] = Book4131_Plant(t,x,u,flag) +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 %连续状态计算 + sys=mdlDerivatives(t,x,u); + case {2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', 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; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = [pi/60 0]; % 系统初始状态变量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 + + +function sys=mdlDerivatives(t,x,u) %该函数仅在连续系统中被调用，用于产生控制系统状态的导数 +ut = u(1); +th = x(1); +dth = x(2); + +some = -25 * dth + 133 * ut; + +sys(1) = x(2); +sys(2) = some; + + +function sys=mdlOutputs(t,x,u) %产生（传递）系统输出 +sys(1) = x(1); %x1 +sys(2) = x(2); %x2 + + + + diff --git a/Book4132.slx b/Book4132.slx new file mode 100644 index 0000000..bc109a0 Binary files /dev/null and b/Book4132.slx differ diff --git a/Book4132.slx.r2016a b/Book4132.slx.r2016a new file mode 100644 index 0000000..32de8a9 Binary files /dev/null and b/Book4132.slx.r2016a differ diff --git a/Book4132_Controller.m b/Book4132_Controller.m new file mode 100644 index 0000000..b83f9da --- /dev/null +++ b/Book4132_Controller.m @@ -0,0 +1,90 @@ +function [sys,x0,str,ts] = Book4132_Controller(t,x,u,flag) +switch flag + case 0 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 + sys=mdlDerivatives(t,x,u); + case {2,4,9} + sys=[]; + case 3 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag)); +end + +function [sys,x0,str,ts]=mdlInitializeSizes %系统的初始化 +sizes = simsizes; +sizes.NumContStates = 0; %设置系统连续状态的变量 +sizes.NumDiscStates = 0; %设置系统离散状态的变量 +sizes.NumOutputs = 2; %设置系统输出的变量 +sizes.NumInputs = 2; %设置系统输入的变量 +sizes.DirFeedthrough = 1; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = []; % 系统初始状态变量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 +global W +% 神经网络采用2-5-1结构 IN = 2 MID = 5 OUT = 1 +% 初始权值 +W = [0 ; 0 ; 0 ; 0 ; 0]'; %MID * OUT矩阵 1*5 + +function sys = mdlOutputs(t,x,u) %产生（传递）系统输出 +global W +% 神经网络采用2-5-1结构 +IN = 2; +Mid = 5; +Out = 1; + +Q = [500 0; 0 500]; +kd = 50; +kp = 30; +gama = 1200; %gama为正常数 +b = 0.2; % 高斯函数的基宽 维度MID * 1 1*1 +c = [-2 -1 0 1 2; + -2 -1 0 1 2]; % 高斯函数的中心点矢量 维度 IN * MID 2*5 + +e = u(1); +de = u(2); + +some = [u(1); u(2)]; +h = zeros(Mid , 1); %5*1矩阵 +for i =1:Mid + h(i) = exp(-(norm(some - c(:,i))^2) / (2*b^2)); +end +fx_refer = W * h; +% 参数的定义 +th = sin(t); +mc = 1; %小车质量 +m = 0.1; %摆的质量 +l = 0.5; +g_up = cos(th)/(mc+m); +g_down = l *(4/3 - m*(cos(th)^2)/(mc+m)); +gx = g_up / g_down; +ddyd = -0.1 * sin(t); %跟踪信号的二阶导数 +K = [kp ;kd]; +E = [e ; de]; + +% 控制率ut +ut = 1/(gx)*(-fx_refer + ddyd + K' * E); + +sys(1) = ut; +sys(2) = fx_refer; + +% 自适应律的设计 +fai = [0 1; -kp -kd]; +P = lyap(fai', Q); %P为对称正定矩阵且满足Lyapunov方程 +B = [0; 1]; +dw = zeros(1, 5); +for i = 1:5 + dw(i) = -gama * E' * P * B * h(i); % 1*1 * 1*2 * 2*2 *2*1 * 1*1 +end +dt = 0.001; % 仿真步长 +W = W + dw * dt; + + + + + diff --git a/Book4132_Plant.m b/Book4132_Plant.m new file mode 100644 index 0000000..ea3f3bc --- /dev/null +++ b/Book4132_Plant.m @@ -0,0 +1,60 @@ +function [sys,x0,str,ts] = Book4132_Plant(t,x,u,flag) +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 %连续状态计算 + sys=mdlDerivatives(t,x,u); + case {2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', 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; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = [pi/60 0]; % 系统初始状态变量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 + + +function sys=mdlDerivatives(t,x,u) %该函数仅在连续系统中被调用，用于产生控制系统状态的导数 +ut = u(1); +th = x(1); % 摆角 +dth = x(2); % 摆速 + +% 参数的定义 +g = 9.8; +mc = 1; %小车质量 +m = 0.1; %摆的质量 +l = 0.5; +f_up = g*sin(th) - m*l*dth^2*cos(th)*sin(th)/(mc+m); +f_down = l *(4/3 - m*(cos(th)^2)/(mc+m)); +f = f_up / f_down; +g_up = cos(th)/(mc+m); +g_down = l *(4/3 - m*(cos(th)^2)/(mc+m)); +g = g_up / g_down; + +some = f + g * ut; + +sys(1) = x(2); +sys(2) = some; + + +function sys=mdlOutputs(t,x,u) %产生（传递）系统输出 +sys(1) = x(1); %x1 +sys(2) = x(2); %x2 + + + + diff --git a/Book423.slx b/Book423.slx new file mode 100644 index 0000000..6639f70 Binary files /dev/null and b/Book423.slx differ diff --git a/Book423_Controller.m b/Book423_Controller.m new file mode 100644 index 0000000..8b8e219 --- /dev/null +++ b/Book423_Controller.m @@ -0,0 +1,101 @@ +function [sys,x0,str,ts] = Book423_Controller(t,x,u,flag) +switch flag + case 0 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 + sys=mdlDerivatives(t,x,u); + case {2,4,9} + sys=[]; + case 3 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag)); +end + +function [sys,x0,str,ts]=mdlInitializeSizes %系统的初始化 +sizes = simsizes; +sizes.NumContStates = 0; %设置系统连续状态的变量 +sizes.NumDiscStates = 0; %设置系统离散状态的变量 +sizes.NumOutputs = 2; %设置系统输出的变量 +sizes.NumInputs = 2; %设置系统输入的变量 +sizes.DirFeedthrough = 1; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = []; % 系统初始状态变量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 +global W m_0 +% 神经网络采用2-5-1结构 IN = 2 MID = 5 OUT = 1 +% 初始权值 +W = [0 ; 0 ; 0 ; 0 ; 0]'; %MID * OUT矩阵 1*5 +m_0 = 120; + +function sys = mdlOutputs(t,x,u) %产生（传递）系统输出 +global W m_0 +% 神经网络采用2-5-1结构 +b = 100; % 高斯函数的基宽 维度MID * 1 1*1 b的选择很重要 b越大 网路对输入的映射能力越大 +c = [-2 -1 0 1 2; + -2 -1 0 1 2]; % 高斯函数的中心点矢量 维度 IN * MID 2*5 +% 仿真中应根据网络输入值的有效映射范围来设计 c和b 从而保证有效的高斯映射 不合适的b或c均会导致结果不正确 +IN = 2; +Mid = 5; +Out = 1; + +Q = [500 0; 0 500]; +kd = 50; +kp = 30; +gama = 1200; %gama为正常数 +xite = 0.0001; +m = 100; + +e = u(1); +de = u(2); + +Input = [u(1); u(2)]; +h = zeros(Mid , 1); %5*1矩阵 +for i =1:Mid + h(i) = exp(-(norm(Input - c(:,i))^2) / (2*b^2)); +end +% fx的估计 +fx_refer = W * h; + +K = [kp ;kd]; +E = [e ; de]; +yd = sin(t); +dyd = cos(t); +ddyd = -sin(t); + +% 控制率ut +ut = 1/(m_0)*(-fx_refer + ddyd + K' * E); + +sys(1) = ut; +sys(2) = fx_refer; + +% 自适应律的设计 +fai = [0 1; -kp -kd]; +P = lyap(fai', Q); %P为对称正定矩阵且满足Lyapunov方程 +B = [0; 1]; +dw = zeros(1, 5); +for i = 1:5 + dw(i) = -gama * E' * P * B * h(i); % 1*1 * 1*2 * 2*2 *2*1 * 1*1 +end +dt = 0.001; % 仿真步长 +W = W + dw * dt; % W的自适应律 + +% m的估计律 +some = E' * P * B * ut; +if some > 0 + dm = 1/xite*some; +elseif some <= 0 && m_0 > m + dm = 1/xite*some; +else + dm = 1/xite; +end +m_0 = m_0 + dm * dt; % m的自适应律 + + + + + diff --git a/Book423_Plant.m b/Book423_Plant.m new file mode 100644 index 0000000..cc02bb9 --- /dev/null +++ b/Book423_Plant.m @@ -0,0 +1,47 @@ +function [sys,x0,str,ts] = Book423_Plant(t,x,u,flag) +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 %连续状态计算 + sys=mdlDerivatives(t,x,u); + case {2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', 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; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = [0.5 0]; % 系统初始状态变量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 + + +function sys = mdlDerivatives(t,x,u) %该函数仅在连续系统中被调用，用于产生控制系统状态的导数 +ut = u(1); +th = x(1); % 摆角 +dth = x(2); % 摆速 +dt = 100 * sin(t); + +sys(1) = x(2); +sys(2) = -25 * dth - 10 * th + 133 * ut + dt; + + +function sys = mdlOutputs(t,x,u) %产生（传递）系统输出 +sys(1) = x(1); %x1 +sys(2) = x(2); %x2 + + + + diff --git a/Book4341.slx b/Book4341.slx new file mode 100644 index 0000000..63cf7ff Binary files /dev/null and b/Book4341.slx differ diff --git a/Book4341_Controller.m b/Book4341_Controller.m new file mode 100644 index 0000000..6e2aef0 --- /dev/null +++ b/Book4341_Controller.m @@ -0,0 +1,88 @@ +function [sys,x0,str,ts] = Book4341_Controller(t,x,u,flag) +% 以下程序是 基于RBF神经网络的直接鲁棒自适应控制 +switch flag + case 0 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 + sys=mdlDerivatives(t,x,u); + case {2,4,9} + sys=[]; + case 3 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag)); +end + +function [sys,x0,str,ts]=mdlInitializeSizes %系统的初始化 +sizes = simsizes; +sizes.NumContStates = 0; %设置系统连续状态的变量 +sizes.NumDiscStates = 0; %设置系统离散状态的变量 +sizes.NumOutputs = 1; %设置系统输出的变量 +sizes.NumInputs = 4; %设置系统输入的变量 +sizes.DirFeedthrough = 1; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = []; % 系统初始状态变量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 +global W +% 神经网络采用5-9-1结构 IN = 5 MID = 9 OUT = 1 +% 初始权值 +W = [0 0 0 0 0 0 0 0 0]' ; %MID * OUT矩阵 9*1 + + +function sys = mdlOutputs(t,x,u) %产生（传递）系统输出 +global W +% 神经网络采用5-9-1结构 +b = 20; % 高斯函数的基宽 维度MID * 1 1*1 b的选择很重要 b越大 网路对输入的映射能力越大 +c = [-2 -1.5 -1 -0.5 0 0.5 1 1.5 2; + -2 -1.5 -1 -0.5 0 0.5 1 1.5 2; + -2 -1.5 -1 -0.5 0 0.5 1 1.5 2; + -2 -1.5 -1 -0.5 0 0.5 1 1.5 2; + -2 -1.5 -1 -0.5 0 0.5 1 1.5 2]; % 高斯函数的中心点矢量 维度 IN * MID 5*9 +% 仿真中应根据网络输入值的有效映射范围来设计 c和b 从而保证有效的高斯映射 不合适的b或c均会导致结果不正确 +IN = 5; +Mid = 9; +Out = 1; + +lambda = 5; +ita = 500 * eye(9); +xite = 0.005; +If = 0.25; + +e = -u(1); % e = x - xd; 实际-期望 +de = -u(2); +x_1 = u(3); +x_2 = u(4); +s = lambda * e + de; +s_if = s/If; + +yd = sin(t); +dyd = cos(t); +ddyd = -sin(t); + +v = -ddyd + lambda * de; + +Input = [x_1; x_2; s; s_if ; v]; +h = zeros(Mid , 1); %9*1矩阵 +for i =1:Mid + h(i) = exp(-(norm(Input - c(:,i))^2) / (2*b^2)); +end +% 控制率ut +belta = 150; +ut = 1/belta * W' * h; +sys(1) = ut; + +% W权值的更新 +dw = -ita * (h * s + xite * W); % 9*9 * (9*1 + 9*1) +dt = 0.001; % 仿真步长 +W = W + dw * dt; % W的自适应律 + + + + + + + diff --git a/Book4341_Plant.m b/Book4341_Plant.m new file mode 100644 index 0000000..c768bcc --- /dev/null +++ b/Book4341_Plant.m @@ -0,0 +1,48 @@ +function [sys,x0,str,ts] = Book4341_Plant(t,x,u,flag) +% 以下程序是 基于RBF神经网络的直接鲁棒自适应控制 +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 %连续状态计算 + sys=mdlDerivatives(t,x,u); + case {2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', 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; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = [0.5 0]; % 系统初始状态变量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 + + +function sys = mdlDerivatives(t,x,u) %该函数仅在连续系统中被调用，用于产生控制系统状态的导数 +ut = u(1); +th = x(1); % 摆角 +dth = x(2); % 摆速 +dt = 100 * sin(t); + +sys(1) = x(2); +sys(2) = -25 * dth + 133 * ut + dt; + + +function sys = mdlOutputs(t,x,u) %产生（传递）系统输出 +sys(1) = x(1); %x1 +sys(2) = x(2); %x2 + + + + diff --git a/Book4342.slx b/Book4342.slx new file mode 100644 index 0000000..81626d9 Binary files /dev/null and b/Book4342.slx differ diff --git a/Book4342_Controller.m b/Book4342_Controller.m new file mode 100644 index 0000000..3ecba3d --- /dev/null +++ b/Book4342_Controller.m @@ -0,0 +1,117 @@ +function [sys,x0,str,ts] = Book4342_Controller(t,x,u,flag) +% 以下程序是 基于RBF神经网络的直接鲁棒自适应控制 +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 %连续状态计算 + sys=mdlDerivatives(t,x,u); + case {2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag)); +end + +function [sys,x0,str,ts]=mdlInitializeSizes %系统的初始化 +global c b node If lamda W +W = [0 0 0 0 0 0 0 0 0 0 0 0 0]' ; %MID * OUT 矩阵 13*1 +node = 13; +If = 0.25; +lamda = 5; +sizes = simsizes; +sizes.NumContStates = node; %设置系统连续状态的变量 +sizes.NumDiscStates = 0; %设置系统离散状态的变量 +sizes.NumOutputs = 1; %设置系统输出的变量 +sizes.NumInputs = 3; %设置系统输入的变量 +sizes.DirFeedthrough = 1; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = zeros(1,13); % 系统初始状态变量 +% 神经网络采用5-9-1结构 +c = [-6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6; + -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6; + -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6; + -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6; + -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6]; % 高斯函数的中心点矢量 维度 IN * MID 5*13 +b = 5; % 高斯函数的基宽 维度MID * 1 1*1 b的选择很重要 b越大 网路对输入的映射能力越大 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 + + +function sys = mdlDerivatives(t,x,u) %该函数仅在连续系统中被调用，用于产生控制系统状态的导数 +global c b node If lamda W +% 仿真中应根据网络输入值的有效映射范围来设计 c和b 从而保证有效的高斯映射 不合适的b或c均会导致结果不正确 +IN = 5; +Mid = 13; +Out = 1; +yd = pi/6 * sin(t); +dyd = pi/6 * cos(t); +ddyd = -pi/6 * sin(t); + +% e = -u(1); % e = x - xd; 实际-期望 +% de = -u(2); +% x_1 = u(3); +% x_2 = u(4); +x1 = u(2); +x2 = u(3); +e = x1 - yd; +de = x2 - dyd; +s = lamda * e + de; +s_if = s/If; + +v = -ddyd + lamda * de; +Input = [x1; x2; s; s_if ; v]; +% Input = [x_1; x_2; s; s_if ; v]; +h = zeros(Mid , 1); %13*1矩阵 +for i =1:Mid + h(i) = exp(-(norm(Input - c(:,i))^2) / (2*b^2)); +end + +rou = 0.005; +Gama = 15 * eye(13); +W = [x(1); x(2); x(3); x(4); x(5); x(6); x(7); x(8); x(9); x(10); x(11); x(12); x(13)]; +S = -Gama * (h*s + rou*W); + +for i = 1:node + sys(i) = S(i); +end + + +function sys = mdlOutputs(t,x,u) %产生（传递）系统输出 +global c b node If lamda W +yd = pi/6 * sin(t); +dyd = pi/6 * cos(t); +ddyd = -pi/6 * sin(t); +x_1 = u(2); +x_2 = u(3); +e = x_1 - yd; % e = x - xd; 实际-期望 +de = x_2 - dyd; +s = lamda * e + de; +s_if = s/If; + +v = -ddyd + lamda * de; +Input = [x_1; x_2; s; s_if ; v]; +% Input = [x_1; x_2; s; s_if ; v]; +h = zeros(node , 1); %13*1矩阵 +for i =1:node + h(i) = exp(-(norm(Input - c(:,i))^2) / (2*b^2)); +end +W = [x(1); x(2); x(3); x(4); x(5); x(6); x(7); x(8); x(9); x(10); x(11); x(12); x(13)]; +belta = 1; +ut = 1/belta * W' * h; +sys(1) = ut; + + + + + + + + + + + + diff --git a/Book4342_Plant.m b/Book4342_Plant.m new file mode 100644 index 0000000..e04c2bd --- /dev/null +++ b/Book4342_Plant.m @@ -0,0 +1,53 @@ +function [sys,x0,str,ts] = Book4342_Plant(t,x,u,flag) +% 以下程序是 基于RBF神经网络的直接鲁棒自适应控制 +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 %连续状态计算 + sys=mdlDerivatives(t,x,u); + case {2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', 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; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = [0 0]; % 系统初始状态变量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 + + +function sys = mdlDerivatives(t,x,u) %该函数仅在连续系统中被调用，用于产生控制系统状态的导数 +ut = u(1); +th = x(1); % 摆角 +dth = x(2); % 摆速 +fx_up = 0.5*sin(th)*(1+0.5*cos(th))*dth^2 - 10*sin(th)*(1+cos(th)); +fx_down = 0.25*(2+cos(th))^2; +fx = fx_up / fx_down; +gx = 1 / (0.25*(2+cos(th))^2); +d1 = cos(3*t); +dt = 0.1 * d1 * cos(th); + +sys(1) = x(2); +sys(2) = fx + gx * ut + dt; + + +function sys = mdlOutputs(t,x,u) %产生（传递）系统输出 +sys(1) = x(1); %x1 +sys(2) = x(2); %x2 + + + + diff --git a/Book523.slx b/Book523.slx new file mode 100644 index 0000000..657d43d Binary files /dev/null and b/Book523.slx differ diff --git a/Book523_Controller.m b/Book523_Controller.m new file mode 100644 index 0000000..04132db --- /dev/null +++ b/Book523_Controller.m @@ -0,0 +1,119 @@ +function [sys,x0,str,ts] = Book523_Controller(t,x,u,flag) +% 以下程序是 基于RBF神经网络的直接鲁棒自适应控制 +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 %连续状态计算 + sys=mdlDerivatives(t,x,u); + case {2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag)); +end + +function [sys,x0,str,ts]=mdlInitializeSizes %系统的初始化 +sizes = simsizes; +sizes.NumContStates = 5; %设置系统连续状态的变量 +sizes.NumDiscStates = 0; %设置系统离散状态的变量 +sizes.NumOutputs = 2; %设置系统输出的变量 +sizes.NumInputs = 3; %设置系统输入的变量 +sizes.DirFeedthrough = 1; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = zeros(1,5); % 系统初始状态变量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 +global c b +% 神经网络采用2-5-1结构 +c = 0.1*[-1 -0.5 -0 0.5 1; + -1 -0.5 -0 0.5 1]; % 高斯函数的中心点矢量 维度 IN * MID 2*5 +b = 5; % 高斯函数的基宽 维度MID * 1 1*1 b的选择很重要 b越大 网路对输入的映射能力越大 + + +function sys = mdlDerivatives(t,x,u) %该函数仅在连续系统中被调用，用于产生控制系统状态的导数 +global c b gama +% 仿真中应根据网络输入值的有效映射范围来设计 c和b 从而保证有效的高斯映射 不合适的b或c均会导致结果不正确 +IN = 2; +Mid = 5; +Out = 1; +yd = 0.1 * sin(t); +dyd = 0.1 * cos(t); +ddyd = -0.1 * sin(t); + +c1 = 15; +gama = 0.015; +e = u(1); +de = u(2); + +s = c1 * e + de; + +Input = [e; de]; +% Input = [x_1; x_2; s; s_if ; v]; +h = zeros(Mid , 1); %5*1矩阵 +for i =1:Mid + h(i) = exp(-(norm(Input - c(:,i))^2) / (2*b^2)); +end +W = [x(1); x(2); x(3); x(4); x(5)]; +S = -1/gama * s * h; + +for i = 1:Mid + sys(i) = S(i); +end + + +function sys = mdlOutputs(t,x,u) %产生（传递）系统输出 +global c b +IN = 2; +Mid = 5; +Out = 1; +yd = 0.1 * sin(t); +dyd = 0.1 * cos(t); +ddyd = -0.1 * sin(t); +c1 = 15; + +e = u(1); +de = u(2); +th = u(3); + +s = c1 * e + de; + +Input = [e; de]; + +h = zeros(Mid , 1); %13*1矩阵 +for i =1:Mid + h(i) = exp(-(norm(Input - c(:,i))^2) / (2*b^2)); +end +W = [x(1); x(2); x(3); x(4); x(5)]; +fx = W' * h; + +% 参数的定义 +mc = 1; %小车质量 +m = 0.1; %摆的质量 +l = 0.5; +g_up = cos(th)/(mc+m); +g_down = l *(4/3 - m*(cos(th)^2)/(mc+m)); +g = g_up / g_down; +if t<=1.5 + xite = 1.0; +else + xite = 0.1; +end +ut = 1 / g * (-fx + ddyd + c1 * de + xite * sign(s)); +sys(1) = ut; +sys(2) = fx; + + + + + + + + + + + + diff --git a/Book523_Plant.m b/Book523_Plant.m new file mode 100644 index 0000000..09d6cad --- /dev/null +++ b/Book523_Plant.m @@ -0,0 +1,62 @@ +function [sys,x0,str,ts] = Book523_Plant(t,x,u,flag) +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 %连续状态计算 + sys=mdlDerivatives(t,x,u); + case {2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', 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; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = [pi/60 0]; % 系统初始状态变量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 + + +function sys=mdlDerivatives(t,x,u) %该函数仅在连续系统中被调用，用于产生控制系统状态的导数 +% 倒立摆状态方程 +ut = u(1); +% f = u(2); +th = x(1); % 摆角 +dth = x(2); % 摆速 + +% 参数的定义 +g = 9.8; +mc = 1; %小车质量 +m = 0.1; %摆的质量 +l = 0.5; +f_up = g*sin(th) - m*l*dth^2*cos(th)*sin(th)/(mc+m); +f_down = l *(4/3 - m*(cos(th)^2)/(mc+m)); +f = f_up / f_down; +g_up = cos(th)/(mc+m); +g_down = l *(4/3 - m*(cos(th)^2)/(mc+m)); +g = g_up / g_down; + +some = f + g * ut; + +sys(1) = x(2); +sys(2) = some; + + +function sys=mdlOutputs(t,x,u) %产生（传递）系统输出 +sys(1) = x(1); %x1 +sys(2) = x(2); %x2 + + + + diff --git a/Book532.slx b/Book532.slx new file mode 100644 index 0000000..1059390 Binary files /dev/null and b/Book532.slx differ diff --git a/Book532_Controller.m b/Book532_Controller.m new file mode 100644 index 0000000..c9bd4e7 --- /dev/null +++ b/Book532_Controller.m @@ -0,0 +1,157 @@ +function [sys,x0,str,ts] = Book532_Controller(t,x,u,flag) +% 以下程序是 基于RBF神经网络的直接鲁棒自适应控制 +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 %连续状态计算 + sys=mdlDerivatives(t,x,u); + case {2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag)); +end + +function [sys,x0,str,ts]=mdlInitializeSizes %系统的初始化 +sizes = simsizes; +sizes.NumContStates = 10; %设置系统连续状态的变量 +sizes.NumDiscStates = 0; %设置系统离散状态的变量 +sizes.NumOutputs = 4; %设置系统输出的变量 +sizes.NumInputs = 4; %设置系统输入的变量 +sizes.DirFeedthrough = 1; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = 0.1 * ones(10,1); % 系统初始状态变量 代表W和V向量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 +global c b +% 神经网络采用2-5-1结构 +c = 2*[-1 -0.5 -0 0.5 1; + -1 -0.5 -0 0.5 1]; % 高斯函数的中心点矢量 维度 IN * MID 2*5 +b = 10; % 高斯函数的基宽 维度MID * 1 1*1 b的选择很重要 b越大 网路对输入的映射能力越大 + + +function sys = mdlDerivatives(t,x,u) %该函数仅在连续系统中被调用，用于产生控制系统状态的导数 +global c b +% 仿真中应根据网络输入值的有效映射范围来设计 c和b 从而保证有效的高斯映射 不合适的b或c均会导致结果不正确 +IN = 2; +Mid = 5; +Out = 1; +yd = 0.1 * sin(t); +dyd = 0.1 * cos(t); +ddyd = -0.1 * sin(t); + +c1 = 5; +gama1 = 10; +gama2 = 10; +xite = 0.01; +x_1 = u(1); +x_2 = u(2); +e = u(3); +de = u(4); + +s = c1 * e + de; + +Input = [x_1; x_2]; +h = zeros(Mid , 1); %5*1矩阵 +for i =1:Mid + h(i) = exp(-(norm(Input - c(:,i))^2) / (2*b^2)); +end +W = [x(1); x(2); x(3); x(4); x(5)]; +fx = W' * h; +S1 = -gama1 * s * h; +for i = 1:5 + sys(i) = S1(i); +end +th = u(1); % 摆角 +dth = u(2); % 摆速 + +% 参数的定义 +g = 9.8; +mc = 1; %小车质量 +m = 0.1; %摆的质量 +l = 0.5; +f_up = g*sin(th) - m*l*dth^2*cos(th)*sin(th)/(mc+m); +f_down = l *(4/3 - m*(cos(th)^2)/(mc+m)); +f = f_up / f_down; + +V = [x(6); x(7); x(8); x(9); x(10)]; +gx = V' * h ; +ut = 1 / gx * (-f + ddyd + c1 * de + xite * sign(s)); +S2 = -gama2 * s * h * ut; +for i = 6:10 + sys(i) = S2(i - 5); +end + +function sys = mdlOutputs(t,x,u) %产生（传递）系统输出 +global c b +IN = 2; +Mid = 5; +Out = 1; +yd = 0.1 * sin(t); +dyd = 0.1 * cos(t); +ddyd = -0.1 * sin(t); +c1 = 15; + +x_1 = u(1); +x_2 = u(2); +e = u(3); +de = u(4); + +s = c1 * e + de; + +Input = [x_1; x_2]; + +h = zeros(Mid , 1); %13*1矩阵 +for i =1:Mid + h(i) = exp(-(norm(Input - c(:,i))^2) / (2*b^2)); +end +W = [x(1); x(2); x(3); x(4); x(5)]; +fx = W' * h; + +V = [x(6); x(7); x(8); x(9); x(10)]; +gx = V' * h ; + +th = x(1); % 摆角 +dth = x(2); % 摆速 + +% 参数的定义 +g = 9.8; +mc = 1; %小车质量 +m = 0.1; %摆的质量 +l = 0.5; +f_up = g*sin(th) - m*l*dth^2*cos(th)*sin(th)/(mc+m); +f_down = l *(4/3 - m*(cos(th)^2)/(mc+m)); +f = f_up / f_down; +g_up = cos(th)/(mc+m); +g_down = l *(4/3 - m*(cos(th)^2)/(mc+m)); +g = g_up / g_down; + +% if t<=1.5 +% xite = 1.0; +% else +% xite = 0.1; +% end + +xite = 1; +ut = 1 / gx * (-f + ddyd + c1 * de + xite * sign(s)); + +sys(1) = ut; +sys(2) = fx; +sys(3) = gx; +sys(4) = s; + + + + + + + + + + + + diff --git a/Book532_Plant.m b/Book532_Plant.m new file mode 100644 index 0000000..bc77e24 --- /dev/null +++ b/Book532_Plant.m @@ -0,0 +1,62 @@ +function [sys,x0,str,ts] = Book532_Plant(t,x,u,flag) +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 %连续状态计算 + sys=mdlDerivatives(t,x,u); + case {2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', 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; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = [pi/60 0]; % 系统初始状态变量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 + + +function sys=mdlDerivatives(t,x,u) %该函数仅在连续系统中被调用，用于产生控制系统状态的导数 +% 倒立摆状态方程 +ut = u(1); + +th = x(1); % 摆角 +dth = x(2); % 摆速 + +% 参数的定义 +g = 9.8; +mc = 1; %小车质量 +m = 0.1; %摆的质量 +l = 0.5; +f_up = g*sin(th) - m*l*dth^2*cos(th)*sin(th)/(mc+m); +f_down = l *(4/3 - m*(cos(th)^2)/(mc+m)); +f = f_up / f_down; +g_up = cos(th)/(mc+m); +g_down = l *(4/3 - m*(cos(th)^2)/(mc+m)); +g = g_up / g_down; + +some = f + g * ut; + +sys(1) = x(2); +sys(2) = some; + + +function sys=mdlOutputs(t,x,u) %产生（传递）系统输出 +sys(1) = x(1); %x1 +sys(2) = x(2); %x2 + + + + diff --git a/Book6141.slx b/Book6141.slx new file mode 100644 index 0000000..65000a6 Binary files /dev/null and b/Book6141.slx differ diff --git a/Book6141_2_Controller.m b/Book6141_2_Controller.m new file mode 100644 index 0000000..da121f3 --- /dev/null +++ b/Book6141_2_Controller.m @@ -0,0 +1,144 @@ +function [sys,x0,str,ts] = Book6141_2_Controller(t,x,u,flag) +% 以下程序是 基于RBF神经网络的直接鲁棒自适应控制 +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 %连续状态计算 + sys=mdlDerivatives(t,x,u); + case {2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag)); +end + +function [sys,x0,str,ts]=mdlInitializeSizes %系统的初始化 +global c b node +% 神经网络采用2-19-1结构 +node = 19; +c = 0.5 * [-4.5 -4 -3.5 -3 -2.5 -2 -1.5 -1 -0.5 0 0.5 1 1.5 2 2.5 3 3.5 4 4.5; + -4.5 -4 -3.5 -3 -2.5 -2 -1.5 -1 -0.5 0 0.5 1 1.5 2 2.5 3 3.5 4 4.5]; % 高斯函数的中心点矢量 维度 IN * MID 2*19 +b = 2 * ones(19,1); % 高斯函数的基宽 维度node * 1 19*1 b的选择很重要 b越大 网路对输入的映射能力越大 +sizes = simsizes; +sizes.NumContStates = node; %设置系统连续状态的变量 W +sizes.NumDiscStates = 0; %设置系统离散状态的变量 +sizes.NumOutputs = 3; %设置系统输出的变量 +sizes.NumInputs = 3; %设置系统输入的变量 +sizes.DirFeedthrough = 1; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = 0.1 * ones(node,1); % 系统初始状态变量 代表W和V向量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 + + +function sys = mdlDerivatives(t,x,u) %该函数仅在连续系统中被调用，用于产生控制系统状态的导数 +global c b node +% 仿真中应根据网络输入值的有效映射范围来设计 c和b 从而保证有效的高斯映射 不合适的b或c均会导致结果不正确 +IN = 2; +Out = 1; +qd = sin(t); +dqd = cos(t); +ddqd = -sin(t); + +qd = u(1); +q = u(2); % e = q - qd +dq = u(3); +e = q - qd; +de = dq - dqd; + +% 参数的定义 +M = 10; +gama = 1200; +alph = 3; +kp = alph^2; +kv = 2 * alph; +Q = [50 0; 0 50]; +A = [0 1; -kp -kv]; +P = lyap(A' , Q); +B = [0; 1/M]; +k1 = 0.001; + +Input = [e; de]; +h = zeros(node , 1); %19*1矩阵 +for i =1:node + h(i) = exp(-(norm(Input - c(:,i))^2) / (2*b(i)^2)); +end +W = [x(1:19)]'; %node*1 19*1 + +method = 1; +if method == 1 % 自适应方法一 + dw = gama * h * Input' * P * B; + for i = 1:node + sys(i) = dw(i); + end +else % 自适应方法二 + dw = gama * h * Input' * P * B + k1 * gama * norm(Input) * W; + for i = 1:node + sys(i) = dw(i); + end +end + + +function sys = mdlOutputs(t,x,u) %产生（传递）系统输出 +global c b node +IN = 2; +Out = 1; +qd = sin(t); +dqd = cos(t); +ddqd = -sin(t); + +qd = u(1); +q = u(2); % e = q - qd +dq = u(3); +e = q - qd; +de = dq - dqd; + +% 参数的定义 +M = 10; +gama = 1200; +alph = 3; +kp = alph^2; +kv = 2 * alph; +Q = [50 0; 0 50]; +A = [0 1; -kp -kv]; +P = lyap(A' , Q); +B = [0; 1/M]; +k1 = 0.001; + +Input = [e; de]; +h = zeros(node , 1); %5*1矩阵 +for i =1:node + h(i) = exp(-(norm(Input - c(:,i))^2) / (2*b(i)^2)); +end +W = [x(1:19)]; %node*1 19*1 +% 神经网络的输出 +fx = W' * h; +d = -15 * dq - 30 *sign(dq); + +some = 1; +if some == 1 + ut = M * (ddqd - kv*de - kp*e) - fx; +elseif some == 2 + ut = M * (ddqd - kv*de - kp*e) - d; +else + ut = M * (ddqd - kv*de - kp*e); +end +sys(1) = ut; +sys(2) = fx; +sys(3) = d; + + + + + + + + + + + + diff --git a/Book6141_Controller.m b/Book6141_Controller.m new file mode 100644 index 0000000..0ee56da --- /dev/null +++ b/Book6141_Controller.m @@ -0,0 +1,146 @@ +function [sys,x0,str,ts] = Book6141_Controller(t,x,u,flag) +% 以下程序是 基于RBF神经网络的直接鲁棒自适应控制 +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 %连续状态计算 + sys=mdlDerivatives(t,x,u); + case {2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag)); +end + +function [sys,x0,str,ts]=mdlInitializeSizes %系统的初始化 +global c b node +% 神经网络采用2-5-1结构 +node = 5; +c = 0.5 * [-2 -1 -0 1 2; + -2 -1 -0 1 2]; % 高斯函数的中心点矢量 维度 IN * MID 2*5 +b = 2 * ones(5,1); % 高斯函数的基宽 维度node * 1 5*1 b的选择很重要 b越大 网路对输入的映射能力越大 +sizes = simsizes; +sizes.NumContStates = node; %设置系统连续状态的变量 W +sizes.NumDiscStates = 0; %设置系统离散状态的变量 +sizes.NumOutputs = 3; %设置系统输出的变量 +sizes.NumInputs = 3; %设置系统输入的变量 +sizes.DirFeedthrough = 1; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = 0.1 * ones(node,1); % 系统初始状态变量 代表W和V向量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 + + +function sys = mdlDerivatives(t,x,u) %该函数仅在连续系统中被调用，用于产生控制系统状态的导数 +global c b node +% 仿真中应根据网络输入值的有效映射范围来设计 c和b 从而保证有效的高斯映射 不合适的b或c均会导致结果不正确 +IN = 2; +node = 5; +Out = 1; +qd = sin(t); +dqd = cos(t); +ddqd = -sin(t); + +qd = u(1); +q = u(2); % e = q - qd +dq = u(3); +e = q - qd; +de = dq - dqd; + +% 参数的定义 +M = 10; +gama = 1200; +alph = 3; +kp = alph^2; +kv = 2 * alph; +Q = [50 0; 0 50]; +A = [0 1; -kp -kv]; +P = lyap(A' , Q); +B = [0; 1/M]; +k1 = 0.001; + +Input = [e; de]; +h = zeros(node , 1); %5*1矩阵 +for i =1:node + h(i) = exp(-(norm(Input - c(:,i))^2) / (2*b(i)^2)); +end +W = [x(1); x(2); x(3); x(4); x(5)]; + +method = 1; +if method == 1 % 自适应方法一 + dw = gama * h * Input' * P * B; + for i = 1:node + sys(i) = dw(i); + end +else % 自适应方法二 + dw = gama * h * Input' * P * B + k1 * gama * norm(Input) * W; + for i = 1:node + sys(i) = dw(i); + end +end + + +function sys = mdlOutputs(t,x,u) %产生（传递）系统输出 +global c b node +IN = 2; +node = 5; +Out = 1; +qd = sin(t); +dqd = cos(t); +ddqd = -sin(t); + +qd = u(1); +q = u(2); % e = q - qd +dq = u(3); +e = q - qd; +de = dq - dqd; + +% 参数的定义 +M = 10; +gama = 1200; +alph = 3; +kp = alph^2; +kv = 2 * alph; +Q = [50 0; 0 50]; +A = [0 1; -kp -kv]; +P = lyap(A' , Q); +B = [0; 1/M]; +k1 = 0.001; + +Input = [e; de]; +h = zeros(node , 1); %5*1矩阵 +for i =1:node + h(i) = exp(-(norm(Input - c(:,i))^2) / (2*b(i)^2)); +end +W = [x(1); x(2); x(3); x(4); x(5)]; +% 神经网络的输出 +fx = W' * h; +d = -15 * dq - 30 *sign(dq); + +some = 1; +if some == 1 + ut = M * (ddqd - kv*de - kp*e) - fx; % RBF逼近未知干扰f +elseif some == 2 + ut = M * (ddqd - kv*de - kp*e) - d; +else + ut = M * (ddqd - kv*de - kp*e); +end +sys(1) = ut; +sys(2) = fx; +sys(3) = d; + + + + + + + + + + + + diff --git a/Book6141_Plant.m b/Book6141_Plant.m new file mode 100644 index 0000000..b50436c --- /dev/null +++ b/Book6141_Plant.m @@ -0,0 +1,51 @@ +function [sys,x0,str,ts] = Book6141_Plant(t,x,u,flag) +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 %连续状态计算 + sys=mdlDerivatives(t,x,u); + case {2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', 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; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = [0.6 0]; % 系统初始状态变量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 + + +function sys=mdlDerivatives(t,x,u) %该函数仅在连续系统中被调用，用于产生控制系统状态的导数 +ut = u(1); + +q = x(1); % 角度 +dq = x(2); % 角速度 + +% 参数的定义 +M = 10; +d = -15 * dq - 30 * sign(dq); + +sys(1) = x(2); +sys(2) = inv(M) * (ut + d); + + +function sys=mdlOutputs(t,x,u) %产生（传递）系统输出 +sys(1) = x(1); %x1 +sys(2) = x(2); %x2 + + + + diff --git a/Book6142.slx b/Book6142.slx new file mode 100644 index 0000000..faa4a78 Binary files /dev/null and b/Book6142.slx differ diff --git a/Book6142_Controller.m b/Book6142_Controller.m new file mode 100644 index 0000000..3222c98 --- /dev/null +++ b/Book6142_Controller.m @@ -0,0 +1,193 @@ +function [sys,x0,str,ts] = Book6142_Controller(t,x,u,flag) +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 %连续状态计算 + sys=mdlDerivatives(t,x,u); + case {2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag)); +end + +function [sys,x0,str,ts]=mdlInitializeSizes %系统的初始化 +global c b node +% 神经网络采用4 - 5 - 2结构 +node = 5; +c = 1 * [-2 -1 -0 1 2; + -2 -1 -0 1 2; + -2 -1 -0 1 2; + -2 -1 -0 1 2]; % 高斯函数的中心点矢量 维度 IN * MID 4*5 +b = 3 * ones(node,1); % 高斯函数的基宽 维度node * 1 5*1 b的选择很重要 b越大 网路对输入的映射能力越大 +sizes = simsizes; +sizes.NumContStates = node*2; %设置系统连续状态的变量 W V +sizes.NumDiscStates = 0; %设置系统离散状态的变量 +sizes.NumOutputs = 6; %设置系统输出的变量 +sizes.NumInputs = 8; %设置系统输入的变量 +sizes.DirFeedthrough = 1; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = 0.1 * ones(node*2,1); % 系统初始状态变量 代表W和V向量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 + + +function sys = mdlDerivatives(t,x,u) %该函数仅在连续系统中被调用，用于产生控制系统状态的导数 +global c b node +% 仿真中应根据网络输入值的有效映射范围来设计 c和b 从而保证有效的高斯映射 不合适的b或c均会导致结果不正确 +% 角度跟踪指令 +dqd1 = 0.1*pi*cos(0.5*pi*t); +dqd2 = 0.1*pi*sin(0.5*pi*t); + +qd1 = u(1); +qd2 = u(2); +q1 = u(3); +q2 = u(4); +dq1 = u(5); +dq2 = u(6); + +e1 = q1 - qd1; % e = q - qd +e2 = q2 - qd2; +de1 = dq1 - dqd1; +de2 = dq2 - dqd2; + +% 参数的定义 +v = 13.33; +a1 = 8.98; +a2 = 8.75; +g = 9.8; +gama = 20; +M = [v+a1+2*a2*cos(q2) a1+a2*cos(q2); + a1+a2*cos(q2) a1]; +alph = 3; +kp = [alph^2 0; 0 alph^2]; +kv = [2 * alph 0;0 2*alph]; +Q = 50 * eye(4); + +A = [zeros(2,2) eye(2,2); -kp -kv]; % 4*4 +P = lyap(A' , Q); % 4*4 +% B = [zeros(2,2); inv(M)]; % 4*2 +B = [0 0;0 0;1 0;0 1]; +k1 = 0.001; + +Input = [e1; e2; de1; de2]; +h = zeros(node , 1); %5*1矩阵 +for i =1:node + h(i) = exp(-(norm(Input - c(:,i))^2) / (2*b(i)^2)); +end +W = x(1:5); % 5*1 +V = x(6:10); + +method = 1; + +% W权值的更新 +if method == 1 % 自适应方法一 + dw = gama * h * Input' * P * B; + for i = 1:node*2 + sys(i) = dw(i); + end +else % 自适应方法二 + dw = gama * h * Input' * P * B + k1 * gama * norm(Input) * [W V]; + for i = 1:node*2 + sys(i) = dw(i); + end +end + + +function sys = mdlOutputs(t,x,u) %产生（传递）系统输出 +global c b node +% 角度跟踪指令 +ddqd1 = -0.1*pi*0.5*pi*sin(0.5*pi*t); +ddqd2 = 0.1*pi*0.5*pi*cos(0.5*pi*t); + +qd1 = u(1); +qd2 = u(2); +q1 = u(3); +q2 = u(4); +dq1 = u(5); +dq2 = u(6); +ddq1 = u(7); +ddq2 = u(8); +dqd1 = 0.1*pi*cos(0.5*pi*t); +dqd2 = 0.1*pi*sin(0.5*pi*t); +ddq = [ddq1; ddq2]; + +e1 = q1 - qd1; % e = q - qd +e2 = q2 - qd2; +de1 = dq1 - dqd1; +de2 = dq2 - dqd2; + +% 参数的定义 +v = 13.33; +a1 = 8.98; +a2 = 8.75; +g = 9.8; +d1 = 2; +d2 = 3; +d3 = 6; +alph = 3; +kp = [alph^2 0; 0 alph^2]; +kv = [2 * alph 0;0 2*alph]; + +M = [v+a1+2*a2*cos(q2) a1+a2*cos(q2); + a1+a2*cos(q2) a1]; +C = [-a2*dq2*sin(q2) -a2*(dq1 + dq2)*sin(q2); + a2*dq1*sin(q2) 0]; +G = [15*g*cos(q1)+8.75*g*cos(q1+q2); + 8.75*g*cos(q1+q2)]; +deltam = 0.2*M; +deltac = 0.2*C; +deltag = 0.2*G; + +Input = [e1; e2; de1; de2]; +h = zeros(node , 1); %5*1矩阵 +for i =1:node + h(i) = exp(-(norm(Input - c(:,i))^2) / (2*b(i)^2)); +end +W = x(1:5); % 5*1 +V = x(6:10); + +% 神经网络的输出 +fx1 = W' * h; +fx2 = V' * h; + +% 干扰 +d = d1 + d2 * norm([e1,e2]) + d3 * norm([de1, de2]); +ddqd = [ddqd1; ddqd2]; +e = [e1; e2]; +de = [de1; de2]; +q = [q1; q2]; +dq = [dq1; dq2]; +f = deltam * ddq + deltac * dq + deltag + d; + +some = 1; +if some == 1 + tau = M * (ddqd - kv*de - kp*e) + C * dq + G - M * [fx1; fx2]; % RBF逼近未知干扰f +elseif some == 2 + tau = M * (ddqd - kv*de - kp*e) + C * dq + G - f; % 精确补偿干扰项 +else + tau = M * (ddqd - kv*de - kp*e) + C * dq + G ; % 不补偿干扰项 +end + +sys(1) = tau(1); +sys(2) = tau(2); +sys(3) = fx1; +sys(4) = fx2; +sys(5) = f(1); +sys(6) = f(2); + + + + + + + + + + + + diff --git a/Book6142_Plant.m b/Book6142_Plant.m new file mode 100644 index 0000000..88ed27d --- /dev/null +++ b/Book6142_Plant.m @@ -0,0 +1,93 @@ +function [sys,x0,str,ts] = Book6142_Plant(t,x,u,flag) +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 %连续状态计算 + sys=mdlDerivatives(t,x,u); + case {2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag)); +end + +function [sys,x0,str,ts]=mdlInitializeSizes %系统的初始化 +sizes = simsizes; +sizes.NumContStates = 4; %设置系统连续状态的变量 +sizes.NumDiscStates = 0; %设置系统离散状态的变量 +sizes.NumOutputs = 4; %设置系统输出的变量 +sizes.NumInputs = 2; %设置系统输入的变量 +sizes.DirFeedthrough = 0; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = [0.6 0.3 0.5 0.5]; % 系统初始状态变量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 +global ddq1 ddq2 +ddq1 = 0; +ddq2 = 0; + +function sys=mdlDerivatives(t,x,u) %该函数仅在连续系统中被调用，用于产生控制系统状态的导数 +global ddq1 ddq2 +tau1 = u(1); %力矩1 +tau2 = u(2); %力矩2 + +q1 = x(1); % 关节角一 +q2 = x(2); % 关节角二 +dq1 = x(3); % 关节角速度一 +dq2 = x(4); % 关节角速度一 + +% 参数的定义 +v = 13.33; +a1 = 8.98; +a2 = 8.75; +g = 9.8; +d1 = 2; +d2 = 3; +d3 = 6; + +% 角度跟踪指令 +qd1 = 1+0.2*sin(0.5*pi*t); +qd2 = 1-0.2*cos(0.5*pi*t); +dqd1 = 0.1*pi*cos(0.5*pi*t); +dqd2 = 0.1*pi*sin(0.5*pi*t); + +M = [v+a1+2*a2*cos(q2) a1+a2*cos(q2); + a1+a2*cos(q2) a1]; +C = [-a2*dq2*sin(q2) -a2*(dq1 + dq2)*sin(q2); + a2*dq1*sin(q2) 0]; +G = [15*g*cos(q1)+8.75*g*cos(q1+q2); + 8.75*g*cos(q1+q2)]; +deltam = 0.2*M; +deltac = 0.2*C; +deltag = 0.2*G; +% 外部干扰 +e1 = q1 - qd1; +e2 = q2 - qd2; +de1 = dq1 - dqd1; +de2 = dq2 - dqd2; +ddq = [ddq1; ddq2]; + +d = d1 + d2 * norm([e1;e2]) + d3 * norm([de1; de2]); +f = deltam * ddq + deltac * [dq1; dq2] + deltag + d; +tau = [tau1; tau2]; + +ddq = inv(M) * (tau - C*[dq1; dq2] - G + f); + +sys(1) = x(3); +sys(2) = x(4); +sys(3) = ddq(1); +sys(4) = ddq(2); + + +function sys=mdlOutputs(t,x,u) %产生（传递）系统输出 +sys(1) = x(1); %q1 +sys(2) = x(2); %q2 +sys(3) = x(3); %dq1 +sys(4) = x(4); %dq2 + + + diff --git a/Book6241.slx b/Book6241.slx new file mode 100644 index 0000000..86283f8 Binary files /dev/null and b/Book6241.slx differ diff --git a/Book6241_Controller.m b/Book6241_Controller.m new file mode 100644 index 0000000..e48aeb2 --- /dev/null +++ b/Book6241_Controller.m @@ -0,0 +1,125 @@ +function [sys,x0,str,ts] = Book6241_Controller(t,x,u,flag) +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 %连续状态计算 + sys=mdlDerivatives(t,x,u); + case {2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag)); +end + +function [sys,x0,str,ts]=mdlInitializeSizes %系统的初始化 +global c b node +% 神经网络采用2 - 7 - 1结构 两个 2*7*1结构 tau1对应e1和de1 tau2对应e2和de2 +node = 7; +c = 1 * [-1.5 -1.0 -0.5 0 0.5 1 1.5; + -1.5 -1.0 -0.5 0 0.5 1 1.5]; % 高斯函数的中心点矢量 维度 IN * MID 2*7 +b = 10 * ones(node,1); % 高斯函数的基宽 维度node * 1 7*1 b的选择很重要 b越大 网路对输入的映射能力越大 +sizes = simsizes; +sizes.NumContStates = node; %设置系统连续状态的变量 W V +sizes.NumDiscStates = 0; %设置系统离散状态的变量 +sizes.NumOutputs = 2; %设置系统输出的变量 +sizes.NumInputs = 4; %设置系统输入的变量 +sizes.DirFeedthrough = 1; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = 0 * ones(node,1); % 系统初始状态变量 代表W和V向量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 + + +function sys = mdlDerivatives(t,x,u) %该函数仅在连续系统中被调用，用于产生控制系统状态的导数 +global c b node +% 仿真中应根据网络输入值的有效映射范围来设计 c和b 从而保证有效的高斯映射 不合适的b或c均会导致结果不正确 +% 角度跟踪指令 +% qd = sin(t); +dqd = cos(t); + +qd = u(1); +q = u(2); +dq = u(3); + +e = qd - q; % e = qd - q +de = dqd - dq; + +% 参数的定义 +kv = 110; +xite = 100; +ita = 15; + +input = [e; de]; +h = zeros(node , 1); %7*1矩阵 +for i =1:node + h(i) = exp(-(norm(input - c(:,i))^2) / (2*b(i)^2)); % 7*1 +end + +W = x(1:7); % 7*1 +s = de + ita * e; +% 权值的自适应律 +dw = ita * h * s'; +for i = 1:7 + sys(i) = dw(i); +end + + +function sys = mdlOutputs(t,x,u) %产生（传递）系统输出 +global c b node +% 角度跟踪指令 +% dqd1 = 0.1*cos(t); +% dqd2 = 0.1*cos(t); +% qd = sin(t); +dqd = cos(t); +ddqd = -sin(t); + +qd = u(1); +q = u(2); +dq = u(3); +ddq = u(4); + +e = qd - q; % e = qd - q +de = dqd - dq; + +% 参数的定义 +kv = 110; +xite = 100; +ita = 15; + +input = [e; de]; +h = zeros(node , 1); %7*1矩阵 +for i =1:node + h(i) = exp(-(norm(input - c(:,i))^2) / (2*b(i)^2)); % 7*1 +end +W = x(1:7); % 7*1 + +% 神经网络的输出 +fx = W' * h; + +tol = fx; +% 滑模面 +s = de + xite * e; +epn = 0.2; +bd = 0.1; +v = -(epn + bd)*sign(s); +tau = tol + kv * s - v; + +sys(1) = tau; +sys(2) = fx; + + + + + + + + + + + + + diff --git a/Book6241_Plant.m b/Book6241_Plant.m new file mode 100644 index 0000000..bd2841a --- /dev/null +++ b/Book6241_Plant.m @@ -0,0 +1,53 @@ +function [sys,x0,str,ts] = Book6241_Plant(t,x,u,flag) +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 %连续状态计算 + sys=mdlDerivatives(t,x,u); + case {2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', 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; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = [0.1 0]; % 系统初始状态变量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 + + +function sys=mdlDerivatives(t,x,u) %该函数仅在连续系统中被调用，用于产生控制系统状态的导数 +tau = u(1); %力矩1 + +q = x(1); % 关节角一 +dq = x(2); % 关节角速度一 + +% 参数的定义 +M = 10; +F = 15 * dq + 30*sign(dq); + +ddq = inv(M) * (tau - F); + +sys(1) = x(2); +sys(2) = ddq; + + +function sys=mdlOutputs(t,x,u) %产生（传递）系统输出 +sys(1) = x(1); %q1 +sys(2) = x(2); %dq1 + + + + diff --git a/Book6242.fis b/Book6242.fis new file mode 100644 index 0000000..76ef63b --- /dev/null +++ b/Book6242.fis @@ -0,0 +1,39 @@ +[System] +Name='Book6242' +Type='mamdani' +Version=2.0 +NumInputs=1 +NumOutputs=1 +NumRules=5 +AndMethod='min' +OrMethod='max' +ImpMethod='min' +AggMethod='max' +DefuzzMethod='centroid' + +[Input1] +Name='s*ds' +Range=[-10 10] +NumMFs=5 +MF1='NB':'gaussmf',[2.124 -10] +MF2='NM':'trimf',[-10 -5 0] +MF3='ZO':'trimf',[-5 0 5] +MF4='PM':'trimf',[0 5 10] +MF5='PB':'gaussmf',[2.124 10] + +[Output1] +Name='K' +Range=[-1 1] +NumMFs=5 +MF1='NB':'gaussmf',[0.2123 -1] +MF2='NM':'trimf',[-0.6667 -0.3333 0] +MF3='ZO':'trimf',[-0.3333 0 0.3333] +MF4='PM':'trimf',[4.78e-05 0.3333 0.6666] +MF5='PB':'gaussmf',[0.2123 1] + +[Rules] +1, 1 (1) : 1 +2, 2 (1) : 1 +3, 3 (1) : 1 +4, 4 (1) : 1 +5, 5 (1) : 1 diff --git a/Book6242.slx b/Book6242.slx new file mode 100644 index 0000000..91cbb30 Binary files /dev/null and b/Book6242.slx differ diff --git a/Book6242.slxc b/Book6242.slxc new file mode 100644 index 0000000..5db8212 Binary files /dev/null and b/Book6242.slxc differ diff --git a/Book6242_Controller.m b/Book6242_Controller.m new file mode 100644 index 0000000..d3214ea --- /dev/null +++ b/Book6242_Controller.m @@ -0,0 +1,173 @@ +function [sys,x0,str,ts] = Book6242_Controller(t,x,u,flag) +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 %连续状态计算 + sys=mdlDerivatives(t,x,u); + case {2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag)); +end + +function [sys,x0,str,ts]=mdlInitializeSizes %系统的初始化 +global c b node +% 神经网络采用4 - 7 - 2结构 +node = 7; +c = 1 * [-1.5 -1 -0.5 0 0.5 1 1.5; + -1.5 -1 -0.5 0 0.5 1 1.5]; % 高斯函数的中心点矢量 维度 IN * MID 2*7 +b = 10 * ones(node,1); % 高斯函数的基宽 维度node * 1 5*1 b的选择很重要 b越大 网路对输入的映射能力越大 +sizes = simsizes; +sizes.NumContStates = node*2; %设置系统连续状态的变量 W V +sizes.NumDiscStates = 0; %设置系统离散状态的变量 +sizes.NumOutputs = 6; %设置系统输出的变量 +sizes.NumInputs = 6; %设置系统输入的变量 +sizes.DirFeedthrough = 1; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = 0 * ones(node*2,1); % 系统初始状态变量 代表W和V向量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 + + +function sys = mdlDerivatives(t,x,u) %该函数仅在连续系统中被调用，用于产生控制系统状态的导数 +global c b node +% 仿真中应根据网络输入值的有效映射范围来设计 c和b 从而保证有效的高斯映射 不合适的b或c均会导致结果不正确 +% 角度跟踪指令 +qd1 = 0.1*sin(t); +qd2 = 0.1*sin(t); +dqd1 = 0.1*cos(t); +dqd2 = 0.1*cos(t); + +q1 = u(1); +q2 = u(2); +dq1 = u(3); +dq2 = u(4); + +e1 = qd1 - q1; % e = qd - q +e2 = qd2 - q2; +de1 = dqd1 - dq1; +de2 = dqd2 - dq2; + +% 参数的定义 +kv = [10 0; 0 10]; +ita = [15 0;0 15]; +xite1 = 5; +xite2 = 5; + +% 滑模函数 +s1 = de1 + xite1*e1; +s2 = de2 + xite2*e2; +s = [s1;s2]; + +Input1 = [e1;de1]; +hw = zeros(node, 1); %7*1矩阵 +for j = 1:node + hw(j) = exp(-(norm(Input1 - c(:,j))^2) / (b(j)^2)); +end + +Input2 = [e2;de2]; +hv = zeros(node, 1); %7*1矩阵 +for j = 1:node + hv(j) = exp(-(norm(Input2 - c(:,j))^2) / (b(j)^2)); +end + +W = x(1:node); % node*1 +V = x(node+1:2*node); + +% W权值的更新 +dw1 = ita(1)*hw*s(1); +dw2 = ita(4)*hv*s(2); +for i = 1:node + sys(i) = dw1(i); + sys(i+node) = dw2(i); +end + + +function sys = mdlOutputs(t,x,u) %产生（传递）系统输出 +global c b node +% 角度跟踪指令 +qd1 = 0.1*sin(t); +qd2 = 0.1*sin(t); +dqd1 = 0.1*cos(t); +dqd2 = 0.1*cos(t); + +q1 = u(1); +q2 = u(2); +dq1 = u(3); +dq2 = u(4); +K1 = u(5); +K2 = u(6); + +e1 = qd1 - q1; % e = qd - q +e2 = qd2 - q2; +de1 = dqd1 - dq1; +de2 = dqd2 - dq2; + +% 参数的定义 +kv = [20 0; 0 20]; +ita = [15 0;0 15]; +xite1 = 5; +xite2 = 5; +epc = 2; +bd = 2.1; + +% 滑模函数 +s1 = de1 + xite1*e1; +s2 = de2 + xite2*e2; + +d1 = norm(s1)/sqrt(xite1^2+1); +d2 = norm(s2)/sqrt(xite2^2+1); + +% 滑模函数 +s1 = de1 + xite1*e1; +s2 = de2 + xite2*e2; +s = [s1;s2]; + +Input1 = [e1;de1]; +hw = zeros(node, 1); %7*1矩阵 +for j = 1:node + hw(j) = exp(-(norm(Input1 - c(:,j))^2) / (b(j)^2)); +end + +Input2 = [e2;de2]; +hv = zeros(node, 1); %7*1矩阵 +for j = 1:node + hv(j) = exp(-(norm(Input2 - c(:,j))^2) / (b(j)^2)); +end + +W = x(1:node); % node*1 +V = x(node+1:2*node); + +% 神经网络的输出 +fx1 = W' * hw; +fx2 = V' * hv; +v = -(epc+bd)*sign(s); + +temp1 = (abs(K1)+1)*sign(s1); +temp2 = (abs(K2)+1)*sign(s2); +v_new = -[temp1; temp2]; + +tau = [fx1;fx2]+kv*s-v; + +sys(1) = tau(1); +sys(2) = tau(2); +sys(3) = fx1; +sys(4) = fx2; +sys(5) = s1; +sys(6) = s2; + + + + + + + + + + + diff --git a/Book6242_Plant.m b/Book6242_Plant.m new file mode 100644 index 0000000..eb32468 --- /dev/null +++ b/Book6242_Plant.m @@ -0,0 +1,75 @@ +function [sys,x0,str,ts] = Book6242_Plant(t,x,u,flag) +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 %连续状态计算 + sys=mdlDerivatives(t,x,u); + case {2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag)); +end + +function [sys,x0,str,ts]=mdlInitializeSizes %系统的初始化 +sizes = simsizes; +sizes.NumContStates = 4; %设置系统连续状态的变量 +sizes.NumDiscStates = 0; %设置系统离散状态的变量 +sizes.NumOutputs = 4; %设置系统输出的变量 +sizes.NumInputs = 2; %设置系统输入的变量 +sizes.DirFeedthrough = 0; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = [0.09 -0.09 0 0]; % 系统初始状态变量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 + + +function sys=mdlDerivatives(t,x,u) %该函数仅在连续系统中被调用，用于产生控制系统状态的导数 +tau1 = u(1); %力矩1 +tau2 = u(2); %力矩2 + +q1 = x(1); % 关节角一 +q2 = x(2); % 关节角二 +dq1 = x(3); % 关节角速度一 +dq2 = x(4); % 关节角速度一 + +% 参数的定义 +p1 = 2.9; +p2 = 0.76; +p3 = 0.87; +p4 = 3.04; +p5 = 0.87; +g = 9.8; + +M = [p1+p2+2*p3*cos(q2) p2+p3*cos(q2) + p2+p3*cos(q2) p2]; +C = [-p3*dq2*sin(q2) -p3*(dq1 + dq2)*sin(q2); + p3*dq1*sin(q2) 0]; +G = [p4*g*cos(q1)+p5*g*cos(q1+q2); + p5*g*cos(q1+q2)]; + +% 外部干扰 +F = [2*sign(dq1); 2*sign(dq2)]; +taud = [2*sin(t); 2*sin(t)]; +tau = [tau1; tau2]; + +ddq = inv(M) * (tau - C*[dq1; dq2] - G - F - taud); + +sys(1) = x(3); +sys(2) = x(4); +sys(3) = ddq(1); +sys(4) = ddq(2); + + +function sys=mdlOutputs(t,x,u) %产生（传递）系统输出 +sys(1) = x(1); %q1 +sys(2) = x(2); %q2 +sys(3) = x(3); %dq1 +sys(4) = x(4); %dq2 + + + diff --git a/Book6331.slx b/Book6331.slx new file mode 100644 index 0000000..b0978a0 Binary files /dev/null and b/Book6331.slx differ diff --git a/Book6331_Controller.m b/Book6331_Controller.m new file mode 100644 index 0000000..b42e3d5 --- /dev/null +++ b/Book6331_Controller.m @@ -0,0 +1,124 @@ +function [sys,x0,str,ts] = Book6331_Controller(t,x,u,flag) +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 %连续状态计算 + sys=mdlDerivatives(t,x,u); + case {2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag)); +end + +function [sys,x0,str,ts]=mdlInitializeSizes %系统的初始化 +global c b node +% 神经网络采用2 - 5 - 1结构 +node = 5; +c = 1 * [-1.0 -0.5 0 0.5 1 ; + -1.0 -0.5 0 0.5 1]; % 高斯函数的中心点矢量 维度 IN * MID 2*5 +b = 50 * ones(node,1); % 高斯函数的基宽 维度node * 1 7*1 b的选择很重要 b越大 网路对输入的映射能力越大 +sizes = simsizes; +sizes.NumContStates = node; %设置系统连续状态的变量 W V +sizes.NumDiscStates = 0; %设置系统离散状态的变量 +sizes.NumOutputs = 2; %设置系统输出的变量 +sizes.NumInputs = 4; %设置系统输入的变量 +sizes.DirFeedthrough = 1; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = 0 * ones(node,1); % 系统初始状态变量 代表W和V向量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 + + +function sys = mdlDerivatives(t,x,u) %该函数仅在连续系统中被调用，用于产生控制系统状态的导数 +global c b node +% 仿真中应根据网络输入值的有效映射范围来设计 c和b 从而保证有效的高斯映射 不合适的b或c均会导致结果不正确 +% 角度跟踪指令 +% qd = sin(t); +dqd = cos(t); + +qd = u(1); +q = u(2); +dq = u(3); + +e = q - qd; % e = q - qd +de = dq - dqd; + +% 参数的定义 +xite = 1000; +alpha = 200; +gama = 0.1; + +input = [e; de]; +h = zeros(node , 1); %7*1矩阵 +for i =1:node + h(i) = exp(-(norm(input - c(:,i))^2) / (2*b(i)^2)); % 7*1 +end + +W = x(1:node); % 5*1 +% 权值的自适应律 +x_2 = de + alpha * e; +dw = - xite * x_2 * h'; +for i = 1:node + sys(i) = dw(i); +end + + +function sys = mdlOutputs(t,x,u) %产生（传递）系统输出 +global c b node +% 角度跟踪指令 +% dqd1 = 0.1*cos(t); +% dqd2 = 0.1*cos(t); +% qd = sin(t); +dqd = cos(t); +ddqd = -sin(t); + +qd = u(1); +q = u(2); +dq = u(3); +ddq = u(4); + +e = q - qd; % e = q - qd +de = dq - dqd; + +% 参数的定义 +M = 1; +xite = 1000; +alpha = 200; +gama = 0.1; + +input = [e; de]; +h = zeros(node , 1); %5*1矩阵 +for i =1:node + h(i) = exp(-(norm(input - c(:,i))^2) / (2*b(i)^2)); % 5*1 +end +W = x(1:node); % 5*1 + +% 神经网络的输出 +fx = W' * h; +V = 0; +omiga = M * alpha * de + V * alpha * e; +x_2 = de + alpha * e; +ut = -omiga - 1/(2*gama*gama)*x_2 + W' * h - 1/2*x_2; +G = 0; +tau = ut + M*ddqd + V * dqd + G; + +sys(1) = tau; +sys(2) = fx; + + + + + + + + + + + + + diff --git a/Book6331_Plant.m b/Book6331_Plant.m new file mode 100644 index 0000000..0b42059 --- /dev/null +++ b/Book6331_Plant.m @@ -0,0 +1,64 @@ +function [sys,x0,str,ts] = Book6331_Plant(t,x,u,flag) +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 %连续状态计算 + sys=mdlDerivatives(t,x,u); + case {2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag)); +end + +function [sys,x0,str,ts]=mdlInitializeSizes %系统的初始化 +sizes = simsizes; +sizes.NumContStates = 2; %设置系统连续状态的变量 +sizes.NumDiscStates = 0; %设置系统离散状态的变量 +sizes.NumOutputs = 3; %设置系统输出的变量 +sizes.NumInputs = 1; %设置系统输入的变量 +sizes.DirFeedthrough = 0; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = [0 0]; % 系统初始状态变量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 + + +function sys=mdlDerivatives(t,x,u) %该函数仅在连续系统中被调用，用于产生控制系统状态的导数 +tau = u(1); %力矩1 + +q = x(1); % 关节角一 +dq = x(2); % 关节角速度一 + +% 参数的定义 +M = 1.0; +d = 150 * sign(dq) + 10 * dq; + +ddq = inv(M) * (tau - d); + +sys(1) = x(2); +sys(2) = ddq; + + +function sys=mdlOutputs(t,x,u) %产生（传递）系统输出 +tau = u(1); %力矩1 + +q = x(1); % 关节角一 +dq = x(2); % 关节角速度一 + +% 参数的定义 +M = 1.0; +d = 150 * sign(dq) + 10 * dq; + +ddq = inv(M) * (tau - d); +sys(1) = x(1); %q1 +sys(2) = x(2); %dq1 +sys(3) = d; + + + + diff --git a/Book6332.slx b/Book6332.slx new file mode 100644 index 0000000..1196eba Binary files /dev/null and b/Book6332.slx differ diff --git a/Book6332_Controller.m b/Book6332_Controller.m new file mode 100644 index 0000000..5dcc4f8 --- /dev/null +++ b/Book6332_Controller.m @@ -0,0 +1,173 @@ +function [sys,x0,str,ts] = Book6332_Controller(t,x,u,flag) +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 %连续状态计算 + sys=mdlDerivatives(t,x,u); + case {2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag)); +end + +function [sys,x0,str,ts]=mdlInitializeSizes %系统的初始化 +global c b node +% 神经网络采用4 - 7 - 2结构 一个 4*7*2结构 输入[e1 e2 de1 de2] 对应输出 [tau1 tau2] +node = 7; +c = 1 * [-1.5 -1.0 -0.5 0 0.5 1 1.5; + -1.5 -1.0 -0.5 0 0.5 1 1.5; + -1.5 -1.0 -0.5 0 0.5 1 1.5; + -1.5 -1.0 -0.5 0 0.5 1 1.5]; % 高斯函数的中心点矢量 维度 IN * MID 4*7 +b = 10 * ones(node,1); % 高斯函数的基宽 维度node * 1 7*1 b的选择很重要 b越大 网路对输入的映射能力越大 +sizes = simsizes; +sizes.NumContStates = node*2; %设置系统连续状态的变量 W V +sizes.NumDiscStates = 0; %设置系统离散状态的变量 +sizes.NumOutputs = 4; %设置系统输出的变量 +sizes.NumInputs = 8; %设置系统输入的变量 +sizes.DirFeedthrough = 1; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = 0 * ones(node*2,1); % 系统初始状态变量 代表W和V向量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 + + +function sys = mdlDerivatives(t,x,u) %该函数仅在连续系统中被调用，用于产生控制系统状态的导数 +global c b node +% 仿真中应根据网络输入值的有效映射范围来设计 c和b 从而保证有效的高斯映射 不合适的b或c均会导致结果不正确 +% 角度跟踪指令 +dqd1 = cos(t); +dqd2 = cos(t); + +qd1 = u(1); +qd2 = u(2); +q1 = u(3); +q2 = u(4); +dq1 = u(5); +dq2 = u(6); + +e1 = q1 - qd1; % e = qd - q +e2 = q2 - qd2; +de1 = dq1 - dqd1; +de2 = dq2 - dqd2; +e = [e1; e2]; +de = [de1 ; de2]; + +% 参数的定义 +xite = 1500; +alpha = 20; +gama = 0.05; + +input = [e; de]; +h = zeros(node , 1); %7*1矩阵 +for i =1:node + h(i) = exp(-(norm(input - c(:,i))^2) / (b(i)^2)); % 7*1 +end + +W = [x(1) x(2) x(3) x(4) x(5) x(6) x(7); + x(8) x(9) x(10) x(11) x(12) x(13) x(14)]'; % 7*2 + +x2_1 = de + alpha * e; + +% 权值的自适应律 +dw = -xite * x2_1 * h'; % +% dw = dw'; +for i = 1:node + sys(i) = dw(1,i); + sys(i+7) = dw(2,i); +end + + +function sys = mdlOutputs(t,x,u) %产生（传递）系统输出 +global c b node +% 角度跟踪指令 +% dqd1 = cos(t); +% dqd2 = cos(t); +ddqd1 = -sin(t); +ddqd2 = -sin(t); + +qd1 = u(1); +qd2 = u(2); +q1 = u(3); +q2 = u(4); +dq1 = u(5); +dq2 = u(6); +ddq1 = u(7); +ddq2 = u(8); +dqd1 = cos(t); +dqd2 = cos(t); +ddq = [ddq1; ddq2]; +ddqd = [ddqd1; ddqd2]; +dqd = [dqd1; dqd2]; + +e1 = q1 - qd1; % e = q - qd +e2 = q2 - qd2; +de1 = dq1 - dqd1; +de2 = dq2 - dqd2; +e = [e1; e2]; +de = [de1; de2]; + +% 参数的定义 +xite = 1500; +alpha = 20; +gama = 0.05; +m1 = 1; +m2 = 1.5; +r1 = 1; +r2 = 0.8; +M11 = (m1 + m2)*r1^2 + m2*r2^2 + 2*m2*r1*r2*cos(q2); +M12 = m2*r2^2 + m2*r1*r2*cos(q2); +M21 = M12; +M22 = m2 * r2^2; +V12 = m2*r1*sin(q2); +G1 = (m1+m2)*r1*cos(q2) + m2*r2*cos(q1+q2); +G2 = m2*r2*cos(q1+q2); + +M = [M11 M12; + M21 M22]; +V = [-V12*dq2 -V12*(dq1+dq2); + V12*q1 0]; +G = [G1; G2]; +D = [10*dq1 + 30*sign(dq1); 10*dq2 + 30*sign(dq2)]; + +input = [e; de]; +h = zeros(node , 1); %7*1矩阵 + +for i =1:node + h(i) = exp(-(norm(input - c(:,i))^2) / (b(i)^2)); % 7*1 +end +W = [x(1) x(2) x(3) x(4) x(5) x(6) x(7); + x(8) x(9) x(10) x(11) x(12) x(13) x(14)]'; % 7*2 + % 网络输出 +fx = W' * h; + +omiga = M * alpha * de + V * alpha * e; + +x2_1 = de + alpha * e; + +% 反馈控制律 +ut = -omiga - 1/(2*gama^2) * x2_1 + fx - 1/2*x2_1; + +tau = ut + M * ddqd + V * dqd + G; + +sys(1) = tau(1); +sys(2) = tau(2); +sys(3) = fx(1); +sys(4) = fx(2); + + + + + + + + + + + + + diff --git a/Book6332_Plant.m b/Book6332_Plant.m new file mode 100644 index 0000000..94981db --- /dev/null +++ b/Book6332_Plant.m @@ -0,0 +1,115 @@ +function [sys,x0,str,ts] = Book6332_Plant(t,x,u,flag) +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 %连续状态计算 + sys=mdlDerivatives(t,x,u); + case {2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag)); +end + +function [sys,x0,str,ts]=mdlInitializeSizes %系统的初始化 +sizes = simsizes; +sizes.NumContStates = 4; %设置系统连续状态的变量 +sizes.NumDiscStates = 0; %设置系统离散状态的变量 +sizes.NumOutputs = 6; %设置系统输出的变量 +sizes.NumInputs = 2; %设置系统输入的变量 +sizes.DirFeedthrough = 0; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = [0 0 0 0]; % 系统初始状态变量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 + + +function sys=mdlDerivatives(t,x,u) %该函数仅在连续系统中被调用，用于产生控制系统状态的导数 +% 角度跟踪指令 +% qd1 = sin(t); +% qd2 = sin(t); +% dqd1 = cos(t); +% dqd2 = cos(t); +tau1 = u(1); %力矩1 +tau2 = u(2); %力矩2 + +q1 = x(1); % 关节角一 +q2 = x(2); % 关节角二 +dq1 = x(3); % 关节角速度一 +dq2 = x(4); % 关节角速度一 +q = [q1; q2]; +dq = [dq1; dq2]; + +% 参数的定义 +m1 = 1; +m2 = 1.5; +r1 = 1; +r2 = 0.8; +M11 = (m1 + m2)*r1^2 + m2*r2^2 + 2*m2*r1*r2*cos(q2); +M12 = m2*r2^2 + m2*r1*r2*cos(q2); +M21 = M12; +M22 = m2 * r2^2; +V12 = m2*r1*sin(q2); +G1 = (m1+m2)*r1*cos(q2) + m2*r2*cos(q1+q2); +G2 = m2*r2*cos(q1+q2); + +M = [M11 M12; + M21 M22]; +V = [-V12*dq2 -V12*(dq1+dq2); + V12*q1 0]; +G = [G1; G2]; +D = [10*dq1 + 30*sign(dq1); 10*dq2 + 30*sign(dq2)]; + +tau = [tau1; tau2]; + +ddq = inv(M) * (tau - D - G - V*dq); + +sys(1) = x(3); +sys(2) = x(4); +sys(3) = ddq(1); +sys(4) = ddq(2); + + +function sys=mdlOutputs(t,x,u) %产生（传递）系统输出 +tau1 = u(1); %力矩1 +tau2 = u(2); %力矩2 + +q1 = x(1); % 关节角一 +q2 = x(2); % 关节角二 +dq1 = x(3); % 关节角速度一 +dq2 = x(4); % 关节角速度一 +q = [q1; q2]; +dq = [dq1; dq2]; + +% 参数的定义 +m1 = 1; +m2 = 1.5; +r1 = 1; +r2 = 0.8; +M11 = (m1 + m2)*r1^2 + m2*r2^2 + 2*m2*r1*r2*cos(q2); +M12 = m2*r2^2 + m2*r1*r2*cos(q2); +M21 = M12; +M22 = m2 * r2^2; +V12 = m2*r1*sin(q2); +G1 = (m1+m2)*r1*cos(q2) + m2*r2*cos(q1+q2); +G2 = m2*r2*cos(q1+q2); + +M = [M11 M12; + M21 M22]; +V = [-V12*dq2 -V12*(dq1+dq2); + V12*q1 0]; +G = [G1; G2]; +D = [10*dq1 + 30*sign(dq1); 10*dq2 + 30*sign(dq2)]; + +sys(1) = x(1); %q1 +sys(2) = x(2); %q2 +sys(3) = x(3); %dq1 +sys(4) = x(4); %dq2 +sys(5) = D(1); +sys(6) = D(2); + + diff --git a/Book7241.slx b/Book7241.slx new file mode 100644 index 0000000..c892425 Binary files /dev/null and b/Book7241.slx differ diff --git a/Book7241_Controller.m b/Book7241_Controller.m new file mode 100644 index 0000000..3e3848b --- /dev/null +++ b/Book7241_Controller.m @@ -0,0 +1,191 @@ +function [sys,x0,str,ts] = Book7241_Controller(t,x,u,flag) +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 %连续状态计算 + sys=mdlDerivatives(t,x,u); + case {2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag)); +end + +function [sys,x0,str,ts]=mdlInitializeSizes %系统的初始化 +global c1 b1 node c2 b2 c3 b3 s_new s_past inte_s +% 神经网络采用2 - 7 - 1结构 采用3个2*7*1 神经网络 +node = 7; +c1 = 1 * [-1.5 -1.0 -0.5 0 0.5 1 1.5; + -1.5 -1.0 -0.5 0 0.5 1 1.5]; % 高斯函数的中心点矢量 维度 IN * MID 2*7 +b1 = 20 * ones(node,1); % 高斯函数的基宽 维度node * 1 7*1 b的选择很重要 b越大 网路对输入的映射能力越大 +c2 = 1 * [-1.5 -1.0 -0.5 0 0.5 1 1.5; + -1.5 -1.0 -0.5 0 0.5 1 1.5]; +b2 = 20 * ones(node,1); +c3 = 1 * [-1.5 -1.0 -0.5 0 0.5 1 1.5; + -1.5 -1.0 -0.5 0 0.5 1 1.5]; +b3 = 20 * ones(node,1); +s_new = 0; +s_past = s_new; +inte_s = 0; +sizes = simsizes; +sizes.NumContStates = node*3; %设置系统连续状态的变量 W V +sizes.NumDiscStates = 0; %设置系统离散状态的变量 +sizes.NumOutputs = 4; %设置系统输出的变量 +sizes.NumInputs = 4; %设置系统输入的变量 +sizes.DirFeedthrough = 1; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = 0 * ones(node*3,1); % 系统初始状态变量 代表W和V向量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 + + +function sys = mdlDerivatives(t,x,u) %该函数仅在连续系统中被调用，用于产生控制系统状态的导数 +global c1 b1 node c2 b2 c3 b3 s_new s_past inte_s +% 仿真中应根据网络输入值的有效映射范围来设计 c和b 从而保证有效的高斯映射 不合适的b或c均会导致结果不正确 +% 角度跟踪指令 +% qd = sin(t); +dqd = cos(t); +ddqd = -sin(t); + +qd = u(1); +q = u(2); +dq = u(3); +ddq = u(4); + +e = qd - q; % e = qd - q +de = dqd - dq; +dde = ddqd - ddq; + +% 参数的定义 +kr = 0.1; +kp = 15; +kt = 15; +xite = 5.0; +gamam = 100; +gamac = 100; +gamag = 100; + +s_new = xite * e + de; +dqr = xite * e + dqd; +ddqr = xite * de + ddqd; + +% 神经网络的输入 +input = [q; dq]; +h1 = zeros(node , 1); %7*1矩阵 +h2 = zeros(node , 1); %7*1矩阵 +h3 = zeros(node , 1); %7*1矩阵 +for i =1:node + h1(i) = exp(-(norm(input - c1(:,i))^2) / (b1(i)^2)); % 7*1 +end +for i =1:node + h2(i) = exp(-(norm(input - c2(:,i))^2) / (b2(i)^2)); % 7*1 +end +for i =1:node + h3(i) = exp(-(norm(input - c3(:,i))^2) / (b3(i)^2)); % 7*1 +end + +W1 = x(1:node); % 7*1 +W2 = x(node+1: node*2); +W3 = x(node*2+1: node*3); + +% 权值的自适应律 +dw1 = gamam * h1 * ddqr * s_new; +dw2 = gamac * h2 * dqr * s_new; +dw3 = gamag * h3 * s_new; + +for i = 1:node + sys(i) = dw1(i); + sys(i+7) = dw2(i); + sys(i+14) = dw3(i); +end + + +function sys = mdlOutputs(t,x,u) %产生（传递）系统输出 +global c1 b1 node c2 b2 c3 b3 s_new s_past inte_s +% 角度跟踪指令 +% dqd1 = 0.1*cos(t); +% dqd2 = 0.1*cos(t); +% qd = sin(t); +dqd = cos(t); +ddqd = -sin(t); + +qd = u(1); +q = u(2); +dq = u(3); +ddq = u(4); + +e = qd - q; % e = qd - q +de = dqd - dq; +dde = ddqd - ddq; + +% 参数的定义 +kr = 0.1; +kp = 15; +ki = 15; +xite = 5.0; +gamam = 100; +gamac = 100; +gamag = 100; + +s_new = xite * e + de; +dqr = xite * e + dqd; +ddqr = xite * de + ddqd; + +% 神经网络的输入 +input = [q; dq]; +h1 = zeros(node , 1); %7*1矩阵 +h2 = zeros(node , 1); %7*1矩阵 +h3 = zeros(node , 1); %7*1矩阵 +for i =1:node + h1(i) = exp(-(norm(input - c1(:,i))^2) / (b1(i)^2)); % 7*1 +end +for i =1:node + h2(i) = exp(-(norm(input - c2(:,i))^2) / (b2(i)^2)); % 7*1 +end +for i =1:node + h3(i) = exp(-(norm(input - c3(:,i))^2) / (b3(i)^2)); % 7*1 +end + +W1 = x(1:node); % 7*1 +W2 = x(node+1: node*2); +W3 = x(node*2+1: node*3); + +% 神经网络的输出 +fx1 = W1' * h1; +fx2 = W2' * h2; +fx3 = W3' * h3; + +M_refer = fx1; +C_refer = fx2; +G_refer = fx3; + +% 名义模型控制律 +taum = M_refer*ddqr + C_refer*dqr + G_refer; +% 鲁棒项 +taur = kr*sign(s_new); +dt = 0.001; +inte_s = inte_s + (s_past + s_new)*dt/2; +tau = taum + kp*s_new + ki*inte_s + taur; + + +sys(1) = tau; +sys(2) = fx1; +sys(3) = fx2; +sys(4) = fx3; +s_past = s_new; + + + + + + + + + + + + diff --git a/Book7241_Plant.m b/Book7241_Plant.m new file mode 100644 index 0000000..03cfc04 --- /dev/null +++ b/Book7241_Plant.m @@ -0,0 +1,59 @@ +function [sys,x0,str,ts] = Book7241_Plant(t,x,u,flag) +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 %连续状态计算 + sys=mdlDerivatives(t,x,u); + case {2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', 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; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = [0.15 0]; % 系统初始状态变量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 + + +function sys=mdlDerivatives(t,x,u) %该函数仅在连续系统中被调用，用于产生控制系统状态的导数 +tau = u(1); %力矩1 + +q = x(1); % 关节角一 +dq = x(2); % 关节角速度一 + +% 参数的定义 +m = 0.02; +g = 9.8; +l = 0.05; +M = 0.1 + 0.06*sin(q); +C = 3*dq + 3*cos(dq); +G = m*g*l*cos(q); + +ddq = inv(M) * (tau - G - C*dq); + +sys(1) = x(2); +sys(2) = ddq; + + +function sys=mdlOutputs(t,x,u) %产生（传递）系统输出 + +sys(1) = x(1); %q1 +sys(2) = x(2); %dq1 + + + + + diff --git a/Book7242.slx b/Book7242.slx new file mode 100644 index 0000000..27737dc Binary files /dev/null and b/Book7242.slx differ diff --git a/Book7242.slxc b/Book7242.slxc new file mode 100644 index 0000000..2b3fec3 Binary files /dev/null and b/Book7242.slxc differ diff --git a/Book7242_Controller.m b/Book7242_Controller.m new file mode 100644 index 0000000..35ef848 --- /dev/null +++ b/Book7242_Controller.m @@ -0,0 +1,329 @@ +function [sys,x0,str,ts] = Book7242_Controller(t,x,u,flag) +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 %连续状态计算 + sys=mdlDerivatives(t,x,u); + case {2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag)); +end + +function [sys,x0,str,ts]=mdlInitializeSizes %系统的初始化 +global c_M b_M c_C b_C c_G b_G node s_new s_past inte_s +% 神经网络采用4 - 5 - 1结构 矩阵中每个值用一个W和h M11 -- W11'*h11 M12 -- W12'*h12 +node = 5; +c_M = 1 * [-1.0 -0.5 0 0.5 1; + -1.0 -0.5 0 0.5 1]; % 高斯函数的中心点矢量 维度 IN * MID 2*5 +b_M = 10 * ones(node,1); % 高斯函数的基宽 维度node * 1 7*1 b的选择很重要 b越大 网路对输入的映射能力越大 +c_C = [-1.0 -0.5 0 0.5 1; + -1.0 -0.5 0 0.5 1; + -1.0 -0.5 0 0.5 1; + -1.0 -0.5 0 0.5 1]; % 高斯函数的中心点矢量 维度 IN * MID 4*5 +b_C = 10 * ones(node,1); +c_G = 1 * [-1.0 -0.5 0 0.5 1; + -1.0 -0.5 0 0.5 1]; % 高斯函数的中心点矢量 维度 IN * MID 2*5 +b_G = 10 * ones(node,1); +s_new = [0; 0]; +s_past = s_new; +inte_s = [0; 0]; +sizes = simsizes; +sizes.NumContStates = node*10; %设置系统连续状态的变量 W V +sizes.NumDiscStates = 0; %设置系统离散状态的变量 +sizes.NumOutputs = 7; %设置系统输出的变量 +sizes.NumInputs = 12; %设置系统输入的变量 +sizes.DirFeedthrough = 1; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = 0 * ones(node*10,1); % 系统初始状态变量 代表W和V向量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 + + +function sys = mdlDerivatives(t,x,u) %该函数仅在连续系统中被调用，用于产生控制系统状态的导数 +global c_M b_M c_C b_C c_G b_G node s_new s_past inte_s +% 仿真中应根据网络输入值的有效映射范围来设计 c和b 从而保证有效的高斯映射 不合适的b或c均会导致结果不正确 +% 角度跟踪指令 +% qd1 = 0.5*sin(pi*t); +% qd2 = 0.5*sin(pi*t); +dqd1 = 0.5*pi*cos(pi*t); +dqd2 = 0.5*pi*cos(pi*t); +ddqd1 = -0.5*pi*pi*sin(pi*t); +ddqd2 = -0.5*pi*pi*sin(pi*t); + +qd1 = u(1); +qd2 = u(2); +q1 = u(3); +q2 = u(4); +dq1 = u(5); +dq2 = u(6); +ddq1 = u(7); +ddq2 = u(8); +ddq = [ddq1; ddq2]; + +e1 = qd1 - q1; % e = qd - q +e2 = qd2 - q2; +de1 = dqd1 - dq1; +de2 = dqd2 - dq2; +e = [e1; e2]; +de = [de1; de2]; +dq = [dq1; dq2]; +q = [q1; q2]; +dqd = [dqd1; dqd2]; +ddqd = [ddqd1; ddqd2]; +dde = ddqd - ddq; +% 参数的定义 +kp = 100*eye(2); +ki = 100*eye(2); +kr = 0.1*eye(2); +xite = 5.0*eye(2); +gamam = 5; +gamac = 10; +gamag = 10; + +s_new = xite * e + de; +% q = 3; +% p = 5; +% belta = 3; +% s1 = e1 + 1/belta*abs(de1)^(p/q)*sign(de1); +% s2 = e2 + 1/belta*abs(de2)^(p/q)*sign(de2); +% s_new = [s1; s2]; +dqr = s_new + dq; +ddqr = xite * de + dde + ddq; + +% 神经网络的输入 +input1 = [q1;q2]; +% ------------------------------------M矩阵的径向基函数 +h_M11 = zeros(node , 1); % 7*1 +h_M12 = zeros(node , 1); +h_M21 = zeros(node , 1); +h_M22 = zeros(node , 1); +for i =1:node + h_M11(i) = exp(-(norm(input1 - c_M(:,i))^2) / (b_M(i)^2)); % 7*1 + h_M12(i) = exp(-(norm(input1 - c_M(:,i))^2) / (b_M(i)^2)); % 7*1 + h_M21(i) = exp(-(norm(input1 - c_M(:,i))^2) / (b_M(i)^2)); % 7*1 + h_M22(i) = exp(-(norm(input1 - c_M(:,i))^2) / (b_M(i)^2)); % 7*1 +end +W_M11 = x(1:node); % 7*1 +W_M12 = x(node+1: node*2); +W_M21 = x(node*2+1: node*3); +W_M22 = x(node*3+1: node*4); + +% W_M权值的自适应律 +dw_M11 = gamam * h_M11 * ddqr(1) * s_new(1); +dw_M12 = gamam * h_M12 * ddqr(2) * s_new(1); +dw_M21 = gamam * h_M21 * ddqr(1) * s_new(2); +dw_M22 = gamam * h_M22 * ddqr(2) * s_new(2); + +for i = 1:node + sys(i) = dw_M11(i); + sys(i+node) = dw_M12(i); + sys(i+node*2) = dw_M21(i); + sys(i+node*3) = dw_M22(i); +end + +% ----------------------------------------C矩阵的径向基函数 +input2 = [q1;q2;dq1;dq2]; +h_C11 = zeros(node , 1); % 7*1 +h_C12 = zeros(node , 1); +h_C21 = zeros(node , 1); +h_C22 = zeros(node , 1); +for i =1:node + h_C11(i) = exp(-(norm(input2 - c_C(:,i))^2) / (b_C(i)^2)); % 7*1 + h_C12(i) = exp(-(norm(input2 - c_C(:,i))^2) / (b_C(i)^2)); % 7*1 + h_C21(i) = exp(-(norm(input2 - c_C(:,i))^2) / (b_C(i)^2)); % 7*1 + h_C22(i) = exp(-(norm(input2 - c_C(:,i))^2) / (b_C(i)^2)); % 7*1 +end +W_C11 = x(node*4+1:node*5); % 7*1 +W_C12 = x(node*5+1: node*6); +W_C21 = x(node*6+1: node*7); +W_C22 = x(node*7+1: node*8); + +% W_C权值的自适应律 +dw_C11 = gamac * h_C11 * dqr(1) * s_new(1); +dw_C12 = gamac * h_C12 * ddqr(2) * s_new(1); +dw_C21 = gamac * h_C21 * dqr(1) * s_new(2); +dw_C22 = gamac * h_C22 * ddqr(2) * s_new(2); + +for i = 1:node + sys(i+node*4) = dw_C11(i); + sys(i+node*5) = dw_C12(i); + sys(i+node*6) = dw_C21(i); + sys(i+node*7) = dw_C22(i); +end + +% ----------------------------------------G矩阵的径向基函数 +input3 = [q1;q2]; +h_G11 = zeros(node , 1); % 7*1 +h_G12 = zeros(node , 1); +for i =1:node + h_G11(i) = exp(-(norm(input3 - c_G(:,i))^2) / (b_G(i)^2)); % 7*1 + h_G12(i) = exp(-(norm(input3 - c_G(:,i))^2) / (b_G(i)^2)); % 7*1 +end +W_G11 = x(node*8+1:node*9); % 7*1 +W_G12 = x(node*9+1: node*10); + +% W_C权值的自适应律 +dw_G11 = gamag * h_G11 * s_new(1); +dw_G12 = gamag * h_G12 * s_new(2); + +for i = 1:node + sys(i+node*8) = dw_G11(i); + sys(i+node*9) = dw_G12(i); +end + +function sys = mdlOutputs(t,x,u) %产生（传递）系统输出 +global c_M b_M c_C b_C c_G b_G node s_new s_past inte_s +% 角度跟踪指令 +% qd1 = 0.5*sin(pi*t); +% qd2 = 0.5*sin(pi*t); +dqd1 = 0.5*pi*cos(pi*t); +dqd2 = 0.5*pi*cos(pi*t); +ddqd1 = -0.5*pi*pi*sin(pi*t); +ddqd2 = -0.5*pi*pi*sin(pi*t); + +qd1 = u(1); +qd2 = u(2); +q1 = u(3); +q2 = u(4); +dq1 = u(5); +dq2 = u(6); +ddq1 = u(7); +ddq2 = u(8); +ddq = [ddq1; ddq2]; + +e1 = qd1 - q1; % e = qd - q +e2 = qd2 - q2; +de1 = dqd1 - dq1; +de2 = dqd2 - dq2; +e = [e1; e2]; +de = [de1; de2]; +dq = [dq1; dq2]; +q = [q1; q2]; +dqd = [dqd1; dqd2]; +ddqd = [ddqd1; ddqd2]; +dde = ddqd - ddq; + +% 参数的定义 +kp = 100*eye(2); +ki = 100*eye(2); +xite = 5.0*eye(2); +gamam = 5; +gamac = 10; +gamag = 10; + +s_new = xite * e + de; +% q = 3; +% p = 5; +% belta = 3; +% s1 = e1 + 1/belta*abs(de1)^(p/q)*sign(de1); +% s2 = e2 + 1/belta*abs(de2)^(p/q)*sign(de2); +% s_new = [s1; s2]; +dqr = s_new + dq; +ddqr = xite * de + dde + ddq; + +% ------------------------------------M矩阵的径向基函数 +input1 = [q1;q2]; +h_M11 = zeros(node , 1); % 7*1 +h_M12 = zeros(node , 1); +h_M21 = zeros(node , 1); +h_M22 = zeros(node , 1); +for i =1:node + h_M11(i) = exp(-(norm(input1 - c_M(:,i))^2) / (b_M(i)^2)); % 7*1 + h_M12(i) = exp(-(norm(input1 - c_M(:,i))^2) / (b_M(i)^2)); % 7*1 + h_M21(i) = exp(-(norm(input1 - c_M(:,i))^2) / (b_M(i)^2)); % 7*1 + h_M22(i) = exp(-(norm(input1 - c_M(:,i))^2) / (b_M(i)^2)); % 7*1 +end +W_M11 = x(1:node); % 7*1 +W_M12 = x(node*1+1: node*2); +W_M21 = x(node*2+1: node*3); +W_M22 = x(node*3+1: node*4); + +% ----------------------------------------C矩阵的径向基函数 +input2 = [q1;q2;dq1;dq2]; +h_C11 = zeros(node , 1); % 5*1 +h_C12 = zeros(node , 1); +h_C21 = zeros(node , 1); +h_C22 = zeros(node , 1); +for i =1:node + h_C11(i) = exp(-(norm(input2 - c_C(:,i))^2) / (b_C(i)^2)); % 7*1 + h_C12(i) = exp(-(norm(input2 - c_C(:,i))^2) / (b_C(i)^2)); % 7*1 + h_C21(i) = exp(-(norm(input2 - c_C(:,i))^2) / (b_C(i)^2)); % 7*1 + h_C22(i) = exp(-(norm(input2 - c_C(:,i))^2) / (b_C(i)^2)); % 7*1 +end +W_C11 = x(node*4+1:node*5); % 5*1 +W_C12 = x(node*5+1: node*6); +W_C21 = x(node*6+1: node*7); +W_C22 = x(node*7+1: node*8); + +% ----------------------------------------G矩阵的径向基函数 +input3 = [q1;q2]; +h_G11 = zeros(node , 1); % 5*1 +h_G12 = zeros(node , 1); +for i =1:node + h_G11(i) = exp(-(norm(input3 - c_G(:,i))^2) / (b_G(i)^2)); % 7*1 + h_G12(i) = exp(-(norm(input3 - c_G(:,i))^2) / (b_G(i)^2)); % 7*1 +end +W_G11 = x(node*8+1:node*9); % 5*1 +W_G12 = x(node*9+1:node*10); + +% 神经网络的输出 +p1 = 2.9; +p2 = 0.76; +p3 = 0.87; +p4 = 3.04; +p5 = 0.87; +g = 9.8; +M = [p1+p2+2*p3*cos(q2) p2+p3*cos(q2); + p2+p3*cos(q2) p2]; +C = [-p3*dq2*sin(q2) -p3*(dq1+dq2)*sin(q2); + p3*dq1*sin(q2) 0]; +G = [p4*g*cos(q1)+p5*g*cos(q1+q2); + p5*g*cos(q1+q2)]; +fx1 = [W_M11'*h_M11 W_M12'*h_M12; W_M21'*h_M21 W_M22'*h_M22]; % 2*2 +fx2 = [W_C11'*h_C11 W_C12'*h_C12; W_C21'*h_C21 W_C22'*h_C22]; +fx3 = [W_G11'*h_G11; W_G12'*h_G12]; + +M_refer = fx1; +C_refer = fx2; +G_refer = fx3; + +% 名义模型控制律 +taum = M_refer*ddqr + C_refer*dqr + G_refer; +% 鲁棒项 +% kr = 21*eye(2); +% taur = kr*sign(s_new); + +taur = [(abs(u(9))+1)*sign(s_new(1)); (abs(u(10))+1)*sign(s_new(2))]; + +dt = 0.001; +inte_s = inte_s + (s_past + s_new)*dt/2; + +% inte_s = [u(11);u(12)]; + +tau = taum + kp*s_new + ki*inte_s + taur; + +sys(1) = tau(1); +sys(2) = tau(2); +sys(3) = norm(fx1); +sys(4) = norm(fx2); +sys(5) = norm(fx3); +sys(6) = s_new(1); +sys(7) = s_new(2); + +s_past = s_new; + + + + + + + + + + diff --git a/Book7242_Plant.m b/Book7242_Plant.m new file mode 100644 index 0000000..4b65ea4 --- /dev/null +++ b/Book7242_Plant.m @@ -0,0 +1,82 @@ +function [sys,x0,str,ts] = Book7242_Plant(t,x,u,flag) +switch flag + case 0 %初始化 + [sys,x0,str,ts]=mdlInitializeSizes; + case 1 %连续状态计算 + sys=mdlDerivatives(t,x,u); + case {2,4,9} %离散状态计算，下一步仿真时刻，终止仿真设定 + sys=[]; + case 3 %输出信号计算 + sys=mdlOutputs(t,x,u); + otherwise + DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag)); +end + +function [sys,x0,str,ts]=mdlInitializeSizes %系统的初始化 +sizes = simsizes; +sizes.NumContStates = 4; %设置系统连续状态的变量 +sizes.NumDiscStates = 0; %设置系统离散状态的变量 +sizes.NumOutputs = 4; %设置系统输出的变量 +sizes.NumInputs = 2; %设置系统输入的变量 +sizes.DirFeedthrough = 0; %如果在输出方程中显含输入变量u，则应该将本参数设置为1 +sizes.NumSampleTimes = 0; % 模块采样周期的个数 + % 需要的样本时间，一般为1. + % 猜测为如果为n，则下一时刻的状态需要知道前n个状态的系统状态 +sys = simsizes(sizes); +x0 = [0.09 -0.09 0 0]; % 系统初始状态变量 +str = []; % 保留变量，保持为空 +ts = []; % 采样时间[t1 t2] t1为采样周期，如果取t1=-1则将继承输入信号的采样周期；参数t2为偏移量，一般取为0 + + +function sys=mdlDerivatives(t,x,u) %该函数仅在连续系统中被调用，用于产生控制系统状态的导数 +tau1 = u(1); %力矩1 +tau2 = u(2); %力矩2 + +q1 = x(1); % 关节角一 +q2 = x(2); % 关节角二 +dq1 = x(3); % 关节角速度一 +dq2 = x(4); % 关节角速度一 +q = [q1; q2]; +dq = [dq1; dq2]; + +% 参数的定义 +p1 = 2.9; +p2 = 0.76; +p3 = 0.87; +p4 = 3.04; +p5 = 0.87; +g = 9.8; + +% 角度跟踪指令 +% qd1 = 0.5*sin(pi*t); +% qd2 = sin(pi*t); +% dqd1 = 0.5*pi*cos(pi*t); +% dqd2 = pi*cos(pi*t); +d = 10*(sin(10*x(1))+cos(x(2))); %干扰 +f = [0.02*sign(dq1);0.02*sign(dq2)]; +M = [p1+p2+2*p3*cos(q2) p2+p3*cos(q2); + p2+p3*cos(q2) p2]; +C = [-p3*dq2*sin(q2) -p3*(dq1+dq2)*sin(q2); + p3*dq1*sin(q2) 0]; +G = [p4*g*cos(q1)+p5*g*cos(q1+q2); + p5*g*cos(q1+q2)]; + +tau = [tau1; tau2]; + +ddq = inv(M) * (tau - C*dq - G - d - f); + +sys(1) = x(3); +sys(2) = x(4); +sys(3) = ddq(1); +sys(4) = ddq(2); + + +function sys=mdlOutputs(t,x,u) %产生（传递）系统输出 + +sys(1) = x(1); %q1 +sys(2) = x(2); %q2 +sys(3) = x(3); %dq1 +sys(4) = x(4); %dq2 + + +