1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
main
{
初始化模型;
计算下一个采样时间点（大步长）;
while(未到达仿真终止时间）
{
计算模块的输出;
更新离散状态量;
if(此模型带有连续状态模块)
{
here:计算微分;
计算模块的输出;
if(精度未达标)
goto here;
过零检测;
计算下一个采样时间点（大步长）;
}
}
执行仿真终止动作;
}

1
2
3
4
A=[-0.5572,-0.7814;0.7814,0];
B=[1,-1;0,2];
C=[1.9691,6.4493];

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
function [sys,x0,str,ts,simStateCompliance] = sfun_state01(t,x,u,flag,A,B,C)
switch flag,
case 0,
[sys,x0,str,ts,simStateCompliance]=mdlInitializeSizes;
case 1,
sys=mdlDerivatives(t,x,u,A,B);
case 2,
sys=mdlUpdate(t,x,u);
case 3,
sys=mdlOutputs(t,x,u,C);
case 4,
sys=mdlGetTimeOfNextVarHit(t,x,u);
case 9,
sys=mdlTerminate(t,x,u);
otherwise
DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag));
end
function [sys,x0,str,ts,simStateCompliance]=mdlInitializeSizes
sizes = simsizes;
sizes.NumContStates
= 2;
sizes.NumDiscStates
= 0;
sizes.NumOutputs
= 1;
sizes.NumInputs
= 2;
sizes.DirFeedthrough = 0;
sizes.NumSampleTimes = 1;
sys = simsizes(sizes);
x0
= [0,0]';
str = [];
ts
= [0 0];
simStateCompliance = 'UnknownSimState';
function sys=mdlDerivatives(t,x,u,A,B)
sys = A*x + B*u;
function sys=mdlUpdate(t,x,u)
% update state variable
sys = [];
function sys=mdlOutputs(t,x,u,C)
% update output
sys = C * x;
function sys=mdlGetTimeOfNextVarHit(t,x,u)
sampleTime = 1;
sys = t + sampleTime;
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
function [sys,x0,str,ts,simStateCompliance] = sfun_state02(t,x,u,flag,A,B,C,Ts)
switch flag,
%%%%%%%%%%%%%%%%%%
% Initialization %定义S函数的基本属性，如输入/输出维数、连续/离散状态变量个数、采样时间、以及输入是否为直接馈入等
%%%%%%%%%%%%%%%%%%
case 0,
[sys,x0,str,ts,simStateCompliance]=mdlInitializeSizes;
%%%%%%%%%%%%%%%
% Derivatives % 连续状态变量的微分函数，这里通常通过给定的微分计算表达式，通过积分计算得到状态变量的值
%%%%%%%%%%%%%%%
case 1,
sys=mdlDerivatives(t,x,u);
%%%%%%%%%%
% Update %更新离散状态变量
%%%%%%%%%%
case 2,
sys=mdlUpdate(t,x,u,A,B,Ts);
%%%%%%%%%%%
% Outputs %计算S函数的输出
%%%%%%%%%%%
case 3,
sys=mdlOutputs(t,x,u,C);
%%%%%%%%%%%%%%%%%%%%%%%
% GetTimeOfNextVarHit %仅在变离散采样时间情况下使用，用于计算下一个采样时时刻的绝对时间，若模块不是变步长此函数不会执行
%%%%%%%%%%%%%%%%%%%%%%%
case 4,
sys=mdlGetTimeOfNextVarHit(t,x,u);
%%%%%%%%%%%%%
% Terminate %在仿真结束时执行一些必要的动作，如清除临时变量，或显示提示信息等
%%%%%%%%%%%%%
case 9,
sys=mdlTerminate(t,x,u);
%%%%%%%%%%%%%%%%%%%%
% Unexpected flags %
%%%%%%%%%%%%%%%%%%%%
otherwise
DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag));
end
% end sfuntmpl
%
%=============================================================================
% mdlInitializeSizes
% Return the sizes, initial conditions, and sample times for the S-function.
%=============================================================================
%
function [sys,x0,str,ts,simStateCompliance]=mdlInitializeSizes
sizes = simsizes;
sizes.NumContStates
= 0;
sizes.NumDiscStates
= 2;
sizes.NumOutputs
= 1;
sizes.NumInputs
= 2;
sizes.DirFeedthrough = 0;
sizes.NumSampleTimes = 1;
% at least one sample time is needed
sys = simsizes(sizes);
%
% initialize the initial conditions/状态变量的初始值，仅在flag=0时有效，其余情况被忽略
%
x0
= [0 0]';
%
% str is always an empty matrix/保留变量，将来版本可能使用，用户只能将其初始化为[ ]
%
str = [];
%
% initialize the array of sample times/S函数的采样时间，由一个二维的数组表示
%
ts
= [0 0];
% Specify the block simStateCompliance. The allowed values are:
%
'UnknownSimState', < The default setting; warn and assume DefaultSimState
%
'DefaultSimState', < Same sim state as a built-in block
%
'HasNoSimState',
< No sim state
%
'DisallowSimState' < Error out when saving or restoring the model sim state
simStateCompliance = 'UnknownSimState';
% end mdlInitializeSizes
%
%=============================================================================
% mdlDerivatives
% Return the derivatives for the continuous states.
%=============================================================================
%
function sys=mdlDerivatives(t,x,u)
sys = [];
% end mdlDerivatives
%
%=============================================================================
% mdlUpdate
% Handle discrete state updates, sample time hits, and major time step
% requirements.
%=============================================================================
%
function sys=mdlUpdate(t,x,u,A,B,Ts)
sys = x + (A * x + B * u) *Ts;
% end mdlUpdate
%
%=============================================================================
% mdlOutputs
% Return the block outputs.
%=============================================================================
%
function sys=mdlOutputs(t,x,u,C)
sys = C * x;
% end mdlOutputs
%
%=============================================================================
% mdlGetTimeOfNextVarHit
% Return the time of the next hit for this block.
Note that the result is
% absolute time.
Note that this function is only used when you specify a
% variable discrete-time sample time [-2 0] in the sample time array in
% mdlInitializeSizes.
%=============================================================================
%
function sys=mdlGetTimeOfNextVarHit(t,x,u)
sampleTime = 1;
%
Example, set the next hit to be one second later.
sys = t + sampleTime;
% end mdlGetTimeOfNextVarHit
%
%=============================================================================
% mdlTerminate
% Perform any end of simulation tasks.
%=============================================================================
%
function sys=mdlTerminate(t,x,u)
sys = [];
% end mdlTerminate

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
function [sys,x0,str,ts,simStateCompliance] = DisInteg02(t,x,u,flag,Ts)
switch flag,
case 0,
[sys,x0,str,ts,simStateCompliance]=mdlInitializeSizes;
case 1,
sys=mdlDerivatives(t,x,u);
case 2,
sys=mdlUpdate(t,x,u,Ts);
case 3,
sys=mdlOutputs(t,x,u);
case 4,
sys=mdlGetTimeOfNextVarHit(t,x,u);
case 9,
sys=mdlTerminate(t,x,u);
otherwise
DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag));
end
function [sys,x0,str,ts,simStateCompliance]=mdlInitializeSizes
sizes = simsizes;
sizes.NumContStates
= 0;
sizes.NumDiscStates
= 1;
sizes.NumOutputs
= 1;
sizes.NumInputs
= 1;
sizes.DirFeedthrough = 1;
sizes.NumSampleTimes = 1;
sys = simsizes(sizes);
x0
= [0];
str = [];
ts
= [0 0];
simStateCompliance = 'UnknownSimState';
function sys=mdlDerivatives(t,x,u)
sys = [];
function sys=mdlUpdate(t,x,u,Ts)
% update state variable
% x(k+1) - x(k) = u*Ts
% x(k+1) = x(k) + u*Ts
sys = x+u*Ts;
function sys=mdlOutputs(t,x,u)
% update output
sys = x;
function sys=mdlGetTimeOfNextVarHit(t,x,u)
sampleTime = 1;
sys = t + sampleTime;
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
function [sys,x0,str,ts,simStateCompliance] = Derivative(t,x,u,flag)
switch flag,
case 0,
[sys,x0,str,ts,simStateCompliance]=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=mdlGetTimeOfNextVarHit(t,x,u);
case 9,
sys=mdlTerminate(t,x,u);
otherwise
DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag));
end
function [sys,x0,str,ts,simStateCompliance]=mdlInitializeSizes
sizes = simsizes;
sizes.NumContStates
= 0;
sizes.NumDiscStates
= 1;
sizes.NumOutputs
= 1;
sizes.NumInputs
= 1;
sizes.DirFeedthrough = 1;
sizes.NumSampleTimes = 1;
sys = simsizes(sizes);
x0
= [0];
str = [];
ts
= [0 0];
simStateCompliance = 'UnknownSimState';
function sys=mdlDerivatives(t,x,u)
sys = [];
function sys=mdlUpdate(t,x,u)
% update state variable
% (x(k+1) - x(k))/Ts = (u - x(k))/Ts;
% x(k+1) = u ;
sys = u;
function sys=mdlOutputs(t,x,u)
% update output
sys = x;
function sys=mdlGetTimeOfNextVarHit(t,x,u)
sampleTime = 1;
sys = t + sampleTime;
function sys=mdlTerminate(t,x,u)
sys = [];

