Документация

### Starting build procedure for: rtwdemo_basicsc
### Successful completion of build procedure for: rtwdemo_basicsc

/* Block signals (default storage) */
typedef struct {
  real32_T Table1;                     /* '<Root>/Table1' */
  real32_T Gain;                       /* '<Root>/Gain' */
  real32_T Delay;                      /* '<Root>/Delay' */
  real32_T Table2;                     /* '<Root>/Table2' */
  boolean_T RelOp1;                    /* '<Root>/RelOp1' */
  boolean_T RelOp2;                    /* '<Root>/RelOp2' */
  boolean_T LogOp;                     /* '<Root>/LogOp' */
} B_rtwdemo_basicsc_T;

/* Parameters (default storage) */
struct P_rtwdemo_basicsc_T_ {
  real_T K2;                           /* Variable: K2
                                        * Referenced by: '<Root>/Stateflow Chart'
                                        */
  real32_T LOWER;                      /* Variable: LOWER
                                        * Referenced by: '<Root>/Constant2'
                                        */
  real32_T T1Break[11];                /* Variable: T1Break
                                        * Referenced by: '<Root>/Table1'
                                        */
  real32_T T1Data[11];                 /* Variable: T1Data
                                        * Referenced by: '<Root>/Table1'
                                        */
  real32_T T2Break[3];                 /* Variable: T2Break
                                        * Referenced by: '<Root>/Table2'
                                        */
  real32_T T2Data[9];                  /* Variable: T2Data
                                        * Referenced by: '<Root>/Table2'
                                        */
  real32_T UPPER;                      /* Variable: UPPER
                                        * Referenced by: '<Root>/Constant1'
                                        */
  real32_T Gain_Gain;                  /* Computed Parameter: Gain_Gain
                                        * Referenced by: '<Root>/Gain'
                                        */
  real32_T Delay_InitialCondition; /* Computed Parameter: Delay_InitialCondition
                                    * Referenced by: '<Root>/Delay'
                                    */
  uint32_T Table2_maxIndex[2];         /* Computed Parameter: Table2_maxIndex
                                        * Referenced by: '<Root>/Table2'
                                        */
  boolean_T DataStoreMemory_InitialValue;
                             /* Computed Parameter: DataStoreMemory_InitialValue
                              * Referenced by: '<Root>/Data Store Memory'
                              */
};

/* Block signals (default storage) */
B_rtwdemo_basicsc_T rtwdemo_basicsc_B;

### Starting build procedure for: rtwdemo_basicsc
### Successful completion of build procedure for: rtwdemo_basicsc

/* Block signals (default storage) */
typedef struct {
  real32_T Gain;                       /* '<Root>/Gain' */
} B_rtwdemo_basicsc_T;

/* Parameters (default storage) */
struct P_rtwdemo_basicsc_T_ {
  real32_T K1;                         /* Variable: K1
                                        * Referenced by: '<Root>/Gain'
                                        */
};

### Starting build procedure for: rtwdemo_basicsc
### Successful completion of build procedure for: rtwdemo_basicsc

