tfuntmpl.m

(./tfuntmpl.m)

Function Synopsis

[sys,x0,str,ts] = tfuntmpl(t,x,u,flag,tmxh,tmxp)

Help text

 TSFUNTMPL General M-file T-function template

 T-FUNCTION Instructions:
   This is a modified version of the Matlab file sfuntmpl. It shows a
   general approach for integrating tempus mex-systems as m-file
   s-functions within Simulink. Not all features of an s-function
   will be supported in Simulink and not all features of tempus will
   be supported by Simulink. This file provides a guide to implementing
   t-functions. The user should search for all occurrences of the 
   string "T-FUNCTION" to find those sections of comments which pertain
   to using mex-systems as t-functions.

   To use this template take the following steps:
      1. Using the tempus tve, create a mex-system with parameters,
         inputs, and outputs which are to be mapped to t-function
         parameters, inputs, and outputs.
      2. Compile the mex-system using tmxmkdll.
      3. Edit this file, following the instructions marked by "T-FUNCTION".
      4. Save the edited file using a unique t-function name (above) and
         filename in a directory which will be in the Matlab path.
      5. Insert an s-function block into a Simulink block diagram,
         specifying the appropriate parameters and connecting the
         inputs and outputs as planned.
      6. Execute the resulting Simulink system.

   It is generally necessary that in order to write a t-function, the
   user understand how to write an s-function. So the t-function
   documentation must be taken in the context of the s-function documentation
   provided by Matlab.

   Note: It is not possible to use two instances of a mex-system
      simultaneously. To use multiple instances of mex-systems and 
      related t-functions, the user must artificially create separate
      .dll and .m files for each and insert them in the Simulink block
      diagram as if they were distinct systems.
 End T-FUNCTION Instructions

   With M-file S-functions, you can define you 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 M-File T-function syntax is:
       [SYS,X0,STR,TS] = SFUNC(T,X,U,FLAG,TMXH,TMXP)

   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 consists 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 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].

 T-FUNCTION Documentation:
      TMXH   = The runset name of a mex-system for which a valid mex-system
               .dll exists in the path or a valid tmx_handle created by a
               call to tmxcreate.
      TMXP   = A tmx_param structure to be used to initialized the mex-system
               to be used to execute this t-function. TMXP is only used if
               TMXH is a runset name and not a tmx_handle. If TMXH is a
               tmx_handle then the parameters were already specified during
               the associated call to tmxcreate.If TMXH is a runset name and
               TMXP is not specified, then the default parameter settings
               are used. The user may put additional data into this structure
               in order to enable processing options in the t-function. However,
               after the system has been initialized, the original structure
               will be stored in TMXP.tfunparams and the rest of the structure
               is returned from a call to tmxcompparams.
 End T-FUNCTION Documentation: