simstruc_types.h

simulink应用实例

#define rtliGetLogY(rtli)     (rtli)->logY
#define rtliSetLogY(rtli,ly)  (rtli)->logY = (ly)

#define rtliGetLogXFinal(rtli)     (rtli)->logXFinal
#define rtliSetLogXFinal(rtli,lxf) (rtli)->logXFinal = (lxf)

#define rtliGetLogXSignalInfo(rtli)     (rtli)->logXSignalInfo
#define rtliSetLogXSignalInfo(rtli,lxi) (rtli)->logXSignalInfo = (lxi)
                                              
#define rtliGetLogYSignalInfo(rtli)     (rtli)->logYSignalInfo
#define rtliSetLogYSignalInfo(rtli,lyi) (rtli)->logYSignalInfo = (lyi)

#define rtliGetLogXSignalPtrs(rtli)     (rtli)->logXSignalPtrs
#define rtliSetLogXSignalPtrs(rtli,lxp) (rtli)->logXSignalPtrs = (lxp)

#define rtliGetLogYSignalPtrs(rtli)     (rtli)->logYSignalPtrs
#define rtliSetLogYSignalPtrs(rtli,lyp) (rtli)->logYSignalPtrs = (lyp)
/* ========================================================================== */

/* =============================================================================
 * External mode object
 * =============================================================================
 */
typedef struct _RTWExtModeInfo_tag {

    void *subSysModeVectorAddr;    /* Array of addresses points to
                                    * the mode vector slots for enabled 
                                    * sub-systems. Enabled sub-systems store
                                    * information about their enabled state 
                                    * in thier mode vector.
                                    */
    uint32_T *checksumsPtr;        /* Pointer to the model's checksums array
                                    */
    const void **mdlMappingInfoPtr;/* Pointer to the model's mapping info
                                    * pointer
                                    */
    void       *tPtr;              /* Copy of model's time pointer
                                    */
} RTWExtModeInfo;

#define rteiSetSubSystemModeVectorAddresses(E,addr) \
        (E)->subSysModeVectorAddr = ((void *)addr)
#define rteiGetSubSystemModeVectorAddresses(E) \
        (E)->subSysModeVectorAddr
#define rteiGetAddrOfSubSystemModeVector(E,idx) \
        ((int_T*)((int8_T**)((E)->subSysModeVectorAddr))[idx])

#define rteiSetModelMappingInfoPtr(E,mip) \
        (E)->mdlMappingInfoPtr = (mip)
#define rteiGetModelMappingInfo(E) (*((E)->mdlMappingInfoPtr))

#define rteiSetChecksumsPtr(E,cp) \
        (E)->checksumsPtr = (cp)
#define rteiGetChecksum0(E) (E)->checksumsPtr[0]
#define rteiGetChecksum1(E) (E)->checksumsPtr[1]
#define rteiGetChecksum2(E) (E)->checksumsPtr[2]
#define rteiGetChecksum3(E) (E)->checksumsPtr[3]

#define rteiSetTPtr(E,p) (E)->tPtr = (p)
#define rteiGetT(E)      ((time_T *)(E)->tPtr)[0]

/* ========================================================================== */

/* =============================================================================
 * Model methods object
 * =============================================================================
 */
typedef void (*rtMdlInitializeSizesFcn)(void *rtModel);
typedef void (*rtMdlInitializeSampleTimesFcn)(void *rtModel);
typedef void (*rtMdlStartFcn)(void *rtModel);
typedef void (*rtMdlOutputsFcn)(void *rtModel, int_T tid);
typedef void (*rtMdlUpdateFcn)(void *rtModel, int_T tid);
typedef void (*rtMdlDerivativesFcn)(void *rtModel);
typedef void (*rtMdlProjectionFcn)(void *rtModel);
typedef void (*rtMdlTerminateFcn)(void *rtModel);

typedef struct _RTWRTModelMethodsInfo_tag {
    void                          *rtModelPtr;
    rtMdlInitializeSizesFcn       rtmInitSizesFcn;
    rtMdlInitializeSampleTimesFcn rtmInitSampTimesFcn;
    rtMdlStartFcn                 rtmStartFcn;
    rtMdlOutputsFcn               rtmOutputsFcn;
    rtMdlUpdateFcn                rtmUpdateFcn;
    rtMdlDerivativesFcn           rtmDervisFcn;
    rtMdlProjectionFcn            rtmProjectionFcn;
    rtMdlTerminateFcn             rtmTerminateFcn;
} RTWRTModelMethodsInfo;

#define rtmiSetRTModelPtr(M,rtmp) (M).rtModelPtr = (rtmp)
#define rtmiGetRTModelPtr(M)      (M).rtModelPtr