/* Block output signal information */
static const rtwCAPI_Signals rtBlockSignals[] = {
  /* addrMapIndex, sysNum, blockPath,
   * signalName, portNumber, dataTypeIndex, dimIndex, fxpIndex, sTimeIndex
   */
  { 0, 0, TARGET_STRING("rtwdemo_basicsc/Gain"),
    TARGET_STRING(""), 0, 0, 0, 0, 0 },

  {
    0, 0, (NULL), (NULL), 0, 0, 0, 0, 0
  }
};

  /* user code (Output function Body) */

  /* System '<Root>' */
  {
    rtwdemo_basicsc_U.input2++;
    rtwCAPI_ModelMappingInfo *MMI = &(rtmGetDataMapInfo(rtwdemo_basicsc_M).mmi);
    tuneFcn(MMI, rtmGetTPtr(rtwdemo_basicsc_M));
  }

  /* DataStoreWrite: '<Root>/DSWrite' incorporates:
   *  Constant: '<Root>/Constant1'
   *  Constant: '<Root>/Constant2'
   *  Inport: '<Root>/In1'
   *  Logic: '<Root>/LogOp'
   *  RelationalOperator: '<Root>/RelOp1'
   *  RelationalOperator: '<Root>/RelOp2'
   */
  rtwdemo_basicsc_DW.mode = ((rtwdemo_basicsc_U.input1 > 10.0F) ||
    (rtwdemo_basicsc_U.input1 < -10.0F));

  /* Gain: '<Root>/Gain' incorporates:
   *  Inport: '<Root>/In2'
   *  Lookup_n-D: '<Root>/Table1'
   */
  rtwdemo_basicsc_B.Gain = rtwdemo_basicsc_P.K1 * look1_iflf_binlx
    (rtwdemo_basicsc_U.input2, rtCP_Table1_bp01Data, rtCP_Table1_tableData, 10U);

  /* Chart: '<Root>/Stateflow Chart' */
  /* Gateway: Stateflow Chart */
  /* During: Stateflow Chart */
  /* Entry Internal: Stateflow Chart */
  /* Transition: '<S1>:5' */
  if (rtwdemo_basicsc_DW.mode) {
    /* Transition: '<S1>:6' */
    /* Transition: '<S1>:2' */
    rtwdemo_basicsc_DW.X = rtwdemo_basicsc_B.Gain;
  } else {
    /* Transition: '<S1>:4' */
  }

  /* Outport: '<Root>/Out1' incorporates:
   *  Chart: '<Root>/Stateflow Chart'
   */
  /* Transition: '<S1>:3' */
  rtwdemo_basicsc_Y.Out1 = (real32_T)(rtwdemo_basicsc_DW.X * 3.0);

  /* Lookup_n-D: '<Root>/Table2' incorporates:
   *  Inport: '<Root>/In3'
   *  Inport: '<Root>/In4'
   */
  rtwdemo_basicsc_DW.X = look2_iflf_binlx(rtwdemo_basicsc_U.input3,
    rtwdemo_basicsc_U.input4, rtCP_Table2_bp01Data, rtCP_Table2_bp02Data,
    rtCP_Table2_tableData, rtCP_Table2_maxIndex, 3U);

  /* user code (Output function Trailer) */

  /* System '<Root>' */
  {
    rtwCAPI_ModelMappingInfo *MMI = &(rtmGetDataMapInfo(rtwdemo_basicsc_M).mmi);
    logFcn(MMI, rtmGetTPtr(rtwdemo_basicsc_M));
  }

  /* Matfile logging */
  rt_UpdateTXYLogVars(rtwdemo_basicsc_M->rtwLogInfo,
                      (&rtwdemo_basicsc_M->Timing.taskTime0));

  /* signal main to stop simulation */
  {                                    /* Sample time: [1.0s, 0.0s] */
    if ((rtmGetTFinal(rtwdemo_basicsc_M)!=-1) &&
        !((rtmGetTFinal(rtwdemo_basicsc_M)-rtwdemo_basicsc_M->Timing.taskTime0) >
          rtwdemo_basicsc_M->Timing.taskTime0 * (DBL_EPSILON))) {
      rtmSetErrorStatus(rtwdemo_basicsc_M, "Simulation finished");
    }
  }

  /* Update absolute time for base rate */
  /* The "clockTick0" counts the number of times the code of this task has
   * been executed. The absolute time is the multiplication of "clockTick0"
   * and "Timing.stepSize0". Size of "clockTick0" ensures timer will not
   * overflow during the application lifespan selected.
   * Timer of this task consists of two 32 bit unsigned integers.
   * The two integers represent the low bits Timing.clockTick0 and the high bits
   * Timing.clockTickH0. When the low bit overflows to 0, the high bits increment.
   */
  if (!(++rtwdemo_basicsc_M->Timing.clockTick0)) {
    ++rtwdemo_basicsc_M->Timing.clockTickH0;
  }

  rtwdemo_basicsc_M->Timing.taskTime0 = rtwdemo_basicsc_M->Timing.clockTick0 *
    rtwdemo_basicsc_M->Timing.stepSize0 + rtwdemo_basicsc_M->Timing.clockTickH0 *
    rtwdemo_basicsc_M->Timing.stepSize0 * 4294967296.0;
}

/* Model initialize function */
void rtwdemo_basicsc_initialize(void)
{
  /* Registration code */

  /* initialize non-finites */
  rt_InitInfAndNaN(sizeof(real_T));

  /* initialize real-time model */
  (void) memset((void *)rtwdemo_basicsc_M, 0,
                sizeof(RT_MODEL_rtwdemo_basicsc_T));
  rtmSetTFinal(rtwdemo_basicsc_M, 10.0);
  rtwdemo_basicsc_M->Timing.stepSize0 = 1.0;

  /* Setup for data logging */
  {
    static RTWLogInfo rt_DataLoggingInfo;
    rt_DataLoggingInfo.loggingInterval = NULL;
    rtwdemo_basicsc_M->rtwLogInfo = &rt_DataLoggingInfo;
  }

  /* Setup for data logging */
  {
    rtliSetLogXSignalInfo(rtwdemo_basicsc_M->rtwLogInfo, (NULL));
    rtliSetLogXSignalPtrs(rtwdemo_basicsc_M->rtwLogInfo, (NULL));
    rtliSetLogT(rtwdemo_basicsc_M->rtwLogInfo, "tout");
    rtliSetLogX(rtwdemo_basicsc_M->rtwLogInfo, "");
    rtliSetLogXFinal(rtwdemo_basicsc_M->rtwLogInfo, "");
    rtliSetLogVarNameModifier(rtwdemo_basicsc_M->rtwLogInfo, "rt_");
    rtliSetLogFormat(rtwdemo_basicsc_M->rtwLogInfo, 0);
    rtliSetLogMaxRows(rtwdemo_basicsc_M->rtwLogInfo, 1000);
    rtliSetLogDecimation(rtwdemo_basicsc_M->rtwLogInfo, 1);

    /*
     * Set pointers to the data and signal info for each output
     */
    {
      static void * rt_LoggedOutputSignalPtrs[] = {
        &rtwdemo_basicsc_Y.Out1
      };

      rtliSetLogYSignalPtrs(rtwdemo_basicsc_M->rtwLogInfo, ((LogSignalPtrsType)
        rt_LoggedOutputSignalPtrs));
    }

    {
      static int_T rt_LoggedOutputWidths[] = {
        1
      };

      static int_T rt_LoggedOutputNumDimensions[] = {
        1
      };

      static int_T rt_LoggedOutputDimensions[] = {
        1
      };

      static boolean_T rt_LoggedOutputIsVarDims[] = {
        0
      };

      static void* rt_LoggedCurrentSignalDimensions[] = {
        (NULL)
      };

      static int_T rt_LoggedCurrentSignalDimensionsSize[] = {
        4
      };

      static BuiltInDTypeId rt_LoggedOutputDataTypeIds[] = {
        SS_SINGLE
      };

      static int_T rt_LoggedOutputComplexSignals[] = {
        0
      };

      static RTWPreprocessingFcnPtr rt_LoggingPreprocessingFcnPtrs[] = {
        (NULL)
      };

      static const char_T *rt_LoggedOutputLabels[] = {
        "output" };

      static const char_T *rt_LoggedOutputBlockNames[] = {
        "rtwdemo_basicsc/Out1" };

      static RTWLogDataTypeConvert rt_RTWLogDataTypeConvert[] = {
        { 0, SS_SINGLE, SS_SINGLE, 0, 0, 0, 1.0, 0, 0.0 }
      };

      static RTWLogSignalInfo rt_LoggedOutputSignalInfo[] = {
        {
          1,
          rt_LoggedOutputWidths,
          rt_LoggedOutputNumDimensions,
          rt_LoggedOutputDimensions,
          rt_LoggedOutputIsVarDims,
          rt_LoggedCurrentSignalDimensions,
          rt_LoggedCurrentSignalDimensionsSize,
          rt_LoggedOutputDataTypeIds,
          rt_LoggedOutputComplexSignals,
          (NULL),
          rt_LoggingPreprocessingFcnPtrs,

          { rt_LoggedOutputLabels },
          (NULL),
          (NULL),
          (NULL),

          { rt_LoggedOutputBlockNames },

          { (NULL) },
          (NULL),
          rt_RTWLogDataTypeConvert
        }
      };

      rtliSetLogYSignalInfo(rtwdemo_basicsc_M->rtwLogInfo,
                            rt_LoggedOutputSignalInfo);

      /* set currSigDims field */
      rt_LoggedCurrentSignalDimensions[0] = &rt_LoggedOutputWidths[0];
    }

    rtliSetLogY(rtwdemo_basicsc_M->rtwLogInfo, "yout");
  }

  /* block I/O */
  (void) memset(((void *) &rtwdemo_basicsc_B), 0,
                sizeof(B_rtwdemo_basicsc_T));

  /* states (dwork) */
  (void) memset((void *)&rtwdemo_basicsc_DW, 0,
                sizeof(DW_rtwdemo_basicsc_T));

  /* external inputs */
  (void)memset(&rtwdemo_basicsc_U, 0, sizeof(ExtU_rtwdemo_basicsc_T));

  /* external outputs */
  rtwdemo_basicsc_Y.Out1 = 0.0F;

  /* Initialize DataMapInfo substructure containing ModelMap for C API */
  rtwdemo_basicsc_InitializeDataMapInfo();

  /* Matfile logging */
  rt_StartDataLoggingWithStartTime(rtwdemo_basicsc_M->rtwLogInfo, 0.0,
    rtmGetTFinal(rtwdemo_basicsc_M), rtwdemo_basicsc_M->Timing.stepSize0,
    (&rtmGetErrorStatus(rtwdemo_basicsc_M)));

  /* Start for DataStoreMemory: '<Root>/Data Store Memory' */
  rtwdemo_basicsc_DW.mode = false;

  /* InitializeConditions for UnitDelay: '<Root>/Delay' */
  rtwdemo_basicsc_DW.X = 0.0F;
}

/* Model terminate function */
void rtwdemo_basicsc_terminate(void)
{
  /* (no terminate code required) */
}

  /* user code (Output function Trailer) */

  /* System '<Root>' */
  {
    rtwCAPI_ModelMappingInfo *MMI = &(rtmGetDataMapInfo(rtwdemo_basicsc_M).mmi);
    logFcn(MMI, rtmGetTPtr(rtwdemo_basicsc_M));
  }