[MATLAB]S函数

86 阅读 0 评论 57 点赞

我是靠谱客的博主追寻月饼，这篇文章主要介绍[MATLAB]S函数，现在分享给大家，希望可以做个参考。

使用M语言编写S-函数，使用模板来编写。

M文件主函数格式

%[sys,x0,str,ts]=f(t,x,u,flag,p1,p1,...)%f为函数名，与文件名相同

%sys是某个子函数的返回值，取决也flag
%x0为所有状态的初始化向量，只有在flag=0时使用
%str为空矩阵，
%ts为采样时间，采样时间和偏移时间
% [0 0]每个时间步都运行S-函数
% [-1 0]使S——函数和被连接的模块一相同时速率运行
% [0.3 0.5]从0.5s和以0.3s的速度采样
%t为当前时间，
%x为状态向量，
%u为输入，
%flag是运行过程中的标志位，

%p1，p1...为附加值

子函数说明

function [sys,x0,str,ts]=sfun_mix(t,x,u,flag)
switch flag
case 0,
[sys,x0,str,ts]=mdlInitializeSizes;%初始化系统参数
case 1,
sys=mdlDerivatives(t,x,u);%计算连续状态的导数
case 2,
sys=mdlUpdate(t,x,u);%离散状态的更新
case 3,
sys=mdlOutputs(t,x,u); %输出
case 4,
sys=mdlGetNextTimeVarHit(t,x,u);计算下一采样点
case 9,
sys=mdlTerminate(t,x,u);%终止仿真
otherwise
error(['Unhandled flag=',num2str(flag)]);

end

初始化定义说明

sizes.NumContStates=1;%连续变量个数
sizes.NumDiscStates=1;%离散变量个数
sizes.NumOutputs=1;%输出个数
sizes.NumInputs=1;%输入个数
sizes.DirFeedthrough=0;%直接贯通，0或1,当时输出值直接依赖于同一时刻的输入时为1
sizes.NumSampleTimes=2;%采样时间

实例：

1.信号放大两倍

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
%[sys,x0,str,ts]=f(t,x,u,flag,p1,p1,...)
%sys是某个子函数的返回值，取决也flag
%x0为所有状态的初始化向量，只有在flag=0时使用
%str为空矩阵，
%ts为采样时间，采样时间和偏移时间
%  [0 0]每个时间步都运行S-函数
%  [-1 0]使S——函数和被连接的模块一相同时速率运行
%  [0.25 0.1]从0.1s和以0.25s的速度采样
%t为当前时间，
%x为状态向量，
%u为输入，
%flag是运行过程中的标志位，
%p1，p1...为附加值

function [sys,x0,str,ts]=timestwo(t,x,u,flag)
switch flag
    case 0
        [sys,x0,str,ts]=mdlInitializeSizes;
    case 3
        sys=mdlOutputs(t,x,u);
    case{1,2,4,9}
        sys=[];
    otherwise 
        error(['Unhandled flag=',num2str(flag)]);    
end

function [sys,x0,str,ts]=mdlInitializeSizes
sizes=simsizes;%返回一个变量，
sizes.NumContStates=0;%连续变量个数
sizes.NumDiscStates=0;%离散变量个数
sizes.NumOutputs=1;%输出个数
sizes.NumInputs=1;%输入个数
sizes.DirFeedthrough=1;%直接贯通，0或1，当时输出值直接依赖于同一时刻的输入时为1
sizes.NumSampleTimes=1;%采样时间
sys=simsizes(sizes);%返回值
x0=[];
str=[];
ts=[-1 0];

function sys=mdlOutputs(t,x,u)
sys=2*u;

2.增益可变

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
%[sys,x0,str,ts]=f(t,x,u,flag,p1,p1,...)
%sys是某个子函数的返回值，取决也flag
%x0为所有状态的初始化向量，只有在flag=0时使用
%str为空矩阵，
%ts为采样时间，采样时间和偏移时间
%  [0 0]每个时间步都运行S-函数
%  [-1 0]使S——函数和被连接的模块一相同时速率运行
%  [0.25 0.1]从0.1s和以0.25s的速度采样
%t为当前时间，
%x为状态向量，
%u为输入，
%flag是运行过程中的标志位，
%p1，p1...为附加值

function [sys,x0,str,ts]=sfun_vargain(t,x,u,flag,gain)
switch flag
    case 0
        [sys,x0,str,ts]=mdlInitializeSizes;
    case 3
        sys=mdlOutputs(t,x,u,gain);
    case{1,2,4,9}
        sys=[];
    otherwise 
        error(['Unhandled flag=',num2str(flag)]);    
end

function [sys,x0,str,ts]=mdlInitializeSizes
sizes=simsizes;%返回一个变量，
sizes.NumContStates=0;%连续变量个数
sizes.NumDiscStates=0;%离散变量个数
sizes.NumOutputs=1;%输出个数
sizes.NumInputs=1;%输入个数
sizes.DirFeedthrough=1;%直接贯通，0或1，当时输出值直接依赖于同一时刻的输入时为1
sizes.NumSampleTimes=1;%采样时间
sys=simsizes(sizes);%返回值
x0=[];
str=[];
ts=[-1 0];

