基于模糊控制的统一混沌控制器Matlab编程的全部代码 模糊控制器的程序设计 及其运行后的仿真结果图
以下是一个简单的基于模糊控制的统一混沌控制器的 Matlab 代码，供参考：
clear all;
close all;
clc;
% 设计混沌电路时常用的参数值
a=7.8e-5;
b=1.25e-4;
c=0.85e-5;
d=2.75e-5;
x0=0.3; y0=0.6; z0=0.9; % 初值
% 设计混沌系统的微分方程
f=@(t,x)[(-b*x(1)-y(1)-z(1));
(a*x(2)+y(2));
(-c*x(3)+d*z(3)+(x(1)-z(1))*y(3))];
[t,y]=ode45(f,[0,20000],[x0,y0,z0]); % 数值求解微分方程得出混沌数据
figure(1)
subplot(311);plot(t,y(:,1));title('混沌吸引子变量X(t)');
subplot(312);plot(t,y(:,2));title('混沌吸引子变量Y(t)');
subplot(313);plot(t,y(:,3));title('混沌吸引子变量Z(t)');
% 设计模糊控制器
mffun=@(x)[1./(1+exp(-15*(x-1/3))),(1./(1+exp(-15*(x-1/2)))),(1./(1+exp(-15*(x-2/3))))]; % 设计模糊隶属函数
mfpar=[0,1/2,1]; % 模糊控制器的参数
deltaT=0.01; % 采样周期
err=zeros(100000,1); % 控制误差
ctrlout=zeros(100000,1); % 控制器输出
for k=3:length(t)
e=y(k-1,1)-y(k-2,1); % 计算控制误差
if abs(e)<=mfpar(1)/2 % 判断是否处于模糊集1中心
fuzout=[1,0,0];
elseif abs(e)>mfpar(1)/2 && abs(e)<=mfpar(2) % 判断是否处于模糊集2中心
fuzout=mffun((abs(e)-mfpar(1)/2)/(mfpar(2)-mfpar(1)/2));
elseif abs(e)>mfpar(2) && abs(e)<=(mfpar(2)+mfpar(3))/2 % 判断是否处于模糊集3中心
fuzout=mffun((abs(e)-(mfpar(2)+mfpar(1)))/((mfpar(2)+mfpar(3))/2-(mfpar(2)+mfpar(1))));
else % 处于模糊集4中心
fuzout=[0,0,1];
end
dctrl=fuzout*mfpar'*e; % 根据隶属度计算模糊控制器输出量
ctrlout(k)=ctrlout(k-1)+dctrl*deltaT; % 叠加历史控制器输出量
err(k)=e; % 保存历史控制误差
end
% 绘图
figure(2);
plot(t,err);
title('混沌系统的控制误差变化');
xlabel('时间 (s)');ylabel('控制误差');
grid on;
figure(3);
plot(t,ctrlout);
title('混沌系统的控制器输出量变化');
xlabel('时间 (s)');ylabel('控制器输出量');
grid on;
这段代码中，首先定义了一个三维的 Lorenz 混沌系统微分方程，并用 ode
.....................................................................
a=addrule(a,rulelist);
a=setfis(a,'DefuzzMethod','mom');
writefis(a,'fuzzpid');
a=readfis('fuzzpid');
%显示规则
showrule(a)
%%
%控制对象的设置
%采样时间
ts = 0.002;
%产生连续形式的传递函数
Gp = tf([16],[10,1.2,6]);
%产生离散形式的传递函数
Gpz = c2d(Gp,ts,'z');
%将传递函数转换为差分式子
[num,den] = tfdata(Gpz,'v');
%%
%控制算法初始参数
L = 100;
fai = 0.1;
F = 50;
%此变量分别保存误差，误差积分以及误差导数
Err = [0,0,0]';
%延迟变量
y_1 = 0;
y_2 = 0;
u_1 = 0;
u_2 = 0;
e_1 = 0;
ei = 0;
ed = 0;
%%
%迭代过程
Time = 1001;
u = zeros(1,Time);
Pk = L*ones(1,Time);
Ik = fai*ones(1,Time);
Dk = F*ones(1,Time);
M = 8;
Ed = 0.0;
Ecd = 0.0;
for i=0:1:M
for k=1:1:Time
%产生时间变量
time(k) = (k-1)*ts;
%给定轨迹输入
yd(k) = 8*sin(6*2*pi*k*ts);
%根据模糊规则，进行PID参数的更新
k_pid = evalfis([Ed,Ecd],a);
Pk(k) = L + k_pid(1);
Ik(k) = fai+ k_pid(2);
Dk(k) = F + k_pid(3);
%控制对象模型的输出
.......................................................................
%使用延迟程序起到存储器的功能
u2(k) = u(k);
e_1 = e(k);
y_2 = y_1;
y_1 = y(k);
u_2 = u_1;
u_1 = u2(k);
Ed = e(k);
Ecd = e(k)-e_1;
end
i=i+1;
end
figure;
subplot(311);
plot(time,yd,'b','linewidth',2);
xlabel('time(s)');
ylabel('yd');
legend('给定位移曲线');
axis([0,2,-12,12]);
subplot(312);
plot(time,y,'b','linewidth',2);
xlabel('time(s)');
ylabel('y');
legend('跟踪位移曲线');
axis([0,2,-12,12]);
subplot(313);
plot(time,yd-y,'r','linewidth',2);
xlabel('time(s)');
ylabel('error');
legend('误差曲线');
axis([0,2,-1,1]);
figure;
subplot(311);
plot(time,Pk,'b','linewidth',1);
xlabel('time(s)');
ylabel('L');
legend('参数L的模糊PID方式下的自适应变化');
subplot(312);
plot(time,Ik,'b','linewidth',1);
xlabel('time(s)');
ylabel('fai');
legend('参数fai的模糊PID方式下的自适应变化');
subplot(313);
plot(time,Dk,'b','linewidth',1);
xlabel('time(s)');
ylabel('F');
legend('参数F的模糊PID方式下的自适应变化');
figure;
subplot(321);plotmf(a,'input',1); title('E隶属函数变化');
subplot(322);plotmf(a,'input',2); title('Ec隶属函数变化');
subplot(323);plotmf(a,'output',1); title('L隶属函数变化');
subplot(324);plotmf(a,'output',2); title('fai隶属函数变化');
subplot(325);plotmf(a,'output',3); title('F隶属函数变化');
figure;
plotfis(a);
08_027_m
提供参考实例：https://blog.csdn.net/hlayumi1234567/article/details/128540062
以下是基于模糊控制的统一混沌控制器Matlab编程的全部代码，包括模糊控制器的程序设计部分：
% 基于模糊控制的统一混沌控制器Matlab编程
% 定义混沌系统
function dx = chaotic_system(t, x, u)
% 系统参数
a = 10;
b = 8/3;
c = 28;
% 系统方程
dx = [a * (x(2) - x(1)); x(1) * (c - x(3)) - x(2); x(1) * x(2) - b * x(3)] + u;
end
% 定义模糊控制器
function u = fuzzy_controller(x, e, de, E, DE)
% 模糊控制器参数
P = [-1.5 -1 -0.5 0 0.5 1 1.5];
Q = [-1.5 -1 -0.5 0 0.5 1 1.5];
R = [-1 -0.5 0 0.5 1];
S = [-1 -0.5 0 0.5 1];
% 模糊控制器输入
p = findmf(P, e, E);
q = findmf(Q, de, DE);
% 模糊控制器输出
r = zeros(size(R));
s = zeros(size(S));
for i = 1:length(R)
r(i) = gaussmf(R(i), [0.5 0]);
end
for i = 1:length(S)
s(i) = gaussmf(S(i), [0.5 0]);
end
% 模糊推理
rule = zeros(length(R), length(S));
for i = 1:length(R)
for j = 1:length(S)
rule(i, j) = min(r(i), s(j));
end
end
% 模糊输出
u = zeros(size(x));
for i = 1:length(x)
u(i) = defuzz(R, S, rule, p, q, i);
end
end
% 定义模糊控制器辅助函数
function mf = gaussmf(x, params)
mf = exp(-(x - params(1))^2 / (2 * params(2)^2));
end
function index = findmf(MF, x, E)
index = 1;
for i = 1:length(MF)
if x >= MF(i)
index = i;
end
end
if x <= MF(1) || x >= MF(end)
index = 1;
end
if abs(x - E) < abs(MF(index) - E)
index = index - 1;
end
end
function u = defuzz(R, S, rule, p, q, i)
w = zeros(length(R) * length(S), 1);
v = zeros(length(R) * length(S), 1);
k = 1;
for r = 1:length(R)
for s = 1:length(S)
w(k) = rule(r, s);
v(k) = R(r) + S(s);
k = k + 1;
end
end
u = sum(w .* v) / sum(w);
if isnan(u)
u = 0;
end
if u < -1
u = -1;
end
if u > 1
u = 1;
end
end
% 主程序
% 初始化混沌系统和模糊控制器
x0 = [1; 0; 0];
tspan = [0 100];
u0 = [0; 0; 0];
[t, x] = ode45(@(t, x) chaotic_system(t, x, u0), tspan, x0);
e0 = 0;
de0 = 0;
E0 = 0;
DE0 = 0;
% 模拟控制过程
for i = 1:length(t)
% 计算误差和误差变化率
e = x(i, 1) - x(i, 2);
de = e - e0;
% 计算控制量
u = fuzzy_controller(x(i, :)', e, de, E0, DE0);
% 更新控制量和误差
u0 = u;
e0 = e;
de0 = de;
E0 = e;
DE0 = de;
% 更新混沌系统
[t, x1] = ode45(@(t, x) chaotic_system(t, x, u), [t(i) t(i+1)], x(i, :));
x(i+1, :) = x1(end, :);
end
% 绘制混沌系统输出和控制量
figure;
plot(t, x(:, 1), 'b', t, x(:, 2), 'r');
xlabel('Time');
ylabel('Output');
legend('x_1', 'x_2');
figure;
plot(t, u(:, 1), 'b', t, u(:, 2), 'r', t, u(:, 3), 'g');
xlabel('Time');
ylabel('Control');
legend('u_1', 'u_2', 'u_3');
% 定义输入变量
x1 = linspace(-10, 10, 100);
x2 = linspace(-10, 10, 100);
% 定义输出变量
y = linspace(-10, 10, 100);
% 定义模糊控制器
fis = newfis('fis', 'mamdani', 'min', 'max', 'min', 'max', 'centroid');
% 定义输入变量及其隶属度函数
fis = addvar(fis, 'input', 'x1', [-10, 10]);
fis = addmf(fis, 'input', 1, 'NB', 'trimf', [-10, -10, -5]);
fis = addmf(fis, 'input', 1, 'NM', 'trimf', [-10, -5, 0]);
fis = addmf(fis, 'input', 1, 'NS', 'trimf', [-5, 0, 5]);
fis = addmf(fis, 'input', 1, 'ZO', 'trimf', [0, 5, 10]);
fis = addmf(fis, 'input', 1, 'PS', 'trimf', [5, 10, 15]);
fis = addmf(fis, 'input', 1, 'PM', 'trimf', [10, 15, 20]);
fis = addmf(fis, 'input', 1, 'PB', 'trimf', [15, 20, 20]);
fis = addvar(fis, 'input', 'x2', [-10, 10]);
fis = addmf(fis, 'input', 2, 'NB', 'trimf', [-10, -10, -5]);
fis = addmf(fis, 'input', 2, 'NM', 'trimf', [-10, -5, 0]);
fis = addmf(fis, 'input', 2, 'NS', 'trimf', [-5, 0, 5]);
fis = addmf(fis, 'input', 2, 'ZO', 'trimf', [0, 5, 10]);
fis = addmf(fis, 'input', 2, 'PS', 'trimf', [5, 10, 15]);
fis = addmf(fis, 'input', 2, 'PM', 'trimf', [10, 15, 20]);
fis = addmf(fis, 'input', 2, 'PB', 'trimf', [15, 20, 20]);
% 定义输出变量及其隶属度函数
fis = addvar(fis, 'output', 'y', [-10, 10]);
fis = addmf(fis, 'output', 1, 'NB', 'trimf', [-10, -10, -5]);
fis = addmf(fis, 'output', 1, 'NM', 'trimf', [-10, -5, 0]);
fis = addmf(fis, 'output', 1, 'NS', 'trimf', [-5, 0, 5]);
fis = addmf(fis, 'output', 1, 'ZO', 'trimf', [0, 5, 10]);
fis = addmf(fis, 'output', 1, 'PS', 'trimf', [5, 10, 15]);
fis = addmf(fis, 'output', 1, 'PM', 'trimf', [10, 15, 20]);
fis = addmf(fis, 'output', 1, 'PB', 'trimf', [15, 20, 20]);
基于模糊控制的统一混沌控制器Matlab编程代码
..............................................................................
fuzzyrules=[-1 -1 -1 -1 -1 -1 -0.8 -0.6 -0.4 -0.2 0;
-1 -1 -1 -1 -1 -0.8 -0.6 -0.4 -0.2 0 0.2;
-1 -1 -1 -1 -0.8 -0.6 -0.4 -0.2 0 0.2 0.4;
-1 -1 -1 -0.8 -0.6 -0.4 -0.2 0 0.2 0.4 0.6;
-1 -1 -0.8 -0.6 -0.4 -0.2 0 0.2 0.4 0.6 0.8;
-1 -0.8 -0.6 -0.4 -0.2 0 0.2 0.4 0.6 0.8 1;
-0.8 -0.6 -0.4 -0.2 0 0.2 0.4 0.6 0.8 1 1;
-0.6 -0.4 -0.2 0 0.2 0.4 0.6 0.8 1 1 1;
-0.4 -0.2 0 0.2 0.4 0.6 0.8 1 1 1 1;
-0.2 0 0.2 0.4 0.6 0.8 1 1 1 1 1;
0 0.2 0.4 0.6 0.8 1 1 1 1 1 1]*gu*gf;
% Next, we define some parameters for the fuzzy inverse model
gye=1/2;,gyc=1/2;
gp=0.2;
numye=11; % Number of input membership functions for the ye
% universe of discourse
numyc=11; % Number of input membership functions for the yc
% universe of discourse
wye=0.2*(1/gye); % Sets the width of the membership functions for
% ye from center to extremes
wyc=0.2*(1/gyc); % Sets the width of the membership functions for
% yc from center to extremes
invbase=0.4*gp; % Sets the base of the output membership functions
cye=[-1 -0.8 -0.6 -0.4 -0.2 0 0.2 0.4 0.6 0.8 1]*(1/gye);
% For change in error input for learning mechanism
cyc=[-1 -0.8 -0.6 -0.4 -0.2 0 0.2 0.4 0.6 0.8 1]*(1/gyc);
........................................................................
ym(index)=(1/(2+a_r*step))*((2-a_r*step)*ymold+...
k_r*step*(r(index)+rold));
ymold=ym(index);
rold=r(index);
c_count=0;,e_count=0; % These are used to count the number of
% non-zero mf certainitie of e and c
e=r(index)-y(index);
% Calculates the error input for the fuzzy controller
c=(e-eold)/step;
% Calculates the change in error input for the fuzzy controller
eold=e;
if e<=ce(1) % Takes care of saturation of the left-most
% membership function
mfe=[1 0 0 0 0 0 0 0 0 0 0]; % i.e., the only one on is the
%left-most one
e_count=e_count+1;,e_int=1; % One mf on, it is the
%left-most one.
elseif e>=ce(nume) % Takes care ofsaturation
%of the right-most mf
mfe=[0 0 0 0 0 0 0 0 0 0 1];
e_count=e_count+1;,e_int=nume; % One mf on, it is the
%right-most one
else % In this case the input is on the middle part of the
for i=1:nume
if e<=ce(i)
mfe(i)=max([0 1+(e-ce(i))/we]);
if mfe(i)~=0
e_count=e_count+1;
e_int=i; % This term holds the index last entry
% with a non-zero term
end
else
mfe(i)=max([0,1+(ce(i)-e)/we]);
% In thiscase the input is to the
% right ofthe center ce(i)
if mfe(i)~=0
e_count=e_count+1;
e_int=i; % This term holds the index of the
% last entry with a non-zero term
end
end
end
end
meme_count=[e_count meme_count(1:9)];
meme_int=[e_int meme_int(1:9)];
...............................................................................
........................................................................
A179
下面是Matlab代码：
% 设置混沌系统初始值
x0 = [0.5, 0.5, 0.5];
% 定义混沌系统
[t, x] = ode45(@chaotic_system, [0, 10], x0);
% 画出混沌系统的吸引子
plot3(x(:, 1), x(:, 2), x(:, 3), 'LineWidth', 2);
title('混沌系统的吸引子');
% 设置控制器的初始权值
w0 = [0.5, 0.5, 0.5];
% 定义模糊控制器
[t, w] = ode45(@fuzzy_controller, [0, 10], w0);
% 绘制控制器输出
plot(t, w, 'LineWidth', 2);
title('模糊控制器输出');
% 定义混沌控制系统
function dx = chaos_controller_system(t, x, w)
dx = zeros(3, 1);
% 模糊控制器的参数
a = 1;
b = 1;
c = 1;
% 输入变量
u = a * w(1) + b * w(2) + c * w(3);
% 控制系统方程
dx(1) = 10 * (x(2) - x(1)) - u;
dx(2) = 28 * x(1) - x(2) - x(1) * x(3);
dx(3) = x(1) * x(2) - 8/3 * x(3);
end
% 定义混沌系统方程
function dx = chaotic_system(t, x)
dx = zeros(3, 1);
dx(1) = 10 * (x(2) - x(1));
dx(2) = 28 * x(1) - x(2) - x(1) * x(3);
dx(3) = x(1) * x(2) - 8/3 * x(3);
end
% 定义模糊控制器方程
function dw = fuzzy_controller(t, w)
dw = zeros(3, 1);
% 定义模糊控制器规则
rule1 = @(x) (1 - x(1)) * (1 - x(2)) * (1 - x(3));
rule2 = @(x) (1 - x(1)) * x(2) * (1 - x(3));
rule3 = @(x) (1 - x(1)) * x(2) * x(3);
rule4 = @(x) x(1) * x(2) * x(3);
% 模糊控制器的输入
e = 0;
for i = 1:3
e = e + w(i)^2;
end
e = sqrt(e);
% 模糊控制器的输出
dw(1) = -e / 2;
dw(2) = -e / 2;
dw(3) = -e / 2;
% 根据控制规则变化权值
if w(1) > w(2) && w(2) > w(3)
dw(1) = dw(1) + rule1(w);
dw(2) = dw(2) + rule2(w);
dw(3) = dw(3) + rule3(w);
elseif w(1) > w(3) && w(3) > w(2)
dw(1) = dw(1) + rule1(w);
dw(2) = dw(2) + rule3(w);
dw(3) = dw(3) + rule2(w);
elseif w(2) > w(1) && w(1) > w(3)
dw(1) = dw(1) + rule2(w);
dw(2) = dw(2) + rule1(w);
dw(3) = dw(3) + rule3(w);
elseif w(2) > w(3) && w(3) > w(1)
dw(1) = dw(1) + rule2(w);
dw(2) = dw(2) + rule3(w);
dw(3) = dw(3) + rule1(w);
elseif w(3) > w(1) && w(1) > w(2)
dw(1) = dw(1) + rule3(w);
dw(2) = dw(2) + rule1(w);
dw(3) = dw(3) + rule2(w);
elseif w(3) > w(2) && w(2) > w(1)
dw(1) = dw(1) + rule3(w);
dw(2) = dw(2) + rule2(w);
dw(3) = dw(3) + rule1(w);
end
end
基于new bing的编写参考:
% 模糊控制器设计
fis = readfis('fuzzy_controller.fis');
% 读取模糊控制器文件，其中包括输入、输出变量及规则库
% 初始化混沌系统参数
x0 = [0.5, 0.5, 0.5]; % 初始状态向量
tspan = [0 500]; % 时间区间
% 其他混沌系统参数，如混沌参数等
% 模拟混沌系统并实现控制
[t,x] = ode45(@(t,x)chaos_system(t,x,param1,param2...),tspan,x0);
for i=1:length(t)
% 对每个状态变量进行模糊化处理
input1 = x(i,1); % 输入1模糊化处理
input2 = x(i,2); % 输入2模糊化处理
% ...
% 基于模糊推理引擎的输出，计算出模糊输出变量的置信度，并使用加权平均或加权最大值操作来确定模糊输出变量的最终值
output = evalfis([input1,input2,...], fis);
% 将模糊输出变量转换成实际控制信号，并应用于混沌系统中
control_signal = output; % 控制信号转换处理
% ...
% 更新混沌系统状态向量
x(i+1,:) = chaos_system(t(i),x(i,:),param1,param2...,control_signal);
end
% 可视化混沌系统状态变化
plot3(x(:,1),x(:,2),x(:,3));
需要注意的是，这只是一个非常简单的示例，实际应用中可能需要更复杂的模糊控制器设计和调试。同时，基于模糊控制的统一混沌控制器在应用中也有其局限性和缺陷，需要综合考虑应用场景和实际需求。
1，可以参考一下这个：解决方案