1
2
block.NumDialogPrms = 0;

1
2
block.InputPort(1).Dimensions = 1;

1
2
3
4
5
6
7
8
9
10
11
function DoPostProSetup(block)
%% setup Dwork
block.NumDworks
= 1;
block.Dwork(1).Name
= 'x0';
block.Dwork(1).Dimensions = 1;
block.Dwork(1).DatetypeID = 1;
block.Dwork(1).Complexity = 'Real';
block.Dwork(1).UsedAsDiscState	= true;

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
% Level2 m Sfunction
%% 图片处理
%%
% m1 = imread('阿布罗狄.jpg');
% m1 = m1(:,:,1);
% m2 = imread('艾欧里亚.jpg');
% m2 = m2(:,:,1);
%%
%%
function Sfcn_L2(block)
% Level-2 MATLAB file S-Function for unit delay demo.
%
Copyright 1990-2009 The MathWorks, Inc.
setup(block);
%endfunction
function setup(block)
block.NumDialogPrms
= 0;
%% Register number of input and output ports
block.NumInputPorts
= 2;
block.NumOutputPorts = 0;
%% Setup functional port properties to dynamically
%% inherited.
block.SetPreCompInpPortInfoToDynamic;
block.InputPort(1).Dimensions
= [375 500];
block.InputPort(1).DatatypeID
= 3;
%uint8
block.InputPort(1).Complexity
= 'real';
block.InputPort(1).DirectFeedthrough = false;
block.InputPort(2).Dimensions
= [375 500];
block.InputPort(2).DatatypeID
= 3;
%uint8
block.InputPort(2).Complexity
= 'real';
block.InputPort(2).DirectFeedthrough = false;
%% Set block sample time
block.SampleTimes = [0 0];
%% Set the block simStateCompliance to default (i.e., same as a built-in block)
block.SimStateCompliance = 'DefaultSimState';
%% Register methods
block.RegBlockMethod('Outputs',
@Output);
%endfunction
function Output(block)
imshow((block.InputPort(1).data + block.InputPort(2).data)/2);
%endfunction

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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
/*
* sfuntmpl_basic.c: Basic 'C' template for a level 2 S-function.
*
* Copyright 1990-2018 The MathWorks, Inc.
*/
/*
* You must specify the S_FUNCTION_NAME as the name of your S-function
* (i.e. replace sfuntmpl_basic with the name of your S-function).
*/
#define S_FUNCTION_NAME
sfun_c_add
#define S_FUNCTION_LEVEL 2
/*
* Need to include simstruc.h for the definition of the SimStruct and
* its associated macro definitions.
*/
#include "simstruc.h"
/* Error handling
* --------------
*
* You should use the following technique to report errors encountered within
* an S-function:
*
*
ssSetErrorStatus(S,"Error encountered due to ...");
*
return;
*
* Note that the 2nd argument to ssSetErrorStatus must be persistent memory.
* It cannot be a local variable. For example the following will cause
* unpredictable errors:
*
*
mdlOutputs()
*
{
*
char msg[256];
{ILLEGAL: to fix use "static char msg[256];"}
*
sprintf(msg,"Error due to %s", string);
*
ssSetErrorStatus(S,msg);
*
return;
*
}
*
*/
/*====================*
* S-function methods *
*====================*/
/* Function: mdlInitializeSizes ===============================================
* Abstract:
*
The sizes information is used by Simulink to determine the S-function
*
block's characteristics (number of inputs, outputs, states, etc.).
*/
static void mdlInitializeSizes(SimStruct *S)
{
ssSetNumSFcnParams(S, 0);
/* Number of expected parameters */
if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {
/* Return if number of expected != number of actual parameters */
return;
}
if (!ssSetNumInputPorts(S, 1)) return; //只有一个输入
ssSetInputPortWidth(S, 0, DYNAMICALLY_SIZED);//输入是动态的
/*
* Set direct feedthrough flag (1=yes, 0=no).
* A port has direct feedthrough if the input is used in either
* the mdlOutputs or mdlGetTimeOfNextVarHit functions.
*/
ssSetInputPortDirectFeedThrough(S, 0, 1); //输入是直接馈入的
if (!ssSetNumOutputPorts(S, 1)) return; //只有一个输出
ssSetOutputPortWidth(S, 0, 1);
//输出只有一维
ssSetNumSampleTimes(S, 1);
//采样时间只有一个
/* Specify the operating point save/restore compliance to be same as a
* built-in block */
ssSetOperatingPointCompliance(S, USE_DEFAULT_OPERATING_POINT);
ssSetOptions(S,
SS_OPTION_WORKS_WITH_CODE_REUSE |
SS_OPTION_EXCEPTION_FREE_CODE |
SS_OPTION_USE_TLC_WITH_ACCELERATOR);
}
/* Function: mdlInitializeSampleTimes =========================================
* Abstract:
*
This function is used to specify the sample time(s) for your
*
S-function. You must register the same number of sample times as
*
specified in ssSetNumSampleTimes.
*/
static void mdlInitializeSampleTimes(SimStruct *S)
{
ssSetSampleTime(S, 0, INHERITED_SAMPLE_TIME);
ssSetOffsetTime(S, 0, 0.0);
ssSetModelReferenceSampleTimeDefaultInheritance(S);
}
#define MDL_INITIALIZE_CONDITIONS
/* Change to #undef to remove function */
#if defined(MDL_INITIALIZE_CONDITIONS)
/* Function: mdlInitializeConditions ========================================
* Abstract:
*
In this function, you should initialize the continuous and discrete
*
states for your S-function block.
The initial states are placed
*
in the state vector, ssGetContStates(S) or ssGetRealDiscStates(S).
*
You can also perform any other initialization activities that your
*
S-function may require. Note, this routine will be called at the
*
start of simulation and if it is present in an enabled subsystem
*
configured to reset states, it will be call when the enabled subsystem
*
restarts execution to reset the states.
*/
static void mdlInitializeConditions(SimStruct *S)
{
}
#endif /* MDL_INITIALIZE_CONDITIONS */
#define MDL_START
/* Change to #undef to remove function */
#if defined(MDL_START) 
/* Function: mdlStart =======================================================
* Abstract:
*
This function is called once at start of model execution. If you
*
have states that should be initialized once, this is the place
*
to do it.
*/
static void mdlStart(SimStruct *S)
{
}
#endif /*
MDL_START */
/* Function: mdlOutputs =======================================================
* Abstract:
*
In this function, you compute the outputs of your S-function
*
block.
*/
static void mdlOutputs(SimStruct *S, int_T tid)
{
//获取输入尽量都这样写，其他方式有时候结果会错
InputRealPtrsType u1 = ssGetInputPortRealSignalPtrs(S,0);
int_T
width = ssGetInputPortWidth(S,0); //获取输入维数
real_T
*y1 = ssGetOutputPortSignal(S,0);
real_T Sum=0;
int_T
i;
for(i=0;i<width;i++)
{
Sum = Sum+(*u1[i]);
}
y1[0] = Sum;
//
int_T
width = ssGetInputPortWidth(S,0);
//
y1[0] = (*u1[0])*width;
}
#define MDL_UPDATE
/* Change to #undef to remove function */
#if defined(MDL_UPDATE)
/* Function: mdlUpdate ======================================================
* Abstract:
*
This function is called once for every major integration time step.
*
Discrete states are typically updated here, but this function is useful
*
for performing any tasks that should only take place once per
*
integration step.
*/
static void mdlUpdate(SimStruct *S, int_T tid)
{
}
#endif /* MDL_UPDATE */
#define MDL_DERIVATIVES
/* Change to #undef to remove function */
#if defined(MDL_DERIVATIVES)
/* Function: mdlDerivatives =================================================
* Abstract:
*
In this function, you compute the S-function block's derivatives.
*
The derivatives are placed in the derivative vector, ssGetdX(S).
*/
static void mdlDerivatives(SimStruct *S)
{
}
#endif /* MDL_DERIVATIVES */
/* Function: mdlTerminate =====================================================
* Abstract:
*
In this function, you should perform any actions that are necessary
*
at the termination of a simulation.
For example, if memory was
*
allocated in mdlStart, this is the place to free it.
*/
static void mdlTerminate(SimStruct *S)
{
}
/*=============================*
* Required S-function trailer *
*=============================*/
#ifdef
MATLAB_MEX_FILE
/* Is this file being compiled as a MEX-file? */
#include "simulink.c"
/* MEX-file interface mechanism */
#else
#include "cg_sfun.h"
/* Code generation registration function */
#endif

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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
/*
* sfuntmpl_basic.c: Basic 'C' template for a level 2 S-function.
*
* Copyright 1990-2018 The MathWorks, Inc.
*/
/*
* You must specify the S_FUNCTION_NAME as the name of your S-function
* (i.e. replace sfuntmpl_basic with the name of your S-function).
*/
#define S_FUNCTION_NAME
sfun_c_add
#define S_FUNCTION_LEVEL 2
/*
* Need to include simstruc.h for the definition of the SimStruct and
* its associated macro definitions.
*/
#include "simstruc.h"
/* Error handling
* --------------
*
* You should use the following technique to report errors encountered within
* an S-function:
*
*
ssSetErrorStatus(S,"Error encountered due to ...");
*
return;
*
* Note that the 2nd argument to ssSetErrorStatus must be persistent memory.
* It cannot be a local variable. For example the following will cause
* unpredictable errors:
*
*
mdlOutputs()
*
{
*
char msg[256];
{ILLEGAL: to fix use "static char msg[256];"}
*
sprintf(msg,"Error due to %s", string);
*
ssSetErrorStatus(S,msg);
*
return;
*
}
*
*/
/*====================*
* S-function methods *
*====================*/
/* Function: mdlInitializeSizes ===============================================
* Abstract:
*
The sizes information is used by Simulink to determine the S-function
*
block's characteristics (number of inputs, outputs, states, etc.).
*/
static void mdlInitializeSizes(SimStruct *S)
{
ssSetNumSFcnParams(S, 0);
/* Number of expected parameters */
if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {
/* Return if number of expected != number of actual parameters */
return;
}
if (!ssSetNumInputPorts(S, 1)) return;
ssSetInputPortWidth(S, 0, 2);
/*
* Set direct feedthrough flag (1=yes, 0=no).
* A port has direct feedthrough if the input is used in either
* the mdlOutputs or mdlGetTimeOfNextVarHit functions.
*/
ssSetInputPortDirectFeedThrough(S, 0, 1);
if (!ssSetNumOutputPorts(S, 2)) return;
ssSetOutputPortWidth(S, 0, 1);
ssSetOutputPortWidth(S, 1, 1);
ssSetNumSampleTimes(S, 1);
/* Specify the operating point save/restore compliance to be same as a
* built-in block */
ssSetOperatingPointCompliance(S, USE_DEFAULT_OPERATING_POINT);
ssSetOptions(S,
SS_OPTION_WORKS_WITH_CODE_REUSE |
SS_OPTION_EXCEPTION_FREE_CODE |
SS_OPTION_USE_TLC_WITH_ACCELERATOR);
}
/* Function: mdlInitializeSampleTimes =========================================
* Abstract:
*
This function is used to specify the sample time(s) for your
*
S-function. You must register the same number of sample times as
*
specified in ssSetNumSampleTimes.
*/
static void mdlInitializeSampleTimes(SimStruct *S)
{
ssSetSampleTime(S, 0, INHERITED_SAMPLE_TIME);
ssSetOffsetTime(S, 0, 0.0);
ssSetModelReferenceSampleTimeDefaultInheritance(S);
}
#define MDL_INITIALIZE_CONDITIONS
/* Change to #undef to remove function */
#if defined(MDL_INITIALIZE_CONDITIONS)
/* Function: mdlInitializeConditions ========================================
* Abstract:
*
In this function, you should initialize the continuous and discrete
*
states for your S-function block.
The initial states are placed
*
in the state vector, ssGetContStates(S) or ssGetRealDiscStates(S).
*
You can also perform any other initialization activities that your
*
S-function may require. Note, this routine will be called at the
*
start of simulation and if it is present in an enabled subsystem
*
configured to reset states, it will be call when the enabled subsystem
*
restarts execution to reset the states.
*/
static void mdlInitializeConditions(SimStruct *S)
{
}
#endif /* MDL_INITIALIZE_CONDITIONS */
#define MDL_START
/* Change to #undef to remove function */
#if defined(MDL_START) 
/* Function: mdlStart =======================================================
* Abstract:
*
This function is called once at start of model execution. If you
*
have states that should be initialized once, this is the place
*
to do it.
*/
static void mdlStart(SimStruct *S)
{
}
#endif /*
MDL_START */
/* Function: mdlOutputs =======================================================
* Abstract:
*
In this function, you compute the outputs of your S-function
*
block.
*/
static void mdlOutputs(SimStruct *S, int_T tid)
{
InputRealPtrsType u1 = ssGetInputPortRealSignalPtrs(S,0);
real_T
*y1 = ssGetOutputPortSignal(S,0); //获取第一个输出端口的指针
real_T
*y2 = ssGetOutputPortSignal(S,1); //获取第二个输出端口的指针
//
int_T
width = ssGetInputPortWidth(S,0);
y1[0] = (*u1[0]+*u1[1]);
//输入是二维，所以要用指针加数组的方式
y2[0] = (*u1[0]-*u1[1]);
}
#define MDL_UPDATE
/* Change to #undef to remove function */
#if defined(MDL_UPDATE)
/* Function: mdlUpdate ======================================================
* Abstract:
*
This function is called once for every major integration time step.
*
Discrete states are typically updated here, but this function is useful
*
for performing any tasks that should only take place once per
*
integration step.
*/
static void mdlUpdate(SimStruct *S, int_T tid)
{
}
#endif /* MDL_UPDATE */
#define MDL_DERIVATIVES
/* Change to #undef to remove function */
#if defined(MDL_DERIVATIVES)
/* Function: mdlDerivatives =================================================
* Abstract:
*
In this function, you compute the S-function block's derivatives.
*
The derivatives are placed in the derivative vector, ssGetdX(S).
*/
static void mdlDerivatives(SimStruct *S)
{
}
#endif /* MDL_DERIVATIVES */
/* Function: mdlTerminate =====================================================
* Abstract:
*
In this function, you should perform any actions that are necessary
*
at the termination of a simulation.
For example, if memory was
*
allocated in mdlStart, this is the place to free it.
*/
static void mdlTerminate(SimStruct *S)
{
}
/*=============================*
* Required S-function trailer *
*=============================*/
#ifdef
MATLAB_MEX_FILE
/* Is this file being compiled as a MEX-file? */
#include "simulink.c"
/* MEX-file interface mechanism */
#else
#include "cg_sfun.h"
/* Code generation registration function */
#endif

1
2
3
4
5
6
7
8
//EmMath.h
#ifndef __QM_MATH_H__
#define __QM_MATH_H__
#define PI
3.1415926
signed long Em_Sin(unsigned long Angle);
#endif

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
//EmMath.c
#include"EmMath.h"
const unsigned short SinTbl[] = {0x0000,
//0
0x0019, 0x0032, 0x004B, 0x0064, 0x007D, 0x0096, 0x00AF, 0x00C8, 0x00E2, 0x00FB,//10
0x0114, 0x012D, 0x0146, 0x015F, 0x0178, 0x0191, 0x01AA, 0x01C3, 0x01DC, 0x01F5,//20
0x020E, 0x0227, 0x0240, 0x0258, 0x0271, 0x028A, 0x02A3, 0x02BC, 0x02D4, 0x02ED,//30
0x0306, 0x031F, 0x0337, 0x0350, 0x0368, 0x0381, 0x0399, 0x03B2, 0x03CA, 0x03E3,//40
0x03FB, 0x0413, 0x042C, 0x0444, 0x045C, 0x0474, 0x048C, 0x04A4, 0x04BC, 0x04D4,//50
0x04EC, 0x0504, 0x051C, 0x0534, 0x054C, 0x0563, 0x057B, 0x0593, 0x05AA, 0x05C2,//60
0x05D9, 0x05F0, 0x0608, 0x061F, 0x0636, 0x064D, 0x0664, 0x067B, 0x0692, 0x06A9,//70
0x06C0, 0x06D7, 0x06ED, 0x0704, 0x071B, 0x0731, 0x0747, 0x075E, 0x0774, 0x078A,//80
0x07A0, 0x07B6, 0x07CC, 0x07E2, 0x07F8, 0x080E, 0x0824, 0x0839, 0x084F, 0x0864,//90
0x087A, 0x088F, 0x08A4, 0x08B9, 0x08CE, 0x08E3, 0x08F8, 0x090D, 0x0921, 0x0936,//100
0x094A, 0x095F, 0x0973, 0x0987, 0x099C, 0x09B0, 0x09C4, 0x09D7, 0x09EB, 0x09FF,//110
0x0A12, 0x0A26, 0x0A39, 0x0A4D, 0x0A60, 0x0A73, 0x0A86, 0x0A99, 0x0AAB, 0x0ABE,//120
0x0AD1, 0x0AE3, 0x0AF6, 0x0B08, 0x0B1A, 0x0B2C, 0x0B3E, 0x0B50, 0x0B61, 0x0B73,//130
0x0B85, 0x0B96, 0x0BA7, 0x0BB8, 0x0BC9, 0x0BDA, 0x0BEB, 0x0BFC, 0x0C0C, 0x0C1D,//140
0x0C2D, 0x0C3E, 0x0C4E, 0x0C5E, 0x0C6E, 0x0C7D, 0x0C8D, 0x0C9C, 0x0CAC, 0x0CBB,//150
0x0CCA, 0x0CD9, 0x0CE8, 0x0CF7, 0x0D06, 0x0D14, 0x0D23, 0x0D31, 0x0D3F, 0x0D4D,//160
0x0D5B, 0x0D69, 0x0D76, 0x0D84, 0x0D91, 0x0D9F, 0x0DAC, 0x0DB9, 0x0DC6, 0x0DD2,//170
0x0DDF, 0x0DEB, 0x0DF8, 0x0E04, 0x0E10, 0x0E1C, 0x0E28, 0x0E33, 0x0E3F, 0x0E4A,//180
0x0E55, 0x0E60, 0x0E6B, 0x0E76, 0x0E81, 0x0E8B, 0x0E96, 0x0EA0, 0x0EAA, 0x0EB4,//190
0x0EBE, 0x0EC8, 0x0ED1, 0x0EDB, 0x0EE4, 0x0EED, 0x0EF6, 0x0EFF, 0x0F07, 0x0F10,//200
0x0F18, 0x0F21, 0x0F29, 0x0F31, 0x0F39, 0x0F40, 0x0F48, 0x0F4F, 0x0F56, 0x0F5D,//210
0x0F64, 0x0F6B, 0x0F72, 0x0F78, 0x0F7F, 0x0F85, 0x0F8B, 0x0F91, 0x0F96, 0x0F9C,//220
0x0FA1, 0x0FA7, 0x0FAC, 0x0FB1, 0x0FB6, 0x0FBA, 0x0FBF, 0x0FC3, 0x0FC7, 0x0FCB,//230
0x0FCF, 0x0FD3, 0x0FD7, 0x0FDA, 0x0FDE, 0x0FE1, 0x0FE4, 0x0FE7, 0x0FE9, 0x0FEC,//240
0x0FEE, 0x0FF0, 0x0FF2, 0x0FF4, 0x0FF6, 0x0FF8, 0x0FF9, 0x0FFB, 0x0FFC, 0x0FFD,//250
0x0FFE, 0x0FFE, 0x0FFF, 0x0FFF, 0x0FFF, 0x0FFF};
//256
/****************************************************
Function name: Em_Sin
description:
calculate sin(theta)
input:
Angle(0x3FFFFF
equal
one Cycle
output:
****************************************************/
signed long Em_Sin(unsigned long Angle)
{
unsigned long AngleTemp;
signed long SineValue;
AngleTemp =
Angle >> 12;
AngleTemp &= 0x03FF;
//0~1024
if (AngleTemp <= 256)
{
SineValue = SinTbl[AngleTemp];
}
else if (AngleTemp <= 512)
{
AngleTemp = 512 - AngleTemp;
SineValue = SinTbl[AngleTemp];
}
else if (AngleTemp <= 768)
{
AngleTemp -= 512;
SineValue = -SinTbl[AngleTemp];
}
else if (AngleTemp <= 1024)
{
AngleTemp = 1024 - AngleTemp;
SineValue = -SinTbl[AngleTemp];
}
return (SineValue);
}

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
%% 结构体初始化
%%
def = legacy_code('initialize');
%% 涉及到的.c .h路径
%%
% def.IncPaths = '';
% def.SrcPaths = '';
%% 头文件和源文件
%%
def.SourceFiles
= {'EmMath.c'};
def.HeaderFiles
= {'EmMath.h'};
%% 生成的S-Function模块名称
%%
def.SFunctionName = 'sfun_Em_Math';
%% 输出函数名称，和C源码相同
%%
def.OutputFcnSpec
= 'int32 y1 = Em_Sin(uint32 u1)';
%% 创建C mex S函数文件
%%
legacy_code('sfcn_cmex_generate', def);
%% 生成MEXW64可执行文件，用于Simulink仿真
%%
legacy_code('compile', def);
%% 封装Sfunction
%%
%legacy_code('slblock_generate', def, '保存的模块名');
legacy_code('slblock_generate', def);
%Untitle
%% 生成TLC文件用于代码生成
%%
legacy_code('sfcn_tlc_generate', def);