function sys=mdlOutputs(t,x,u,gain)
sys=gain*u;

3.积分器

复制代码

%[sys,x0,str,ts]=f(t,x,u,flag,p1,p1,...)
%sys是某个子函数的返回值，取决也flag
%x0为所有状态的初始化向量，只有在flag=0时使用
%str为空矩阵，
%ts为采样时间，采样时间和偏移时间
%  [0 0]每个时间步都运行S-函数
%  [-1 0]使S——函数和被连接的模块一相同时速率运行
%  [0.25 0.1]从0.1s和以0.25s的速度采样
%t为当前时间，
%x为状态向量，
%u为输入，
%flag是运行过程中的标志位，
%p1，p1...为附加值

%x'=u
%y=x
function [sys,x0,str,ts]=sfun_int(t,x,u,flag,initial_state)
switch flag
    case 0
        [sys,x0,str,ts]=mdlInitializeSizes(initial_state);
    case 3
        sys=mdlOutputs(t,x,u);
    case 1
        sys=mdlDerivatives(t,x,u);
    case{2,4,9}
        sys=[];
    otherwise 
        error(['Unhandled flag=',num2str(flag)]);    
end

function [sys,x0,str,ts]=mdlInitializeSizes(initial_state)
sizes=simsizes;%返回一个变量，
sizes.NumContStates=1;%连续变量个数
sizes.NumDiscStates=0;%离散变量个数
sizes.NumOutputs=1;%输出个数
sizes.NumInputs=1;%输入个数
sizes.DirFeedthrough=1;%直接贯通，0或1，当时输出值直接依赖于同一时刻的输入时为1
sizes.NumSampleTimes=1;%采样时间
sys=simsizes(sizes);%返回值
x0=[initial_state];
str=[];
ts=[-1 0];

function sys=mdlDerivatives(t,x,u)
sys=[u];

function sys=mdlOutputs(t,x,u)
sys=x;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
%[sys,x0,str,ts]=f(t,x,u,flag,p1,p1,...)
%sys是某个子函数的返回值，取决也flag
%x0为所有状态的初始化向量，只有在flag=0时使用
%str为空矩阵，
%ts为采样时间，采样时间和偏移时间
%  [0 0]每个时间步都运行S-函数
%  [-1 0]使S——函数和被连接的模块一相同时速率运行
%  [0.25 0.1]从0.1s和以0.25s的速度采样
%t为当前时间，
%x为状态向量，
%u为输入，
%flag是运行过程中的标志位，
%p1，p1...为附加值


%x'=u
%y=x
function [sys,x0,str,ts]=sfun_int(t,x,u,flag,initial_state)
switch flag
    case 0
        [sys,x0,str,ts]=mdlInitializeSizes(initial_state);
    case 3
        sys=mdlOutputs(t,x,u);
    case 1
        sys=mdlDerivatives(t,x,u);
    case{2,4,9}
        sys=[];
    otherwise 
        error(['Unhandled flag=',num2str(flag)]);    
end

function [sys,x0,str,ts]=mdlInitializeSizes(initial_state)
sizes=simsizes;%返回一个变量，
sizes.NumContStates=1;%连续变量个数
sizes.NumDiscStates=0;%离散变量个数
sizes.NumOutputs=1;%输出个数
sizes.NumInputs=1;%输入个数
sizes.DirFeedthrough=1;%直接贯通，0或1，当时输出值直接依赖于同一时刻的输入时为1
sizes.NumSampleTimes=1;%采样时间
sys=simsizes(sizes);%返回值
x0=[initial_state];
str=[];
ts=[-1 0];

function sys=mdlDerivatives(t,x,u)
sys=[u];

function sys=mdlOutputs(t,x,u)
sys=x;

4.蹦极系统（多状态）

k=5,a1=1,a2=1,g=10,h为离地面的高度，输入参数为长度、质量、离地面高度

复制代码

function [sys,x0,str,ts]=sfun_bungee(t,x,u,flag,len,weight,dist_ground)
k=5;a1=1;a2=1;g=10;
switch flag
    case 0,
        [sys,x0,str,ts]=mdlInitializeSizes(len);
    case 1,
        sys=mdlDerivatives(t,x,u,weight,k,a1,a2,g);
    case 2,
        sys=mdlUpdate(t,x,u);
    case 3,
        sys=mdlOutputs(t,x,u,dist_ground);
    case 4,
        sys=mdlGetTimeOfNextVarHit(t,u,x);
    case 9,
        sys=mdlTerminate(t,x,u);
    otherwise 
        error(['Unhandled flag=',num2str(flag)]);    
end

function [sys,x0,str,ts]=mdlInitializeSizes(len)
sizes=simsizes;%返回一个变量，
sizes.NumContStates=2;%连续变量个数
sizes.NumDiscStates=0;%离散变量个数
sizes.NumOutputs=1;%输出个数
sizes.NumInputs=0;%输入个数
sizes.DirFeedthrough=0;%直接贯通，0或1，当时输出值直接依赖于同一时刻的输入时为1
sizes.NumSampleTimes=1;%采样时间
sys=simsizes(sizes);%返回值
x0=[-len;1];
str=[];
ts=[0 0];

