I feel that s-function is functionally the same as the function implemented by defining static variables in matlab function. The derivation of case1 of the s-function continuous system to update the continuous variables and the update of the discrete state variables of the discrete system case2 should also be achieved by defining static variables in the matlab function.
However, s-function standardizes the entire process and encapsulates the derivation or integration of case1 into library functions, which simplifies the development process.
Using continuous case1, it is easy to implement the integration link. The differential link can be realized by adding static variables to output. Discretizing continuous functions can be achieved using discrete s-functions. What the s function discretely updates the state function passes out is the next state of the state variable.
c-script is written in c language.
1 matlab function
Matlab function defines static variables:
persistent t1; if isempty(t1) t1=0; end
2 s-function
For continuous systems, the core is the derivative function of case1. The output of this function is the derivative value in the expression. This function updates the state variable.
For discrete systems, the core is the discrete state update of case1, where discrete state variables are updated.
function [sys,x0,str,ts,simStateCompliance] = my_sfuntmpl(t,x,u,flag)%%The function name and file name must be the same, t is the simulation time; x is the state, which is an n-dimensional column Vector; u is the input, which is also an n-dimensional column vector, u(1), u(2)...
%%flag is a flag
%SFUNTMPL General MATLAB S-Function Template
% With MATLAB S-functions, you can define your own ordinary differential
% equations (ODEs), discrete system equations, and/or just about
% any type of algorithm to be used within a Simulink block diagram.
%
% The general form of an MATLAB S-function syntax is:
% [SYS,X0,STR,TS,SIMSTATECOMPLIANCE] = SFUNC(T,X,U,FLAG,P1,...,Pn)
%
% What is returned by SFUNC at a given point in time, T, depends on the
% value of the FLAG, the current state vector, X, and the current
% input vector, U.
%
% FLAG RESULT DESCRIPTION
% ----- ------ ----------------------------------------- ------
% 0 [SIZES,X0,STR,TS] Initialization, return system sizes in SYS,
% initial state in X0, state ordering strings
% in STR, and sample times in TS.
% 1 DX Return continuous state derivatives in SYS.
% 2 DS Update discrete states SYS = X(n + 1)
% 3 Y Return outputs in SYS.
% 4 TNEXT Return next time hit for variable step sample
% time in SYS.
% 5 Reserved for future (root finding).
% 9 [] Termination, perform any cleanup SYS=[].
%
%
% The state vectors, X and X0 consist of continuous states followed
% by discrete states.
%
% Optional parameters, P1,...,Pn can be provided to the S-function and
% used during any FLAG operation.
%
% When SFUNC is called with FLAG = 0, the following information
% should be returned:
%
% SYS(1) = Number of continuous states.
% SYS(2) = Number of discrete states.
% SYS(3) = Number of outputs.
% SYS(4) = Number of inputs.
% Any of the first four elements in SYS can be specified
% as -1 indicating that they are dynamically sized. The
% actual length for all other flags will be equal to the
% length of the input, U.
% SYS(5) = Reserved for root finding. Must be zero.
% SYS(6) = Direct feedthrough flag (1=yes, 0=no). The s-function
% has direct feedthrough if U is used during the FLAG=3
% call. Setting this to 0 is akin to making a promise that
% U will not be used during FLAG=3. If you break the promise
% then unpredictable results will occur.
% SYS(7) = Number of sample times. This is the number of rows in TS.
%
%
% X0 = Initial state conditions or [] if no states.
%
% STR = State ordering strings which is generally specified as [].
%
% TS = An m-by-2 matrix containing the sample time
% (period, offset) information. Where m = number of sample
% times. The ordering of the sample times must be:
%
% TS = [0 0, : Continuous sample time.
% 0 1, : Continuous, but fixed in minor step
% sample time.
% PERIOD OFFSET, : Discrete sample time where
% PERIOD > 0 & OFFSET < PERIOD.
% -2 0]; : Variable step discrete sample time
% where FLAG=4 is used to get time of
% next hit.
%
% There can be more than one sample time providing
% they are ordered such that they are monotonically
% increasing. Only the needed sample times should be
% specified in TS. When specifying more than one
% sample time, you must check for sample hits explicitly by
% seeing if
% abs(round((T-OFFSET)/PERIOD) - (T-OFFSET)/PERIOD)
% is within a specified tolerance, generally 1e-8. This
% tolerance is dependent upon your model's sampling times
% and simulation time.
%
% You can also specify that the sample time of the S-function
% is inherited from the driving block. For functions which
% change during minor steps, this is done by
% specifying SYS(7) = 1 and TS = [-1 0]. For functions which
% are held during minor steps, this is done by specifying
% SYS(7) = 1 and TS = [-1 1].
%
% SIMSTATECOMPLIANCE = Specifices how to handle this block when saving and
% restoring the complete simulation state of the
% model. The allowed values are: 'DefaultSimState',
% 'HasNoSimState' or 'DisallowSimState'. If this value
% is not speficified, then the block's compliance with
% simState feature is set to 'UknownSimState'.
% Copyright 1990-2010 The MathWorks, Inc.
%
% The following outlines the general structure of an S-function.
%
switch flag,
%%%%%%%%%%%%%%%%%
%Initialization%
%%%%%%%%%%%%%%%%%
case 0,
[sys,x0,str,ts,simStateCompliance]=mdlInitializeSizes;%%flag=0 calls the initialization function
%%%%%%%%%%%%%%
% Derivatives %
%%%%%%%%%%%%%%
case 1,
sys=mdlDerivatives(t,x,u);%%flag=1, perform derivatives, continuous simulation state variables are derived
%%%%%%%%%
% Update %
%%%%%%%%%
Case 2, %%flag=2, is used by discrete systems to update the state. For state variables, the discrete state updates the state every sampling period.
sys=mdlUpdate(t,x,u);
%%%%%%%%%%
%Outputs%
%%%%%%%%%%
case 3,%%flag=3, set the output
sys=mdlOutputs(t,x,u);
%%%%%%%%%%%%%%%%%%%%%
% GetTimeOfNextVarHit %
%%%%%%%%%%%%%%%%%%%%%
case 4,%%flag=4, the discrete system calculates the next sampling time point
sys=mdlGetTimeOfNextVarHit(t,x,u);
%%%%%%%%%%%%
% Terminate %
%%%%%%%%%%%%
case 9,%% model termination
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 %%This function is used to initialize the model and is required.
%
% call simsizes for a sizes structure, fill it in and convert it to a
% sizes array.
%
% Note that in this example, the values are hard coded. This is not a
% recommended practice as the characteristics of the block are typically
% defined by the S-function parameters.
%
sizes = simsizes;
sizes.NumContStates = 0;%%Number of continuous state variables
sizes.NumDiscStates = 0;%%Number of discrete state variables
sizes.NumOutputs = 0;%%Number of outputs
sizes.NumInputs = 0;%%Number of inputs
sizes.DirFeedthrough = 1;%%1 indicates that there is direct feedthrough. Direct feedthrough refers to directly adding or subtracting input to the output item, that is, directly adding the input to the output.
sizes.NumSampleTimes = 1; % at least one sample time is needed %%
sys = simsizes(sizes);
%
% initialize the initial conditions
%
x0 = [];%%This is to initialize the state variables. There are several state variables, and there are several initial values in square brackets.
%
% str is always an empty matrix
%
str = [];
%
% initialize the array of sample times
%
ts = [0 0];%%The first zero represents the sampling time, indicating continuous sampling; the second zero represents the offset. ts=[t1,t2], means starting from t2, sampling every t1
% 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)%% is below
sys = [];%%Write the output value of the function in the brackets, that is, the variable with the dotted derivative above in the expression
% end mdlDerivatives
%
%================================================== ============================
% mdlUpdate
% Handle discrete state updates, sample time hits, and major time step
% requirements.
%================================================== ============================
%
function sys=mdlUpdate(t,x,u)
sys = [];
% end mdlUpdate
%
%================================================== ============================
%mdlOutputs
% Return the block outputs.
%================================================== ============================
%
function sys=mdlOutputs(t,x,u)
sys = [];
% 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
The following is the discrete pid built by plecs’ c-script
The knowledge points of the article match the official knowledge files, and you can further learn related knowledge. Algorithm skill tree Home page Overview 56938 people are learning the system