1
2
3
4
5
stop_time = get_param(gcs, 'StopTime');
simin.time = [0:str2num(stop_time)]';
simin.signals.values = [0:length(simin.time) - 1]';
simin.signals.demensions = [length(simin.time) 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
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
#include <DAC_TLC5615.h>
void Delay_us(unsigned char count)
{
while(count--);
}
/******************************************************************************
* Function: DacGpioInit
* Description: Dac gpio initialize function;
* Calls: none;
* Called By: main;
* Input: none;
* Output: none;
* Return: none;
* Others: none;
*****************************************************************************/
void DacGpioInit(void)
{
EALLOW;
/* CS pin */
GpioCtrlRegs.GPBMUX2.bit.GPIO57 = 0;
GpioCtrlRegs.GPBDIR.bit.GPIO57 = 1;
GpioDataRegs.GPBDAT.bit.GPIO57 = 1;
// Set CS pin;
/* SDA pin */
GpioCtrlRegs.GPBMUX2.bit.GPIO54 = 0;
GpioCtrlRegs.GPBDIR.bit.GPIO54 = 1;
// Direction = Output;
GpioDataRegs.GPBDAT.bit.GPIO54 = 1;
//
/* SCL pin */
GpioCtrlRegs.GPBMUX2.bit.GPIO56 = 0;
GpioCtrlRegs.GPBDIR.bit.GPIO56 = 1;
GpioDataRegs.GPBDAT.bit.GPIO56 = 1;
// Set SCL pin;
EDIS;
}
/**********************
end of DacGpioInit function
************************/
/******************************************************************************
* Function: DacDataOut
* Description: Dac data output function;
* Calls: Delay_us;
* Called By: main;
* Input: ui16_Input, Range: 0 ~ 1024, Step: 1;
* Output: none;
* Return: none;
* Others: TLC5615;
*****************************************************************************/
void DacDataOut(int ui16_Input,int Channel_Select)
{
Uint16 lui16_Input = 0;
Uint16 lui16_Daci = 0;
lui16_Input = ui16_Input;
lui16_Input = lui16_Input << 6;
// ֻ������ʮλ
if(Channel_Select==0)
{
DAC_CS_CLEAR;
// ƬѡDAC1оƬ
Delay_us(1);
DAC_SCL_CLEAR;
for (lui16_Daci = 0; lui16_Daci < 12; lui16_Daci ++)
// 12 data bits;
{
if ((lui16_Input & 0x8000) == 0x8000)
// ȡ���ݵ����λ
{
DAC_SDA_SET;
}
else
{
DAC_SDA_CLEAR;
}
Delay_us(1);
DAC_SCL_SET;
// ��SCL�������ش�������
lui16_Input = lui16_Input << 1;
// ����һλ
DAC_SCL_CLEAR;
Delay_us(1);
}
DAC_CS_SET;
Delay_us(1);
DAC_SCL_CLEAR;
}
}
/***********************
end of DacDataOut function
************************/

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
#ifndef DAC_TLC5615_H_
#define DAC_TLC5615_H_
#include "DSP2833x_Device.h"
#include "DSP2833x_Examples.h"
#define
DAC_CS_CLEAR
GpioDataRegs.GPBCLEAR.bit.GPIO57 = 1
#define
DAC_CS_SET
GpioDataRegs.GPBSET.bit.GPIO57= 1
#define
DAC_SDA_CLEAR
GpioDataRegs.GPBCLEAR.bit.GPIO54 = 1
#define
DAC_SDA_SET
GpioDataRegs.GPBSET.bit.GPIO54 = 1
#define
DAC_SCL_CLEAR
GpioDataRegs.GPBCLEAR.bit.GPIO56 = 1
#define
DAC_SCL_SET
GpioDataRegs.GPBSET.bit.GPIO56 = 1
extern void DacGpioInit(void);
extern void DacDataOut(Uint16 ui16_Input,Uint16 Channel_Select);
#endif

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
%结构体初始化
def= legacy_code('initialize')
%设计到的.c以及.h地址
%
def.IncPaths=""
%
def.SrcPaths=""
%驱动源码 以及头文件
%def.SourceFiles={''};
def.SourceFiles={'DAC_TLC5615.c'};
def.HeaderFiles={'DAC_TLC5615.h'};
%S-function 名称
def.SFunctionName='DAC_5615_Driver';
%初始化函数名称
和C源码相同
可选
def.InitializeConditionsFcnSpec='void DacGpioInit(void)';
%输出函数名称 和C源码内容相同
def.OutputFcnSpec='void DacDataOut(uint16 u1,uint16 u2)';
%创建.c文件 S funciton
c文件 LEVEL-2
legacy_code('sfcn_cmex_generate',def)
%生成MEXW64可执行文件名称 用于simulink仿真
legacy_code('compile',def)
%封装S-FUNCTION
legacy_code('slblock_generate',def)
%生成代码生成必要的TLC文件---模块TLC
legacy_code('sfcn_tlc_generate',def)