#define rtmiSetInitSizesFcn(M,fp) \
  (M).rtmInitSizesFcn = ((rtMdlInitializeSizesFcn)(fp))
#define rtmiSetInitSampTimesFcn(M,fp) \
  (M).rtmInitSampTimesFcn = ((rtMdlInitializeSampleTimesFcn)(fp))
#define rtmiSetStartFcn(M,fp) \
  (M).rtmStartFcn = ((rtMdlStartFcn)(fp))
#define rtmiSetOutputsFcn(M,fp) \
  (M).rtmOutputsFcn = ((rtMdlOutputsFcn)(fp))
#define rtmiSetUpdateFcn(M,fp) \
  (M).rtmUpdateFcn = ((rtMdlUpdateFcn)(fp))
#define rtmiSetDervisFcn(M,fp) \
  (M).rtmDervisFcn = ((rtMdlDerivativesFcn)(fp))
#define rtmiSetProjectionFcn(M,fp) \
  (M).rtmProjectionFcn = ((rtMdlProjectionFcn)(fp))
#define rtmiSetTerminateFcn(M,fp) \
  (M).rtmTerminateFcn = ((rtMdlTerminateFcn)(fp))

#define rtmiInitializeSizes(M) \
         (*(M).rtmInitSizesFcn)((M).rtModelPtr)
#define rtmiInitializeSampleTimes(M) \
         (*(M).rtmInitSampTimesFcn)((M).rtModelPtr)
#define rtmiStart(M) \
         (*(M).rtmStartFcn)((M).rtModelPtr)
#define rtmiOutputs(M, tid) \
         (*(M).rtmOutputsFcn)((M).rtModelPtr,tid)
#define rtmiUpdate(M, tid) \
        (*(M).rtmUpdateFcn)((M).rtModelPtr,tid)
#define rtmiDerivatives(M) \
         (*(M).rtmDervisFcn)((M).rtModelPtr)
#define rtmiProjection(M) \
         (*(M).rtmProjectionFcn)((M).rtModelPtr)
#define rtmiTerminate(M) \
         (*(M).rtmTerminateFcn)((M).rtModelPtr)

/* ========================================================================== */

/* =============================================================================
 * Solver object
 * =============================================================================
 */
#ifndef NO_FLOATS /* Needed because ERT code may be integer-only */

typedef struct _RTWSolverInfo_tag {
    void        *rtModelPtr;

    SimTimeStep *simTimeStepPtr;
    void        *solverData;
    const char  *solverName;
    boolean_T   isVariableStepSolver;
    boolean_T   solverNeedsReset;
    SolverMode  solverMode;

    time_T      solverStopTime;
    time_T      *stepSizePtr;
    time_T      minStepSize;
    time_T      maxStepSize;
    time_T      fixedStepSize;

    int_T       maxNumMinSteps;
    int_T       solverMaxOrder;

    int_T       solverRefineFactor;
    real_T      solverRelTol;
    real_T      solverAbsTol;
    
    real_T      **dXPtr;
    time_T      **tPtr;

    int_T       *numContStatesPtr;
    real_T      **contStatesPtr;
    
    const char_T **errStatusPtr;

    RTWRTModelMethodsInfo *modelMethodsPtr;
} RTWSolverInfo;

#define rtsiSetRTModelPtr(S,rtmp) (S)->rtModelPtr = (rtmp)
#define rtsiGetRTModelPtr(S)      (S)->rtModelPtr

#define rtsiSetSimTimeStepPtr(S,stp) (S)->simTimeStepPtr = (stp)
#define rtsiGetSimTimeStep(S)        *((S)->simTimeStepPtr)
#define rtsiSetSimTimeStep(S,st)     *((S)->simTimeStepPtr) = (st)

#define rtsiSetSolverData(S,sd) (S)->solverData = (sd)
#define rtsiGetSolverData(S)    (S)->solverData

#define rtsiSetSolverName(S,sn) (S)->solverName = (sn)
#define rtsiGetSolverName(S)    (S)->solverName

#define rtsiSetVariableStepSolver(S,vs) (S)->isVariableStepSolver = (vs)
#define rtsiIsVariableStepSolver(S)     (S)->isVariableStepSolver

#define rtsiSetSolverNeedsReset(S,sn) (S)->solverNeedsReset = (sn)
#define rtsiGetSolverNeedsReset(S)    (S)->solverNeedsReset

#define rtsiSetSolverMode(S,sm) (S)->solverMode = (sm)
#define rtsiGetSolverMode(S)    (S)->solverMode