function sys=mdlDerivatives(t,x,u,weight,k,a1,a2,g)
if x(1)<0
    b=0;
else 
    b=-k*x(1);
end
x1dot=x(2);
x2dot=1/weight*(weight*g+b-a1*x(2)-a2*abs(x(2))*x(2));
sys=[x1dot;x2dot];

function sys=mdlUpdate(t,x,u)
sys=[];

function sys=mdlOutputs(t,x,u,dist_ground)
sys=dist_ground-x(1);

function sys=mdlGetTimeOfNextVarHit(t,x,u)
%sampleTime=10;
%sys=t+sampleTime;
sys=[];

function sys=mdlTerminate(t,x,u)
sys=[];

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
%[sys,x0,str,ts]=f(t,x,u,flag,p1,p1,...)
%sys是某个子函数的返回值，取决也flag
%x0为所有状态的初始化向量，只有在flag=0时使用
%str为空矩阵，
%ts为采样时间，采样时间和偏移时间
%  [0 0]每个时间步都运行S-函数
%  [-1 0]使S——函数和被连接的模块一相同时速率运行
%  [0.25 0.1]从0.1s和以0.25s的速度采样
%t为当前时间，
%x为状态向量，
%u为输入，
%flag是运行过程中的标志位，
%p1，p1...为附加值



function [sys,x0,str,ts]=sfun_bungee(t,x,u,flag,len,weight,dist_ground)
k=5;a1=1;a2=1;g=10;
switch flag
    case 0,
        [sys,x0,str,ts]=mdlInitializeSizes(len);
    case 1,
        sys=mdlDerivatives(t,x,u,weight,k,a1,a2,g);
    case 2,
        sys=mdlUpdate(t,x,u);
    case 3,
        sys=mdlOutputs(t,x,u,dist_ground);
    case 4,
        sys=mdlGetTimeOfNextVarHit(t,u,x);
    case 9,
        sys=mdlTerminate(t,x,u);
    otherwise 
        error(['Unhandled flag=',num2str(flag)]);    
end

function [sys,x0,str,ts]=mdlInitializeSizes(len)
sizes=simsizes;%返回一个变量，
sizes.NumContStates=2;%连续变量个数
sizes.NumDiscStates=0;%离散变量个数
sizes.NumOutputs=1;%输出个数
sizes.NumInputs=0;%输入个数
sizes.DirFeedthrough=0;%直接贯通，0或1，当时输出值直接依赖于同一时刻的输入时为1
sizes.NumSampleTimes=1;%采样时间
sys=simsizes(sizes);%返回值
x0=[-len;1];
str=[];
ts=[0 0];

function sys=mdlDerivatives(t,x,u,weight,k,a1,a2,g)
if x(1)<0
    b=0;
else 
    b=-k*x(1);
end
x1dot=x(2);
x2dot=1/weight*(weight*g+b-a1*x(2)-a2*abs(x(2))*x(2));
sys=[x1dot;x2dot];

function sys=mdlUpdate(t,x,u)
sys=[];


function sys=mdlOutputs(t,x,u,dist_ground)
sys=dist_ground-x(1);


function sys=mdlGetTimeOfNextVarHit(t,x,u)
%sampleTime=10;
%sys=t+sampleTime;
sys=[];

function sys=mdlTerminate(t,x,u)
sys=[];

5.离散状态

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
%[sys,x0,str,ts]=f(t,x,u,flag,p1,p1,...)
%sys是某个子函数的返回值，取决也flag
%x0为所有状态的初始化向量，只有在flag=0时使用
%str为空矩阵，
%ts为采样时间，采样时间和偏移时间
%  [0 0]每个时间步都运行S-函数
%  [-1 0]使S——函数和被连接的模块一相同时速率运行
%  [0.25 0.1]从0.1s和以0.25s的速度采样
%t为当前时间，
%x为状态向量，
%u为输入，
%flag是运行过程中的标志位，
%p1，p1...为附加值



function [sys,x0,str,ts]=sfun_und(t,x,u,flag)
switch flag
    case 0,
        [sys,x0,str,ts]=mdlInitializeSizes;
    case 2,
        sys=mdlUpdate(t,x,u);
    case 3,
        sys=mdlOutputs(t,x,u);
    case 9,
        sys=[];
    otherwise 
        error(['Unhandled flag=',num2str(flag)]);    
end

function [sys,x0,str,ts]=mdlInitializeSizes(len)
sizes=simsizes;%返回一个变量，
sizes.NumContStates=0;%连续变量个数
sizes.NumDiscStates=1;%离散变量个数
sizes.NumOutputs=1;%输出个数
sizes.NumInputs=1;%输入个数
sizes.DirFeedthrough=0;%直接贯通，0或1，当时输出值直接依赖于同一时刻的输入时为1
sizes.NumSampleTimes=1;%采样时间
sys=simsizes(sizes);%返回值
x0=0;
str=[];
ts=[0.1 0];


function sys=mdlUpdate(t,x,u)
sys=u;


function sys=mdlOutputs(t,x,u)
sys=x;