#define rtsiSetSolverStopTime(S,st) (S)->solverStopTime = (st)
#define rtsiGetSolverStopTime(S)    (S)->solverStopTime

#define rtsiSetStepSizePtr(S,ssp) (S)->stepSizePtr = (ssp)
#define rtsiSetStepSize(S,ss)     *((S)->stepSizePtr) = (ss)
#define rtsiGetStepSize(S)        *((S)->stepSizePtr)

#define rtsiSetMinStepSize(S,ss) (S)->minStepSize = (ss)
#define rtsiGetMinStepSize(S)    (S)->minStepSize

#define rtsiSetMaxStepSize(S,ss) (S)->maxStepSize = (ss)
#define rtsiGetMaxStepSize(S)    (S)->maxStepSize

#define rtsiSetFixedStepSize(S,ss) (S)->fixedStepSize = (ss)
#define rtsiGetFixedStepSize(S)    (S)->fixedStepSize

#define rtsiSetMaxNumMinSteps(S,mns) (S)->maxNumMinSteps = (mns)
#define rtsiGetMaxNumMinSteps(S)     (S)->maxNumMinSteps

#define rtsiSetSolverMaxOrder(S,smo) (S)->solverMaxOrder = (smo)
#define rtsiGetSolverMaxOrder(S)     (S)->solverMaxOrder

#define rtsiSetSolverRefineFactor(S,smo) (S)->solverRefineFactor = (smo)
#define rtsiGetSolverRefineFactor(S)     (S)->solverRefineFactor

#define rtsiSetSolverRelTol(S,smo) (S)->solverRelTol = (smo)
#define rtsiGetSolverRelTol(S)     (S)->solverRelTol

#define rtsiSetSolverAbsTol(S,smo) (S)->solverAbsTol = (smo)
#define rtsiGetSolverAbsTol(S)     (S)->solverAbsTol

#define rtsiSetdXPtr(S,dxp) (S)->dXPtr = (dxp)
#define rtsiSetdX(S,dx)     *((S)->dXPtr) = (dx)
#define rtsiGetdX(S)        *((S)->dXPtr)

#define rtsiSetTPtr(S,tp) (S)->tPtr = (tp)
#define rtsiSetT(S,t)     (*((S)->tPtr))[0] = (t)
#define rtsiGetT(S)       (*((S)->tPtr))[0]

#define rtsiSetContStatesPtr(S,cp) (S)->contStatesPtr = (cp)
#define rtsiGetContStates(S)       *((S)->contStatesPtr)

#define rtsiSetNumContStatesPtr(S,cp) (S)->numContStatesPtr = (cp)
#define rtsiGetNumContStates(S)       *((S)->numContStatesPtr)

#define rtsiSetErrorStatusPtr(S,esp) (S)->errStatusPtr = (esp)
#define rtsiSetErrorStatus(S,es) *((S)->errStatusPtr) = (es)
#define rtsiGetErrorStatus(S)    *((S)->errStatusPtr)

#define rtsiSetModelMethodsPtr(S,mmp) (S)->modelMethodsPtr = (mmp)
#define rtsiGetModelMethodsPtr(S)     (S)->modelMethodsPtr

#endif /* !NO_FLOATS */

/* ========================================================================== */

/* 
 * Lightweight structure for holding a real, sparse matrix
 * as used by the analytical Jacobian methods.  
 */
typedef struct SparseHeader_Tag {
    int_T   mRows;                  /* number of rows   */
    int_T   nCols;                  /* number of cols   */
    int_T   nzMax;                  /* size of *pr, *ir */
    int_T   *Ir;                    /* row indices      */
    int_T   *Jc;                    /* column offsets   */
#ifndef NO_FLOATS
    real_T  *Pr;                    /* nonzero entries  */
#else
    void    *Pr;
#endif
} SparseHeader;

/*========================*
 * Setup for multitasking *
 *========================*/

/*
 * Let MT be synonym for MULTITASKING (to shorten command line for DOS)
 */
#if defined(MT)
# if MT == 0
#   undef MT
# else
#   define MULTITASKING 1
# endif
#endif

#if defined(MULTITASKING) && MULTITASKING == 0
# undef MULTITASKING
#endif

#if defined(MULTITASKING) && !defined(TID01EQ)
# define TID01EQ 0
#endif

/*
 * Undefine MULTITASKING if there is only one task or there are two
 * tasks and the sample times are equal (case of continuous and one discrete
 * with equal rates).
 */
#if defined(NUMST) && defined(MULTITASKING)
# if NUMST == 1 || (NUMST == 2 && TID01EQ == 1)
#  undef MULTITASKING
# endif
#endif

#endif /* __SIMSTRUC_TYPES_H__ */