コード例 #1
0
static void chart_debug_initialization(SimStruct *S, unsigned int
  fullDebuggerInitialization)
{
  if (!sim_mode_is_rtw_gen(S)) {
    SFc52_Expriment_GazeInstanceStruct *chartInstance;
    ChartRunTimeInfo * crtInfo = (ChartRunTimeInfo *)(ssGetUserData(S));
    ChartInfoStruct * chartInfo = (ChartInfoStruct *)(crtInfo->instanceInfo);
    chartInstance = (SFc52_Expriment_GazeInstanceStruct *)
      chartInfo->chartInstance;
    if (ssIsFirstInitCond(S) && fullDebuggerInitialization==1) {
      /* do this only if simulation is starting */
      {
        unsigned int chartAlreadyPresent;
        chartAlreadyPresent = sf_debug_initialize_chart
          (sfGlobalDebugInstanceStruct,
           _Expriment_GazeMachineNumber_,
           52,
           1,
           1,
           0,
           2,
           0,
           0,
           0,
           0,
           0,
           &(chartInstance->chartNumber),
           &(chartInstance->instanceNumber),
           (void *)S);

        /* Each instance must initialize ist own list of scripts */
        init_script_number_translation(_Expriment_GazeMachineNumber_,
          chartInstance->chartNumber,chartInstance->instanceNumber);
        if (chartAlreadyPresent==0) {
          /* this is the first instance */
          sf_debug_set_chart_disable_implicit_casting
            (sfGlobalDebugInstanceStruct,_Expriment_GazeMachineNumber_,
             chartInstance->chartNumber,1);
          sf_debug_set_chart_event_thresholds(sfGlobalDebugInstanceStruct,
            _Expriment_GazeMachineNumber_,
            chartInstance->chartNumber,
            0,
            0,
            0);
          _SFD_SET_DATA_PROPS(0,2,0,1,"v2");
          _SFD_SET_DATA_PROPS(1,1,1,0,"v1");
          _SFD_STATE_INFO(0,0,2);
          _SFD_CH_SUBSTATE_COUNT(0);
          _SFD_CH_SUBSTATE_DECOMP(0);
        }

        _SFD_CV_INIT_CHART(0,0,0,0);

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

        _SFD_CV_INIT_TRANS(0,0,NULL,NULL,0,NULL);

        /* Initialization of MATLAB Function Model Coverage */
        _SFD_CV_INIT_EML(0,1,4,2,0,0,0,0,0,0,0);
        _SFD_CV_INIT_EML_FCN(0,0,"tt_blk_kernel",0,-1,364);
        _SFD_CV_INIT_EML_FCN(0,1,"aFcnTruthTableAction_1",364,-1,408);
        _SFD_CV_INIT_EML_FCN(0,2,"aFcnTruthTableAction_2",408,-1,452);
        _SFD_CV_INIT_EML_FCN(0,3,"aFcnTruthTableAction_3",452,-1,494);
        _SFD_CV_INIT_EML_IF(0,1,0,188,218,249,362);
        _SFD_CV_INIT_EML_IF(0,1,1,249,283,314,362);
        _SFD_SET_DATA_COMPILED_PROPS(0,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,
          (MexFcnForType)c52_sf_marshallOut,(MexInFcnForType)c52_sf_marshallIn);
        _SFD_SET_DATA_COMPILED_PROPS(1,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,
          (MexFcnForType)c52_sf_marshallOut,(MexInFcnForType)NULL);

        {
          real_T *c52_v2;
          real_T *c52_v1;
          c52_v1 = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
          c52_v2 = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
          _SFD_SET_DATA_VALUE_PTR(0U, c52_v2);
          _SFD_SET_DATA_VALUE_PTR(1U, c52_v1);
        }
      }
    } else {
      sf_debug_reset_current_state_configuration(sfGlobalDebugInstanceStruct,
        _Expriment_GazeMachineNumber_,chartInstance->chartNumber,
        chartInstance->instanceNumber);
    }
  }
}
コード例 #2
0
static void chart_debug_initialization(SimStruct *S, unsigned int
  fullDebuggerInitialization)
{
  if (!sim_mode_is_rtw_gen(S)) {
    SFc3_ARP_02_RPSsmile_WirelessGloveInstanceStruct *chartInstance;
    ChartRunTimeInfo * crtInfo = (ChartRunTimeInfo *)(ssGetUserData(S));
    ChartInfoStruct * chartInfo = (ChartInfoStruct *)(crtInfo->instanceInfo);
    chartInstance = (SFc3_ARP_02_RPSsmile_WirelessGloveInstanceStruct *)
      chartInfo->chartInstance;
    if (ssIsFirstInitCond(S) && fullDebuggerInitialization==1) {
      /* do this only if simulation is starting */
      {
        unsigned int chartAlreadyPresent;
        chartAlreadyPresent = sf_debug_initialize_chart
          (sfGlobalDebugInstanceStruct,
           _ARP_02_RPSsmile_WirelessGloveMachineNumber_,
           3,
           1,
           1,
           0,
           2,
           0,
           0,
           0,
           0,
           0,
           &(chartInstance->chartNumber),
           &(chartInstance->instanceNumber),
           (void *)S);

        /* Each instance must initialize ist own list of scripts */
        init_script_number_translation
          (_ARP_02_RPSsmile_WirelessGloveMachineNumber_,
           chartInstance->chartNumber,chartInstance->instanceNumber);
        if (chartAlreadyPresent==0) {
          /* this is the first instance */
          sf_debug_set_chart_disable_implicit_casting
            (sfGlobalDebugInstanceStruct,
             _ARP_02_RPSsmile_WirelessGloveMachineNumber_,
             chartInstance->chartNumber,1);
          sf_debug_set_chart_event_thresholds(sfGlobalDebugInstanceStruct,
            _ARP_02_RPSsmile_WirelessGloveMachineNumber_,
            chartInstance->chartNumber,
            0,
            0,
            0);
          _SFD_SET_DATA_PROPS(0,1,1,0,"u");
          _SFD_SET_DATA_PROPS(1,2,0,1,"y");
          _SFD_STATE_INFO(0,0,2);
          _SFD_CH_SUBSTATE_COUNT(0);
          _SFD_CH_SUBSTATE_DECOMP(0);
        }

        _SFD_CV_INIT_CHART(0,0,0,0);

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

        _SFD_CV_INIT_TRANS(0,0,NULL,NULL,0,NULL);

        /* Initialization of MATLAB Function Model Coverage */
        _SFD_CV_INIT_EML(0,1,1,3,0,0,0,0,0,0,0);
        _SFD_CV_INIT_EML_FCN(0,0,"eML_blk_kernel",0,-1,192);
        _SFD_CV_INIT_EML_IF(0,1,0,105,113,123,185);
        _SFD_CV_INIT_EML_IF(0,1,1,123,135,145,185);
        _SFD_CV_INIT_EML_IF(0,1,2,145,157,167,185);
        _SFD_SET_DATA_COMPILED_PROPS(0,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,
          (MexFcnForType)c3_sf_marshallOut,(MexInFcnForType)NULL);
        _SFD_SET_DATA_COMPILED_PROPS(1,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,
          (MexFcnForType)c3_sf_marshallOut,(MexInFcnForType)c3_sf_marshallIn);

        {
          real_T *c3_u;
          real_T *c3_y;
          c3_y = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
          c3_u = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
          _SFD_SET_DATA_VALUE_PTR(0U, c3_u);
          _SFD_SET_DATA_VALUE_PTR(1U, c3_y);
        }
      }
    } else {
      sf_debug_reset_current_state_configuration(sfGlobalDebugInstanceStruct,
        _ARP_02_RPSsmile_WirelessGloveMachineNumber_,chartInstance->chartNumber,
        chartInstance->instanceNumber);
    }
  }
}
コード例 #3
0
static void chart_debug_initialization(SimStruct *S, unsigned int
  fullDebuggerInitialization)
{
  if (!sim_mode_is_rtw_gen(S)) {
    SFc38_Expriment_FacialExprInstanceStruct *chartInstance;
    ChartRunTimeInfo * crtInfo = (ChartRunTimeInfo *)(ssGetUserData(S));
    ChartInfoStruct * chartInfo = (ChartInfoStruct *)(crtInfo->instanceInfo);
    chartInstance = (SFc38_Expriment_FacialExprInstanceStruct *)
      chartInfo->chartInstance;
    if (ssIsFirstInitCond(S) && fullDebuggerInitialization==1) {
      /* do this only if simulation is starting */
      {
        unsigned int chartAlreadyPresent;
        chartAlreadyPresent = sf_debug_initialize_chart
          (sfGlobalDebugInstanceStruct,
           _Expriment_FacialExprMachineNumber_,
           38,
           1,
           1,
           0,
           3,
           0,
           0,
           0,
           0,
           0,
           &(chartInstance->chartNumber),
           &(chartInstance->instanceNumber),
           (void *)S);

        /* Each instance must initialize ist own list of scripts */
        init_script_number_translation(_Expriment_FacialExprMachineNumber_,
          chartInstance->chartNumber,chartInstance->instanceNumber);
        if (chartAlreadyPresent==0) {
          /* this is the first instance */
          sf_debug_set_chart_disable_implicit_casting
            (sfGlobalDebugInstanceStruct,_Expriment_FacialExprMachineNumber_,
             chartInstance->chartNumber,1);
          sf_debug_set_chart_event_thresholds(sfGlobalDebugInstanceStruct,
            _Expriment_FacialExprMachineNumber_,
            chartInstance->chartNumber,
            0,
            0,
            0);
          _SFD_SET_DATA_PROPS(0,1,1,0,"V");
          _SFD_SET_DATA_PROPS(1,2,0,1,"e");
          _SFD_SET_DATA_PROPS(2,1,1,0,"A");
          _SFD_STATE_INFO(0,0,2);
          _SFD_CH_SUBSTATE_COUNT(0);
          _SFD_CH_SUBSTATE_DECOMP(0);
        }

        _SFD_CV_INIT_CHART(0,0,0,0);

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

        _SFD_CV_INIT_TRANS(0,0,NULL,NULL,0,NULL);

        /* Initialization of MATLAB Function Model Coverage */
        _SFD_CV_INIT_EML(0,1,9,8,0,0,0,0,0,0,0);
        _SFD_CV_INIT_EML_FCN(0,0,"tt_blk_kernel",0,-1,1491);
        _SFD_CV_INIT_EML_FCN(0,1,"aFcnTruthTableAction_1",1491,-1,1541);
        _SFD_CV_INIT_EML_FCN(0,2,"aFcnTruthTableAction_2",1541,-1,1593);
        _SFD_CV_INIT_EML_FCN(0,3,"aFcnTruthTableAction_3",1593,-1,1642);
        _SFD_CV_INIT_EML_FCN(0,4,"aFcnTruthTableAction_4",1642,-1,1698);
        _SFD_CV_INIT_EML_FCN(0,5,"aFcnTruthTableAction_5",1698,-1,1750);
        _SFD_CV_INIT_EML_FCN(0,6,"aFcnTruthTableAction_6",1750,-1,1803);
        _SFD_CV_INIT_EML_FCN(0,7,"aFcnTruthTableAction_7",1803,-1,1853);
        _SFD_CV_INIT_EML_FCN(0,8,"aFcnTruthTableAction_8",1853,-1,1900);
        _SFD_CV_INIT_EML_IF(0,1,0,925,955,986,1489);
        _SFD_CV_INIT_EML_IF(0,1,1,986,1020,1051,1489);
        _SFD_CV_INIT_EML_IF(0,1,2,1051,1085,1116,1489);
        _SFD_CV_INIT_EML_IF(0,1,3,1116,1150,1181,1489);
        _SFD_CV_INIT_EML_IF(0,1,4,1181,1215,1246,1489);
        _SFD_CV_INIT_EML_IF(0,1,5,1246,1280,1311,1489);
        _SFD_CV_INIT_EML_IF(0,1,6,1311,1345,1376,1489);
        _SFD_CV_INIT_EML_IF(0,1,7,1376,1410,1441,1489);
        _SFD_SET_DATA_COMPILED_PROPS(0,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,
          (MexFcnForType)c38_sf_marshallOut,(MexInFcnForType)NULL);
        _SFD_SET_DATA_COMPILED_PROPS(1,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,
          (MexFcnForType)c38_sf_marshallOut,(MexInFcnForType)c38_sf_marshallIn);
        _SFD_SET_DATA_COMPILED_PROPS(2,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,
          (MexFcnForType)c38_sf_marshallOut,(MexInFcnForType)NULL);

        {
          real_T *c38_V;
          real_T *c38_e;
          real_T *c38_A;
          c38_A = (real_T *)ssGetInputPortSignal(chartInstance->S, 1);
          c38_e = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
          c38_V = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
          _SFD_SET_DATA_VALUE_PTR(0U, c38_V);
          _SFD_SET_DATA_VALUE_PTR(1U, c38_e);
          _SFD_SET_DATA_VALUE_PTR(2U, c38_A);
        }
      }
    } else {
      sf_debug_reset_current_state_configuration(sfGlobalDebugInstanceStruct,
        _Expriment_FacialExprMachineNumber_,chartInstance->chartNumber,
        chartInstance->instanceNumber);
    }
  }
}
コード例 #4
0
static real_T *c3_DirectionCode(void)
{
  return (real_T *)ssGetOutputPortSignal(chartInstance.S, 1);
}
コード例 #5
0
static void c30_c30_adcs_v15_integral_Power(void)
{
  int32_T c30_i5;
  real_T c30_r_I[3];
  real_T c30_t;
  real_T c30_nargout = 1.0;
  real_T c30_nargin = 4.0;
  real_T c30_c_equinox = c30_b_equinox;
  real_T c30_c_today = c30_b_today;
  real_T c30_TEI[9];
  real_T c30_phi;
  real_T c30_st_sec;
  real_T c30_ut_sec;
  real_T c30_W_EARTH_ROT;
  real_T c30_stperut;
  real_T c30_r_ECEF[3];
  real_T c30_b;
  real_T c30_a;
  real_T c30_x;
  real_T c30_b_x;
  real_T c30_c_x;
  real_T c30_d_x;
  real_T c30_e_x;
  real_T c30_f_x;
  real_T c30_g_x;
  real_T c30_h_x;
  real_T c30_i_x;
  real_T c30_j_x;
  real_T c30_k_x;
  real_T c30_l_x;
  int32_T c30_i6;
  int32_T c30_i7;
  static real_T c30_dv1[3] = { 0.0, 0.0, 1.0 };

  int32_T c30_i8;
  real_T c30_b_a[9];
  int32_T c30_i9;
  real_T c30_b_b[3];
  int32_T c30_i10;
  real_T c30_A[9];
  int32_T c30_i11;
  real_T c30_B[3];
  int32_T c30_i12;
  int32_T c30_i13;
  real_T c30_b_A[9];
  int32_T c30_i14;
  real_T c30_b_B[3];
  int32_T c30_i15;
  real_T c30_c_A[9];
  int32_T c30_i16;
  real_T c30_c_B[3];
  int32_T c30_i17;
  int32_T c30_i18;
  int32_T c30_i19;
  int32_T c30_i20;
  real_T *c30_b_t;
  real_T (*c30_b_r_ECEF)[3];
  real_T (*c30_b_r_I)[3];
  c30_b_r_ECEF = (real_T (*)[3])ssGetOutputPortSignal(chartInstance.S, 1);
  c30_b_t = (real_T *)ssGetInputPortSignal(chartInstance.S, 1);
  c30_b_r_I = (real_T (*)[3])ssGetInputPortSignal(chartInstance.S, 0);
  _SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG,23);
  for (c30_i5 = 0; c30_i5 < 3; c30_i5 = c30_i5 + 1) {
    c30_r_I[c30_i5] = (*c30_b_r_I)[c30_i5];
  }

  c30_t = *c30_b_t;
  sf_debug_symbol_scope_push(13U, 0U);
  sf_debug_symbol_scope_add("nargout", &c30_nargout, c30_b_sf_marshall);
  sf_debug_symbol_scope_add("nargin", &c30_nargin, c30_b_sf_marshall);
  sf_debug_symbol_scope_add("equinox", &c30_c_equinox, c30_b_sf_marshall);
  sf_debug_symbol_scope_add("today", &c30_c_today, c30_b_sf_marshall);
  sf_debug_symbol_scope_add("TEI", &c30_TEI, c30_c_sf_marshall);
  sf_debug_symbol_scope_add("phi", &c30_phi, c30_b_sf_marshall);
  sf_debug_symbol_scope_add("st_sec", &c30_st_sec, c30_b_sf_marshall);
  sf_debug_symbol_scope_add("ut_sec", &c30_ut_sec, c30_b_sf_marshall);
  sf_debug_symbol_scope_add("W_EARTH_ROT", &c30_W_EARTH_ROT, c30_b_sf_marshall);
  sf_debug_symbol_scope_add("stperut", &c30_stperut, c30_b_sf_marshall);
  sf_debug_symbol_scope_add("r_ECEF", &c30_r_ECEF, c30_sf_marshall);
  sf_debug_symbol_scope_add("t", &c30_t, c30_b_sf_marshall);
  sf_debug_symbol_scope_add("r_I", &c30_r_I, c30_sf_marshall);
  CV_EML_FCN(0, 0);

  /* u: position vector in ECI (in m) */
  /* y: position vector in ECEF (in m) */
  _SFD_EML_CALL(0,5);
  c30_stperut = 1.0027379093500000E+000;

  /*  siderial time = stperut * universal time */
  _SFD_EML_CALL(0,6);
  c30_W_EARTH_ROT = 7.2940705438520400E-005;

  /*  sidereal rotation angular velocity of earth, SI */
  _SFD_EML_CALL(0,8);
  c30_ut_sec = 1.8225E+007 + c30_t;

  /*  universal time vector in sec */
  _SFD_EML_CALL(0,9);
  c30_b = c30_ut_sec;
  c30_st_sec = 1.0027379093500000E+000 * c30_b;

  /*  sidereal time vector in sec */
  _SFD_EML_CALL(0,11);
  c30_a = c30_st_sec;
  c30_phi = c30_a * 7.2940705438520400E-005;

  /*  sidereal time vector in rad */
  _SFD_EML_CALL(0,13);
  c30_x = c30_phi;
  c30_b_x = c30_x;
  c30_c_x = c30_b_x;
  c30_b_x = c30_c_x;
  c30_b_x = muDoubleScalarCos(c30_b_x);
  c30_d_x = c30_phi;
  c30_e_x = c30_d_x;
  c30_f_x = c30_e_x;
  c30_e_x = c30_f_x;
  c30_e_x = muDoubleScalarSin(c30_e_x);
  c30_g_x = c30_phi;
  c30_h_x = c30_g_x;
  c30_i_x = c30_h_x;
  c30_h_x = c30_i_x;
  c30_h_x = muDoubleScalarSin(c30_h_x);
  c30_j_x = c30_phi;
  c30_k_x = c30_j_x;
  c30_l_x = c30_k_x;
  c30_k_x = c30_l_x;
  c30_k_x = muDoubleScalarCos(c30_k_x);
  c30_TEI[0] = c30_k_x;
  c30_TEI[3] = c30_h_x;
  c30_TEI[6] = 0.0;
  c30_TEI[1] = -c30_e_x;
  c30_TEI[4] = c30_b_x;
  c30_TEI[7] = 0.0;
  c30_i6 = 0;
  for (c30_i7 = 0; c30_i7 < 3; c30_i7 = c30_i7 + 1) {
    c30_TEI[c30_i6 + 2] = c30_dv1[c30_i7];
    c30_i6 = c30_i6 + 3;
  }

  _SFD_EML_CALL(0,17);
  for (c30_i8 = 0; c30_i8 < 9; c30_i8 = c30_i8 + 1) {
    c30_b_a[c30_i8] = c30_TEI[c30_i8];
  }

  for (c30_i9 = 0; c30_i9 < 3; c30_i9 = c30_i9 + 1) {
    c30_b_b[c30_i9] = c30_r_I[c30_i9];
  }

  c30_eml_scalar_eg();
  c30_eml_scalar_eg();
  for (c30_i10 = 0; c30_i10 < 9; c30_i10 = c30_i10 + 1) {
    c30_A[c30_i10] = c30_b_a[c30_i10];
  }

  for (c30_i11 = 0; c30_i11 < 3; c30_i11 = c30_i11 + 1) {
    c30_B[c30_i11] = c30_b_b[c30_i11];
  }

  for (c30_i12 = 0; c30_i12 < 3; c30_i12 = c30_i12 + 1) {
    c30_r_ECEF[c30_i12] = 0.0;
  }

  for (c30_i13 = 0; c30_i13 < 9; c30_i13 = c30_i13 + 1) {
    c30_b_A[c30_i13] = c30_A[c30_i13];
  }

  for (c30_i14 = 0; c30_i14 < 3; c30_i14 = c30_i14 + 1) {
    c30_b_B[c30_i14] = c30_B[c30_i14];
  }

  for (c30_i15 = 0; c30_i15 < 9; c30_i15 = c30_i15 + 1) {
    c30_c_A[c30_i15] = c30_b_A[c30_i15];
  }

  for (c30_i16 = 0; c30_i16 < 3; c30_i16 = c30_i16 + 1) {
    c30_c_B[c30_i16] = c30_b_B[c30_i16];
  }

  for (c30_i17 = 0; c30_i17 < 3; c30_i17 = c30_i17 + 1) {
    c30_r_ECEF[c30_i17] = 0.0;
    c30_i18 = 0;
    for (c30_i19 = 0; c30_i19 < 3; c30_i19 = c30_i19 + 1) {
      c30_r_ECEF[c30_i17] = c30_r_ECEF[c30_i17] + c30_c_A[c30_i18 + c30_i17] *
        c30_c_B[c30_i19];
      c30_i18 = c30_i18 + 3;
    }
  }

  _SFD_EML_CALL(0,-17);
  sf_debug_symbol_scope_pop();
  for (c30_i20 = 0; c30_i20 < 3; c30_i20 = c30_i20 + 1) {
    (*c30_b_r_ECEF)[c30_i20] = c30_r_ECEF[c30_i20];
  }

  _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG,23);
}
コード例 #6
0
static void c6_chartstep_c6_Array(SFc6_ArrayInstanceStruct *chartInstance)
{
  real_T c6_hoistedGlobal;
  real_T c6_b_hoistedGlobal;
  real_T c6_c_hoistedGlobal;
  real_T c6_V;
  real_T c6_Radiacion;
  real_T c6_Temp;
  uint32_T c6_debug_family_var_map[23];
  real_T c6_q;
  real_T c6_K;
  real_T c6_n;
  real_T c6_T;
  real_T c6_Rs;
  real_T c6_Rp;
  real_T c6_Vt;
  real_T c6_Ns;
  real_T c6_Vc;
  real_T c6_Isc;
  real_T c6_Alfa;
  real_T c6_Iph;
  real_T c6_Voc_ref;
  real_T c6_Beta;
  real_T c6_Voc;
  real_T c6_Io;
  real_T c6_Ir;
  real_T c6_nargin = 3.0;
  real_T c6_nargout = 1.0;
  real_T c6_I;
  real_T c6_b;
  real_T c6_y;
  real_T c6_A;
  real_T c6_x;
  real_T c6_b_x;
  real_T c6_c_x;
  real_T c6_d_x;
  real_T c6_b_b;
  real_T c6_b_y;
  real_T c6_b_A;
  real_T c6_e_x;
  real_T c6_f_x;
  real_T c6_c_y;
  real_T c6_c_b;
  real_T c6_d_y;
  real_T c6_a;
  real_T c6_d_b;
  real_T c6_e_b;
  real_T c6_e_y;
  real_T c6_f_b;
  real_T c6_c_A;
  real_T c6_B;
  real_T c6_g_x;
  real_T c6_f_y;
  real_T c6_h_x;
  real_T c6_g_y;
  real_T c6_h_y;
  real_T c6_i_x;
  real_T c6_j_x;
  real_T c6_b_B;
  real_T c6_i_y;
  real_T c6_j_y;
  int32_T c6_i;
  real_T c6_k_x;
  real_T c6_k_y;
  real_T c6_l_x;
  real_T c6_l_y;
  real_T c6_z;
  real_T c6_m_x;
  real_T c6_n_x;
  real_T c6_d_A;
  real_T c6_o_x;
  real_T c6_p_x;
  real_T c6_m_y;
  real_T c6_n_y;
  real_T c6_o_y;
  real_T c6_b_z;
  real_T c6_b_a;
  real_T c6_g_b;
  real_T c6_p_y;
  real_T c6_q_x;
  real_T c6_q_y;
  real_T c6_r_x;
  real_T c6_r_y;
  real_T c6_c_z;
  real_T c6_s_x;
  real_T c6_t_x;
  real_T c6_u_x;
  real_T c6_s_y;
  real_T c6_v_x;
  real_T c6_t_y;
  real_T c6_d_z;
  real_T *c6_b_Temp;
  real_T *c6_b_Radiacion;
  real_T *c6_b_V;
  real_T *c6_b_I;
  c6_b_Temp = (real_T *)ssGetInputPortSignal(chartInstance->S, 2);
  c6_b_Radiacion = (real_T *)ssGetInputPortSignal(chartInstance->S, 1);
  c6_b_I = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
  c6_b_V = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
  _SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 5U, chartInstance->c6_sfEvent);
  c6_hoistedGlobal = *c6_b_V;
  c6_b_hoistedGlobal = *c6_b_Radiacion;
  c6_c_hoistedGlobal = *c6_b_Temp;
  c6_V = c6_hoistedGlobal;
  c6_Radiacion = c6_b_hoistedGlobal;
  c6_Temp = c6_c_hoistedGlobal;
  sf_debug_symbol_scope_push_eml(0U, 23U, 23U, c6_debug_family_names,
    c6_debug_family_var_map);
  sf_debug_symbol_scope_add_eml(&c6_q, 0U, c6_sf_marshallOut);
  sf_debug_symbol_scope_add_eml(&c6_K, 1U, c6_sf_marshallOut);
  sf_debug_symbol_scope_add_eml(&c6_n, 2U, c6_sf_marshallOut);
  sf_debug_symbol_scope_add_eml_importable(&c6_T, 3U, c6_sf_marshallOut,
    c6_sf_marshallIn);
  sf_debug_symbol_scope_add_eml(&c6_Rs, 4U, c6_sf_marshallOut);
  sf_debug_symbol_scope_add_eml(&c6_Rp, 5U, c6_sf_marshallOut);
  sf_debug_symbol_scope_add_eml_importable(&c6_Vt, 6U, c6_sf_marshallOut,
    c6_sf_marshallIn);
  sf_debug_symbol_scope_add_eml(&c6_Ns, 7U, c6_sf_marshallOut);
  sf_debug_symbol_scope_add_eml_importable(&c6_Vc, 8U, c6_sf_marshallOut,
    c6_sf_marshallIn);
  sf_debug_symbol_scope_add_eml(&c6_Isc, 9U, c6_sf_marshallOut);
  sf_debug_symbol_scope_add_eml(&c6_Alfa, 10U, c6_sf_marshallOut);
  sf_debug_symbol_scope_add_eml_importable(&c6_Iph, 11U, c6_sf_marshallOut,
    c6_sf_marshallIn);
  sf_debug_symbol_scope_add_eml(&c6_Voc_ref, 12U, c6_sf_marshallOut);
  sf_debug_symbol_scope_add_eml(&c6_Beta, 13U, c6_sf_marshallOut);
  sf_debug_symbol_scope_add_eml_importable(&c6_Voc, 14U, c6_sf_marshallOut,
    c6_sf_marshallIn);
  sf_debug_symbol_scope_add_eml_importable(&c6_Io, 15U, c6_sf_marshallOut,
    c6_sf_marshallIn);
  sf_debug_symbol_scope_add_eml_importable(&c6_Ir, 16U, c6_sf_marshallOut,
    c6_sf_marshallIn);
  sf_debug_symbol_scope_add_eml_importable(&c6_nargin, 17U, c6_sf_marshallOut,
    c6_sf_marshallIn);
  sf_debug_symbol_scope_add_eml_importable(&c6_nargout, 18U, c6_sf_marshallOut,
    c6_sf_marshallIn);
  sf_debug_symbol_scope_add_eml(&c6_V, 19U, c6_sf_marshallOut);
  sf_debug_symbol_scope_add_eml(&c6_Radiacion, 20U, c6_sf_marshallOut);
  sf_debug_symbol_scope_add_eml(&c6_Temp, 21U, c6_sf_marshallOut);
  sf_debug_symbol_scope_add_eml_importable(&c6_I, 22U, c6_sf_marshallOut,
    c6_sf_marshallIn);
  CV_EML_FCN(0, 0);
  _SFD_EML_CALL(0U, chartInstance->c6_sfEvent, 3);
  c6_q = 1.602176E-19;
  _SFD_EML_CALL(0U, chartInstance->c6_sfEvent, 5);
  c6_K = 1.3806488E-23;
  _SFD_EML_CALL(0U, chartInstance->c6_sfEvent, 7);
  c6_n = 1.3;
  _SFD_EML_CALL(0U, chartInstance->c6_sfEvent, 9);
  c6_T = 273.15 + c6_Temp;
  _SFD_EML_CALL(0U, chartInstance->c6_sfEvent, 11);
  c6_Rs = 0.015;
  _SFD_EML_CALL(0U, chartInstance->c6_sfEvent, 13);
  c6_Rp = 100.0;
  _SFD_EML_CALL(0U, chartInstance->c6_sfEvent, 15);
  c6_b = c6_T;
  c6_y = 1.79484344E-23 * c6_b;
  c6_A = c6_y;
  c6_x = c6_A;
  c6_b_x = c6_x;
  c6_Vt = c6_b_x / 1.602176E-19;
  _SFD_EML_CALL(0U, chartInstance->c6_sfEvent, 16);
  c6_Ns = 36.0;
  _SFD_EML_CALL(0U, chartInstance->c6_sfEvent, 17);
  c6_c_x = c6_V;
  c6_d_x = c6_c_x;
  c6_Vc = c6_d_x / 36.0;
  _SFD_EML_CALL(0U, chartInstance->c6_sfEvent, 19);
  c6_Isc = 5.433;
  _SFD_EML_CALL(0U, chartInstance->c6_sfEvent, 20);
  c6_Alfa = 0.00037;
  _SFD_EML_CALL(0U, chartInstance->c6_sfEvent, 22);
  c6_b_b = c6_Radiacion;
  c6_b_y = 5.433 * c6_b_b;
  c6_b_A = c6_b_y;
  c6_e_x = c6_b_A;
  c6_f_x = c6_e_x;
  c6_c_y = c6_f_x / 1000.0;
  c6_c_b = c6_Temp - 25.0;
  c6_d_y = 0.00037 * c6_c_b;
  c6_a = c6_c_y;
  c6_d_b = 1.0 + c6_d_y;
  c6_Iph = c6_a * c6_d_b;
  _SFD_EML_CALL(0U, chartInstance->c6_sfEvent, 24);
  c6_Voc_ref = 0.6166666666666667;
  _SFD_EML_CALL(0U, chartInstance->c6_sfEvent, 25);
  c6_Beta = -0.0034000000000000002;
  _SFD_EML_CALL(0U, chartInstance->c6_sfEvent, 26);
  c6_e_b = c6_Temp - 25.0;
  c6_e_y = -0.0034000000000000002 * c6_e_b;
  c6_f_b = 1.0 + c6_e_y;
  c6_Voc = 0.6166666666666667 * c6_f_b;
  _SFD_EML_CALL(0U, chartInstance->c6_sfEvent, 32);
  c6_c_A = c6_Voc;
  c6_B = c6_Vt;
  c6_g_x = c6_c_A;
  c6_f_y = c6_B;
  c6_h_x = c6_g_x;
  c6_g_y = c6_f_y;
  c6_h_y = c6_h_x / c6_g_y;
  c6_i_x = c6_h_y;
  c6_j_x = c6_i_x;
  c6_j_x = muDoubleScalarExp(c6_j_x);
  c6_b_B = c6_j_x - 1.0;
  c6_i_y = c6_b_B;
  c6_j_y = c6_i_y;
  c6_Io = 5.433 / c6_j_y;
  _SFD_EML_CALL(0U, chartInstance->c6_sfEvent, 33);
  c6_Ir = c6_Io;
  _SFD_EML_CALL(0U, chartInstance->c6_sfEvent, 36);
  c6_I = 0.0;
  c6_i = 0;
  while (c6_i < 50) {
    CV_EML_FOR(0, 1, 0, 1);
    _SFD_EML_CALL(0U, chartInstance->c6_sfEvent, 38);
    c6_k_x = c6_Vc + c6_I * c6_Rs;
    c6_k_y = c6_Vt;
    c6_l_x = c6_k_x;
    c6_l_y = c6_k_y;
    c6_z = c6_l_x / c6_l_y;
    c6_m_x = c6_z;
    c6_n_x = c6_m_x;
    c6_n_x = muDoubleScalarExp(c6_n_x);
    c6_d_A = c6_Vc + c6_I * c6_Rs;
    c6_o_x = c6_d_A;
    c6_p_x = c6_o_x;
    c6_m_y = c6_p_x / 100.0;
    c6_n_y = c6_Vt;
    c6_o_y = c6_n_y;
    c6_b_z = 0.015 / c6_o_y;
    c6_b_a = c6_Ir;
    c6_g_b = c6_b_z;
    c6_p_y = c6_b_a * c6_g_b;
    c6_q_x = c6_Vc + c6_I * c6_Rs;
    c6_q_y = c6_Vt;
    c6_r_x = c6_q_x;
    c6_r_y = c6_q_y;
    c6_c_z = c6_r_x / c6_r_y;
    c6_s_x = c6_c_z;
    c6_t_x = c6_s_x;
    c6_t_x = muDoubleScalarExp(c6_t_x);
    c6_u_x = ((c6_Iph - c6_I) - c6_Ir * (c6_n_x - 1.0)) + c6_m_y;
    c6_s_y = (-1.0 - c6_p_y * c6_t_x) - 0.00015;
    c6_v_x = c6_u_x;
    c6_t_y = c6_s_y;
    c6_d_z = c6_v_x / c6_t_y;
    c6_I -= c6_d_z;
    c6_i++;
    sf_mex_listen_for_ctrl_c(chartInstance->S);
  }

  CV_EML_FOR(0, 1, 0, 0);
  _SFD_EML_CALL(0U, chartInstance->c6_sfEvent, -38);
  sf_debug_symbol_scope_pop();
  *c6_b_I = c6_I;
  _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 5U, chartInstance->c6_sfEvent);
}
コード例 #7
0
static void sf_c10_HIL_model_overall(SFc10_HIL_model_overallInstanceStruct
  *chartInstance)
{
  int32_T c10_i2;
  int32_T c10_i3;
  int32_T c10_i4;
  real_T c10_eta[3];
  uint32_T c10_debug_family_var_map[7];
  real_T c10_psi;
  real_T c10_c;
  real_T c10_s;
  real_T c10_nargin = 1.0;
  real_T c10_nargout = 1.0;
  real_T c10_R[9];
  real_T c10_x;
  real_T c10_b_x;
  real_T c10_c_x;
  real_T c10_d_x;
  int32_T c10_i5;
  int32_T c10_i6;
  static real_T c10_dv1[3] = { 0.0, 0.0, 1.0 };

  int32_T c10_i7;
  real_T (*c10_b_R)[9];
  real_T (*c10_b_eta)[3];
  c10_b_R = (real_T (*)[9])ssGetOutputPortSignal(chartInstance->S, 1);
  c10_b_eta = (real_T (*)[3])ssGetInputPortSignal(chartInstance->S, 0);
  _sfTime_ = (real_T)ssGetT(chartInstance->S);
  _SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 9U, chartInstance->c10_sfEvent);
  for (c10_i2 = 0; c10_i2 < 3; c10_i2++) {
    _SFD_DATA_RANGE_CHECK((*c10_b_eta)[c10_i2], 0U);
  }

  for (c10_i3 = 0; c10_i3 < 9; c10_i3++) {
    _SFD_DATA_RANGE_CHECK((*c10_b_R)[c10_i3], 1U);
  }

  chartInstance->c10_sfEvent = CALL_EVENT;
  _SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 9U, chartInstance->c10_sfEvent);
  for (c10_i4 = 0; c10_i4 < 3; c10_i4++) {
    c10_eta[c10_i4] = (*c10_b_eta)[c10_i4];
  }

  _SFD_SYMBOL_SCOPE_PUSH_EML(0U, 7U, 7U, c10_debug_family_names,
    c10_debug_family_var_map);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c10_psi, 0U, c10_c_sf_marshallOut,
    c10_b_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c10_c, 1U, c10_c_sf_marshallOut,
    c10_b_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c10_s, 2U, c10_c_sf_marshallOut,
    c10_b_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c10_nargin, 3U, c10_c_sf_marshallOut,
    c10_b_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c10_nargout, 4U, c10_c_sf_marshallOut,
    c10_b_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML(c10_eta, 5U, c10_b_sf_marshallOut);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(c10_R, 6U, c10_sf_marshallOut,
    c10_sf_marshallIn);
  CV_EML_FCN(0, 0);
  _SFD_EML_CALL(0U, chartInstance->c10_sfEvent, 3);
  CV_EML_IF(0, 1, 0, TRUE);
  _SFD_EML_CALL(0U, chartInstance->c10_sfEvent, 4);
  c10_psi = c10_eta[2];
  _SFD_EML_CALL(0U, chartInstance->c10_sfEvent, 9);
  c10_x = c10_psi;
  c10_c = c10_x;
  c10_b_x = c10_c;
  c10_c = c10_b_x;
  c10_c = muDoubleScalarCos(c10_c);
  _SFD_EML_CALL(0U, chartInstance->c10_sfEvent, 10);
  c10_c_x = c10_psi;
  c10_s = c10_c_x;
  c10_d_x = c10_s;
  c10_s = c10_d_x;
  c10_s = muDoubleScalarSin(c10_s);
  _SFD_EML_CALL(0U, chartInstance->c10_sfEvent, 12);
  c10_R[0] = c10_c;
  c10_R[3] = -c10_s;
  c10_R[6] = 0.0;
  c10_R[1] = c10_s;
  c10_R[4] = c10_c;
  c10_R[7] = 0.0;
  c10_i5 = 0;
  for (c10_i6 = 0; c10_i6 < 3; c10_i6++) {
    c10_R[c10_i5 + 2] = c10_dv1[c10_i6];
    c10_i5 += 3;
  }

  _SFD_EML_CALL(0U, chartInstance->c10_sfEvent, -12);
  _SFD_SYMBOL_SCOPE_POP();
  for (c10_i7 = 0; c10_i7 < 9; c10_i7++) {
    (*c10_b_R)[c10_i7] = c10_R[c10_i7];
  }

  _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 9U, chartInstance->c10_sfEvent);
  _SFD_CHECK_FOR_STATE_INCONSISTENCY(_HIL_model_overallMachineNumber_,
    chartInstance->chartNumber, chartInstance->instanceNumber);
}
コード例 #8
0
static void mdlOutputs(SimStruct *S, int_T tid) {
    uint16_T *y = ssGetOutputPortSignal(S,0);
    int act;
    char car;
    int negative;
    //printf("asignacion: %d\n",n = readURG(&car, sizeof(car)));
    //printf("lectura de laser: \n");
    act = 0;
    while((readURG(&car, sizeof(car)))==1) {
        
        buf[act] = car;
        act++;
        // printf("%c",car);
        if ((act>1) && ((buf[act-1] == '\r') || (buf[act-1] == '\n')) && ((buf[act-2] == '\r') || (buf[act-2] == '\n'))) {
            
            if (act>1000) {
                
                buf[act] = '\0';
                
                memset(res, 0, sizeof(res));
                urg_decode(buf,res);
                
                memset(aux, 0, sizeof(aux));
                j=0;
                for (i=0; i<682; i++) {
                    
                    biconvert.val = res[i];
                    
                    aux[j++] = biconvert.bytes[0];
                    aux[j++] = biconvert.bytes[1];
                    aux[j++] = biconvert.bytes[2];
                    aux[j++] = biconvert.bytes[3];
                }
                
                biconvert.val = time;
                
                aux[j++] = biconvert.bytes[0];
                aux[j++] = biconvert.bytes[1];
                aux[j++] = biconvert.bytes[2];
                aux[j++] = biconvert.bytes[3];
                
                act=0;
                memset(buf, 0, sizeof(buf));
                break;
            }
        }
    }
    urg_start_single_scan();
    negative = 0;
    for (i=0; i<682; i++)
    {
        if (res[i] < 0)
        {
            negative = 1;
            break;
        }
        else 
        {
            y[i] = res[i];
        }
    }
    // Si hay algun negativo son datos invaldiso: devolvemos todo 0
    if (negative == 1)
    {
        for (i=0; i<682; i++) y[i] = 0;
    }
    
    
    
}
コード例 #9
0
ファイル: c14_test.c プロジェクト: dittoyi/pathfollowingRRS
static void sf_c14_test(SFc14_testInstanceStruct *chartInstance)
{
  real_T c14_hoistedGlobal;
  real_T c14_u;
  uint32_T c14_debug_family_var_map[7];
  real_T c14_a1;
  real_T c14_a2;
  real_T c14_k3;
  real_T c14_nargin = 1.0;
  real_T c14_nargout = 1.0;
  real_T c14_y;
  real_T c14_x;
  real_T c14_b_x;
  real_T c14_b_y;
  real_T c14_c_x;
  real_T c14_d_x;
  real_T c14_A;
  real_T c14_e_x;
  real_T c14_f_x;
  real_T c14_g_x;
  real_T c14_h_x;
  real_T c14_c_y;
  real_T c14_i_x;
  real_T c14_j_x;
  real_T c14_b_A;
  real_T c14_k_x;
  real_T c14_l_x;
  real_T c14_m_x;
  real_T c14_n_x;
  real_T c14_o_x;
  real_T c14_p_x;
  real_T c14_d_y;
  real_T c14_a;
  real_T c14_b;
  real_T c14_b_a;
  real_T c14_b_b;
  real_T c14_e_y;
  real_T c14_c_a;
  real_T c14_c_b;
  real_T c14_f_y;
  real_T *c14_b_u;
  real_T *c14_g_y;
  c14_g_y = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
  c14_b_u = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
  _sfTime_ = (real_T)ssGetT(chartInstance->S);
  _SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 12U, chartInstance->c14_sfEvent);
  _SFD_DATA_RANGE_CHECK(*c14_b_u, 0U);
  _SFD_DATA_RANGE_CHECK(*c14_g_y, 1U);
  chartInstance->c14_sfEvent = CALL_EVENT;
  _SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 12U, chartInstance->c14_sfEvent);
  c14_hoistedGlobal = *c14_b_u;
  c14_u = c14_hoistedGlobal;
  sf_debug_symbol_scope_push_eml(0U, 7U, 7U, c14_debug_family_names,
    c14_debug_family_var_map);
  sf_debug_symbol_scope_add_eml_importable(&c14_a1, 0U, c14_sf_marshallOut,
    c14_sf_marshallIn);
  sf_debug_symbol_scope_add_eml_importable(&c14_a2, 1U, c14_sf_marshallOut,
    c14_sf_marshallIn);
  sf_debug_symbol_scope_add_eml_importable(&c14_k3, 2U, c14_sf_marshallOut,
    c14_sf_marshallIn);
  sf_debug_symbol_scope_add_eml_importable(&c14_nargin, 3U, c14_sf_marshallOut,
    c14_sf_marshallIn);
  sf_debug_symbol_scope_add_eml_importable(&c14_nargout, 4U, c14_sf_marshallOut,
    c14_sf_marshallIn);
  sf_debug_symbol_scope_add_eml(&c14_u, 5U, c14_sf_marshallOut);
  sf_debug_symbol_scope_add_eml_importable(&c14_y, 6U, c14_sf_marshallOut,
    c14_sf_marshallIn);
  CV_EML_FCN(0, 0);
  _SFD_EML_CALL(0U, chartInstance->c14_sfEvent, 3);
  c14_x = c14_u;
  c14_b_x = c14_x;
  c14_b_y = muDoubleScalarAbs(c14_b_x);
  c14_c_x = c14_b_y - 3.1415926535897931;
  c14_d_x = c14_c_x;
  c14_d_x = muDoubleScalarSign(c14_d_x);
  c14_A = 1.0 - c14_d_x;
  c14_e_x = c14_A;
  c14_f_x = c14_e_x;
  c14_a1 = c14_f_x / 2.0;
  _SFD_EML_CALL(0U, chartInstance->c14_sfEvent, 4);
  c14_g_x = c14_u;
  c14_h_x = c14_g_x;
  c14_c_y = muDoubleScalarAbs(c14_h_x);
  c14_i_x = c14_c_y - 3.1415926535897931;
  c14_j_x = c14_i_x;
  c14_j_x = muDoubleScalarSign(c14_j_x);
  c14_b_A = 1.0 + c14_j_x;
  c14_k_x = c14_b_A;
  c14_l_x = c14_k_x;
  c14_a2 = c14_l_x / 2.0;
  _SFD_EML_CALL(0U, chartInstance->c14_sfEvent, 5);
  c14_m_x = c14_u;
  c14_n_x = c14_m_x;
  c14_n_x = muDoubleScalarSign(c14_n_x);
  c14_o_x = c14_u;
  c14_p_x = c14_o_x;
  c14_d_y = muDoubleScalarAbs(c14_p_x);
  c14_a = -c14_n_x;
  c14_b = 6.2831853071795862 - c14_d_y;
  c14_k3 = c14_a * c14_b;
  _SFD_EML_CALL(0U, chartInstance->c14_sfEvent, 6);
  c14_b_a = c14_a1;
  c14_b_b = c14_u;
  c14_e_y = c14_b_a * c14_b_b;
  c14_c_a = c14_a2;
  c14_c_b = c14_k3;
  c14_f_y = c14_c_a * c14_c_b;
  c14_y = c14_e_y + c14_f_y;
  _SFD_EML_CALL(0U, chartInstance->c14_sfEvent, -6);
  sf_debug_symbol_scope_pop();
  *c14_g_y = c14_y;
  _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 12U, chartInstance->c14_sfEvent);
  sf_debug_check_for_state_inconsistency(_testMachineNumber_,
    chartInstance->chartNumber, chartInstance->instanceNumber);
}
static void sf_c19_adcs_v15_integral_Power_no_charge_in_detumb(void)
{
  int32_T c19_previousEvent;
  real_T c19_Latitude;
  real_T c19_Longitude;
  real_T c19_nargout = 4.0;
  real_T c19_nargin = 2.0;
  real_T c19_phi;
  real_T c19_flag_india;
  real_T c19_flag_france;
  real_T c19_flag_downlink;
  real_T c19_Downlink_power;
  real_T c19_a;
  real_T c19_A;
  real_T c19_x;
  real_T c19_b_x;
  real_T c19_c_x;
  real_T c19_d_x;
  real_T c19_b_a;
  real_T c19_e_x;
  real_T c19_b;
  real_T c19_y;
  real_T c19_c_a;
  real_T c19_b_A;
  real_T c19_f_x;
  real_T c19_g_x;
  real_T c19_h_x;
  real_T c19_i_x;
  real_T c19_d_a;
  real_T c19_j_x;
  real_T c19_b_b;
  real_T c19_b_y;
  real_T c19_e_a;
  real_T *c19_b_flag_india;
  real_T *c19_b_flag_france;
  real_T *c19_b_flag_downlink;
  real_T *c19_b_Downlink_power;
  real_T *c19_b_Longitude;
  real_T *c19_b_Latitude;
  c19_b_flag_downlink = (real_T *)ssGetOutputPortSignal(chartInstance.S, 2);
  c19_b_Latitude = (real_T *)ssGetInputPortSignal(chartInstance.S, 0);
  c19_b_flag_india = (real_T *)ssGetOutputPortSignal(chartInstance.S, 4);
  c19_b_Longitude = (real_T *)ssGetInputPortSignal(chartInstance.S, 1);
  c19_b_Downlink_power = (real_T *)ssGetOutputPortSignal(chartInstance.S, 1);
  c19_b_flag_france = (real_T *)ssGetOutputPortSignal(chartInstance.S, 3);
  _sfTime_ = (real_T)ssGetT(chartInstance.S);
  _SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG,13);
  _SFD_DATA_RANGE_CHECK(*c19_b_Latitude, 0U);
  _SFD_DATA_RANGE_CHECK(*c19_b_Longitude, 1U);
  _SFD_DATA_RANGE_CHECK(*c19_b_Downlink_power, 2U);
  _SFD_DATA_RANGE_CHECK(*c19_b_flag_downlink, 3U);
  _SFD_DATA_RANGE_CHECK(*c19_b_flag_france, 4U);
  _SFD_DATA_RANGE_CHECK(*c19_b_flag_india, 5U);
  c19_previousEvent = _sfEvent_;
  _sfEvent_ = CALL_EVENT;
  _SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG,13);
  c19_Latitude = *c19_b_Latitude;
  c19_Longitude = *c19_b_Longitude;
  sf_debug_symbol_scope_push(9U, 0U);
  sf_debug_symbol_scope_add("nargout", &c19_nargout, c19_sf_marshall);
  sf_debug_symbol_scope_add("nargin", &c19_nargin, c19_sf_marshall);
  sf_debug_symbol_scope_add("phi", &c19_phi, c19_sf_marshall);
  sf_debug_symbol_scope_add("flag_india", &c19_flag_india, c19_sf_marshall);
  sf_debug_symbol_scope_add("flag_france", &c19_flag_france, c19_sf_marshall);
  sf_debug_symbol_scope_add("flag_downlink", &c19_flag_downlink, c19_sf_marshall);
  sf_debug_symbol_scope_add("Downlink_power", &c19_Downlink_power,
    c19_sf_marshall);
  sf_debug_symbol_scope_add("Longitude", &c19_Longitude, c19_sf_marshall);
  sf_debug_symbol_scope_add("Latitude", &c19_Latitude, c19_sf_marshall);
  CV_EML_FCN(0, 0);
  _SFD_EML_CALL(0,3);
  c19_phi = 10.0;
  _SFD_EML_CALL(0,4);
  c19_flag_france = 0.0;
  _SFD_EML_CALL(0,5);
  c19_flag_india = 0.0;
  _SFD_EML_CALL(0,6);
  c19_a = c19_Latitude;
  c19_A = c19_a * 3.1415926535897931E+000;
  c19_x = c19_A;
  c19_b_x = c19_x;
  c19_c_x = c19_b_x;
  c19_d_x = c19_c_x / 180.0;
  c19_b_a = c19_d_x;
  c19_e_x = c19_b_a;
  c19_b_a = c19_e_x;
  c19_b_a = muDoubleScalarCos(c19_b_a);
  c19_b = c19_mpower(c19_Longitude - 82.7666);
  c19_y = c19_b_a * c19_b;
  if (CV_EML_IF(0, 0, c19_mpower(c19_Latitude - 22.5833) + c19_y < c19_mpower
                (25.0))) {
    _SFD_EML_CALL(0,7);
    c19_flag_downlink = 1.0;
    _SFD_EML_CALL(0,8);
    c19_flag_india = 1.0;
  } else {
    _SFD_EML_CALL(0,9);
    c19_c_a = c19_Latitude;
    c19_b_A = c19_c_a * 3.1415926535897931E+000;
    c19_f_x = c19_b_A;
    c19_g_x = c19_f_x;
    c19_h_x = c19_g_x;
    c19_i_x = c19_h_x / 180.0;
    c19_d_a = c19_i_x;
    c19_j_x = c19_d_a;
    c19_d_a = c19_j_x;
    c19_d_a = muDoubleScalarCos(c19_d_a);
    c19_b_b = c19_mpower(c19_Longitude - 2.33);
    c19_b_y = c19_d_a * c19_b_b;
    if (CV_EML_IF(0, 1, c19_mpower(c19_Latitude - 48.8) + c19_b_y < c19_mpower
                  (10.0))) {
      _SFD_EML_CALL(0,10);
      c19_flag_downlink = 1.0;
      _SFD_EML_CALL(0,11);
      c19_flag_france = 1.0;
    } else {
      _SFD_EML_CALL(0,13);
      c19_flag_downlink = 0.0;
    }
  }

  _SFD_EML_CALL(0,16);
  c19_e_a = c19_flag_downlink;
  c19_Downlink_power = c19_e_a * 3.5;

  /* W */
  /*   */
  /*  y = u; */
  _SFD_EML_CALL(0,-16);
  sf_debug_symbol_scope_pop();
  *c19_b_Downlink_power = c19_Downlink_power;
  *c19_b_flag_downlink = c19_flag_downlink;
  *c19_b_flag_france = c19_flag_france;
  *c19_b_flag_india = c19_flag_india;
  _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG,13);
  _sfEvent_ = c19_previousEvent;
  sf_debug_check_for_state_inconsistency
    (_adcs_v15_integral_Power_no_charge_in_detumbMachineNumber_,
     chartInstance.chartNumber,
     chartInstance.instanceNumber);
}
static void chart_debug_initialization(SimStruct *S, unsigned int
  fullDebuggerInitialization)
{
  if (!sim_mode_is_rtw_gen(S)) {
    if (ssIsFirstInitCond(S) && fullDebuggerInitialization==1) {
      /* do this only if simulation is starting */
      {
        unsigned int chartAlreadyPresent;
        chartAlreadyPresent = sf_debug_initialize_chart
          (_adcs_v15_integral_Power_no_charge_in_detumbMachineNumber_,
           19,
           1,
           1,
           6,
           0,
           0,
           0,
           0,
           0,
           &(chartInstance.chartNumber),
           &(chartInstance.instanceNumber),
           ssGetPath(S),
           (void *)S);
        if (chartAlreadyPresent==0) {
          /* this is the first instance */
          init_script_number_translation
            (_adcs_v15_integral_Power_no_charge_in_detumbMachineNumber_,
             chartInstance.chartNumber);
          sf_debug_set_chart_disable_implicit_casting
            (_adcs_v15_integral_Power_no_charge_in_detumbMachineNumber_,
             chartInstance.chartNumber,1);
          sf_debug_set_chart_event_thresholds
            (_adcs_v15_integral_Power_no_charge_in_detumbMachineNumber_,
             chartInstance.chartNumber,
             0,
             0,
             0);
          _SFD_SET_DATA_PROPS(0,1,1,0,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,
                              "Latitude",0,(MexFcnForType)c19_sf_marshall);
          _SFD_SET_DATA_PROPS(1,1,1,0,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,
                              "Longitude",0,(MexFcnForType)c19_sf_marshall);
          _SFD_SET_DATA_PROPS(2,2,0,1,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,
                              "Downlink_power",0,(MexFcnForType)c19_sf_marshall);
          _SFD_SET_DATA_PROPS(3,2,0,1,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,
                              "flag_downlink",0,(MexFcnForType)c19_sf_marshall);
          _SFD_SET_DATA_PROPS(4,2,0,1,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,
                              "flag_france",0,(MexFcnForType)c19_sf_marshall);
          _SFD_SET_DATA_PROPS(5,2,0,1,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,
                              "flag_india",0,(MexFcnForType)c19_sf_marshall);
          _SFD_STATE_INFO(0,0,2);
          _SFD_CH_SUBSTATE_COUNT(0);
          _SFD_CH_SUBSTATE_DECOMP(0);
        }

        _SFD_CV_INIT_CHART(0,0,0,0);

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

        _SFD_CV_INIT_TRANS(0,0,NULL,NULL,0,NULL);

        /* Initialization of EML Model Coverage */
        _SFD_CV_INIT_EML(0,1,2,0,0,0,0,0);
        _SFD_CV_INIT_EML_FCN(0,0,"eML_blk_kernel",0,-1,475);
        _SFD_CV_INIT_EML_IF(0,0,141,228,272,426);
        _SFD_CV_INIT_EML_IF(0,1,272,350,395,426);
        _SFD_TRANS_COV_WTS(0,0,0,1,0);
        if (chartAlreadyPresent==0) {
          _SFD_TRANS_COV_MAPS(0,
                              0,NULL,NULL,
                              0,NULL,NULL,
                              1,NULL,NULL,
                              0,NULL,NULL);
        }

        {
          real_T *c19_Latitude;
          real_T *c19_Longitude;
          real_T *c19_Downlink_power;
          real_T *c19_flag_downlink;
          real_T *c19_flag_france;
          real_T *c19_flag_india;
          c19_flag_downlink = (real_T *)ssGetOutputPortSignal(chartInstance.S, 2);
          c19_Latitude = (real_T *)ssGetInputPortSignal(chartInstance.S, 0);
          c19_flag_india = (real_T *)ssGetOutputPortSignal(chartInstance.S, 4);
          c19_Longitude = (real_T *)ssGetInputPortSignal(chartInstance.S, 1);
          c19_Downlink_power = (real_T *)ssGetOutputPortSignal(chartInstance.S,
            1);
          c19_flag_france = (real_T *)ssGetOutputPortSignal(chartInstance.S, 3);
          _SFD_SET_DATA_VALUE_PTR(0U, c19_Latitude);
          _SFD_SET_DATA_VALUE_PTR(1U, c19_Longitude);
          _SFD_SET_DATA_VALUE_PTR(2U, c19_Downlink_power);
          _SFD_SET_DATA_VALUE_PTR(3U, c19_flag_downlink);
          _SFD_SET_DATA_VALUE_PTR(4U, c19_flag_france);
          _SFD_SET_DATA_VALUE_PTR(5U, c19_flag_india);
        }
      }
    } else {
      sf_debug_reset_current_state_configuration
        (_adcs_v15_integral_Power_no_charge_in_detumbMachineNumber_,
         chartInstance.chartNumber,chartInstance.instanceNumber);
    }
  }
}
static void set_sim_state_c19_adcs_v15_integral_Power_no_charge_in_detumb(const
  mxArray *c19_st)
{
  const mxArray *c19_u;
  const mxArray *c19_Downlink_power;
  real_T c19_d0;
  real_T c19_y;
  const mxArray *c19_b_Downlink_power;
  real_T c19_d1;
  real_T c19_b_y;
  const mxArray *c19_c_Downlink_power;
  real_T c19_d2;
  real_T c19_c_y;
  const mxArray *c19_d_Downlink_power;
  real_T c19_d3;
  real_T c19_d_y;
  const mxArray *c19_is_active_c19_adcs_v15_integral_Power_no_charge_in_detumb;
  uint8_T c19_u0;
  uint8_T c19_e_y;
  boolean_T *c19_doneDoubleBufferReInit;
  real_T *c19_e_Downlink_power;
  real_T *c19_flag_downlink;
  real_T *c19_flag_france;
  real_T *c19_flag_india;
  uint8_T *c19_b_is_active_c19_adcs_v15_integral_Power_no_charge_in_detumb;
  c19_flag_downlink = (real_T *)ssGetOutputPortSignal(chartInstance.S, 2);
  c19_b_is_active_c19_adcs_v15_integral_Power_no_charge_in_detumb = (uint8_T *)
    ssGetDWork(chartInstance.S, 2);
  c19_flag_india = (real_T *)ssGetOutputPortSignal(chartInstance.S, 4);
  c19_e_Downlink_power = (real_T *)ssGetOutputPortSignal(chartInstance.S, 1);
  c19_flag_france = (real_T *)ssGetOutputPortSignal(chartInstance.S, 3);
  c19_doneDoubleBufferReInit = (boolean_T *)ssGetDWork(chartInstance.S, 1);
  *c19_doneDoubleBufferReInit = true;
  c19_u = sf_mex_dup(c19_st);
  c19_Downlink_power = sf_mex_dup(sf_mex_getcell(c19_u, 0));
  sf_mex_import("Downlink_power", sf_mex_dup(c19_Downlink_power), &c19_d0, 1, 0,
                0U, 0, 0U, 0);
  c19_y = c19_d0;
  sf_mex_destroy(&c19_Downlink_power);
  *c19_e_Downlink_power = c19_y;
  c19_b_Downlink_power = sf_mex_dup(sf_mex_getcell(c19_u, 1));
  sf_mex_import("flag_downlink", sf_mex_dup(c19_b_Downlink_power), &c19_d1, 1, 0,
                0U, 0, 0U, 0);
  c19_b_y = c19_d1;
  sf_mex_destroy(&c19_b_Downlink_power);
  *c19_flag_downlink = c19_b_y;
  c19_c_Downlink_power = sf_mex_dup(sf_mex_getcell(c19_u, 2));
  sf_mex_import("flag_france", sf_mex_dup(c19_c_Downlink_power), &c19_d2, 1, 0,
                0U, 0, 0U, 0);
  c19_c_y = c19_d2;
  sf_mex_destroy(&c19_c_Downlink_power);
  *c19_flag_france = c19_c_y;
  c19_d_Downlink_power = sf_mex_dup(sf_mex_getcell(c19_u, 3));
  sf_mex_import("flag_india", sf_mex_dup(c19_d_Downlink_power), &c19_d3, 1, 0,
                0U, 0, 0U, 0);
  c19_d_y = c19_d3;
  sf_mex_destroy(&c19_d_Downlink_power);
  *c19_flag_india = c19_d_y;
  c19_is_active_c19_adcs_v15_integral_Power_no_charge_in_detumb = sf_mex_dup
    (sf_mex_getcell(c19_u, 4));
  sf_mex_import("is_active_c19_adcs_v15_integral_Power_no_charge_in_detumb",
                sf_mex_dup(
    c19_is_active_c19_adcs_v15_integral_Power_no_charge_in_detumb), &c19_u0, 1,
                3, 0U, 0, 0U, 0);
  c19_e_y = c19_u0;
  sf_mex_destroy(&c19_is_active_c19_adcs_v15_integral_Power_no_charge_in_detumb);
  *c19_b_is_active_c19_adcs_v15_integral_Power_no_charge_in_detumb = c19_e_y;
  sf_mex_destroy(&c19_u);
  c19_update_debugger_state_c19_adcs_v15_integral_Power_no_charge();
  sf_mex_destroy(&c19_st);
}
コード例 #13
0
static void chart_debug_initialization(SimStruct *S, unsigned int
  fullDebuggerInitialization)
{
  if (!sim_mode_is_rtw_gen(S)) {
    SFc1_TTR_RobustMPC_RTmdlInstanceStruct *chartInstance;
    chartInstance = (SFc1_TTR_RobustMPC_RTmdlInstanceStruct *) ((ChartInfoStruct
      *)(ssGetUserData(S)))->chartInstance;
    if (ssIsFirstInitCond(S) && fullDebuggerInitialization==1) {
      /* do this only if simulation is starting */
      {
        unsigned int chartAlreadyPresent;
        chartAlreadyPresent = sf_debug_initialize_chart
          (sfGlobalDebugInstanceStruct,
           _TTR_RobustMPC_RTmdlMachineNumber_,
           1,
           1,
           1,
           3,
           0,
           0,
           0,
           0,
           0,
           &(chartInstance->chartNumber),
           &(chartInstance->instanceNumber),
           ssGetPath(S),
           (void *)S);
        if (chartAlreadyPresent==0) {
          /* this is the first instance */
          init_script_number_translation(_TTR_RobustMPC_RTmdlMachineNumber_,
            chartInstance->chartNumber);
          sf_debug_set_chart_disable_implicit_casting
            (sfGlobalDebugInstanceStruct,_TTR_RobustMPC_RTmdlMachineNumber_,
             chartInstance->chartNumber,1);
          sf_debug_set_chart_event_thresholds(sfGlobalDebugInstanceStruct,
            _TTR_RobustMPC_RTmdlMachineNumber_,
            chartInstance->chartNumber,
            0,
            0,
            0);
          _SFD_SET_DATA_PROPS(0,1,1,0,"u_ctrl");
          _SFD_SET_DATA_PROPS(1,2,0,1,"u_ctrl_out");
          _SFD_SET_DATA_PROPS(2,1,1,0,"U_bounds");
          _SFD_STATE_INFO(0,0,2);
          _SFD_CH_SUBSTATE_COUNT(0);
          _SFD_CH_SUBSTATE_DECOMP(0);
        }

        _SFD_CV_INIT_CHART(0,0,0,0);

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

        _SFD_CV_INIT_TRANS(0,0,NULL,NULL,0,NULL);

        /* Initialization of MATLAB Function Model Coverage */
        _SFD_CV_INIT_EML(0,1,1,1,0,0,0,1,0,0,0);
        _SFD_CV_INIT_EML_FCN(0,0,"eML_blk_kernel",0,-1,729);
        _SFD_CV_INIT_EML_IF(0,1,0,333,374,538,724);
        _SFD_CV_INIT_EML_FOR(0,1,0,568,593,720);
        _SFD_TRANS_COV_WTS(0,0,0,1,0);
        if (chartAlreadyPresent==0) {
          _SFD_TRANS_COV_MAPS(0,
                              0,NULL,NULL,
                              0,NULL,NULL,
                              1,NULL,NULL,
                              0,NULL,NULL);
        }

        _SFD_SET_DATA_COMPILED_PROPS(0,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,
          (MexFcnForType)c1_sf_marshallOut,(MexInFcnForType)NULL);
        _SFD_SET_DATA_COMPILED_PROPS(1,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,
          (MexFcnForType)c1_sf_marshallOut,(MexInFcnForType)c1_sf_marshallIn);

        {
          unsigned int dimVector[1];
          dimVector[0]= 2;
          _SFD_SET_DATA_COMPILED_PROPS(2,SF_DOUBLE,1,&(dimVector[0]),0,0,0,0.0,
            1.0,0,0,(MexFcnForType)c1_b_sf_marshallOut,(MexInFcnForType)NULL);
        }

        {
          real_T *c1_u_ctrl;
          real_T *c1_u_ctrl_out;
          real_T (*c1_U_bounds)[2];
          c1_U_bounds = (real_T (*)[2])ssGetInputPortSignal(chartInstance->S, 1);
          c1_u_ctrl_out = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
          c1_u_ctrl = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
          _SFD_SET_DATA_VALUE_PTR(0U, c1_u_ctrl);
          _SFD_SET_DATA_VALUE_PTR(1U, c1_u_ctrl_out);
          _SFD_SET_DATA_VALUE_PTR(2U, *c1_U_bounds);
        }
      }
    } else {
      sf_debug_reset_current_state_configuration(sfGlobalDebugInstanceStruct,
        _TTR_RobustMPC_RTmdlMachineNumber_,chartInstance->chartNumber,
        chartInstance->instanceNumber);
    }
  }
}
コード例 #14
0
static void sf_c1_TTR_RobustMPC_RTmdl(SFc1_TTR_RobustMPC_RTmdlInstanceStruct
  *chartInstance)
{
  int32_T c1_i0;
  real_T c1_hoistedGlobal;
  real_T c1_u_ctrl;
  int32_T c1_i1;
  real_T c1_U_bounds[2];
  uint32_T c1_debug_family_var_map[6];
  real_T c1_i;
  real_T c1_nargin = 2.0;
  real_T c1_nargout = 1.0;
  real_T c1_u_ctrl_out;
  real_T c1_varargin_1;
  real_T c1_varargin_2;
  real_T c1_b_varargin_2;
  real_T c1_varargin_3;
  real_T c1_x;
  real_T c1_y;
  real_T c1_b_x;
  real_T c1_b_y;
  real_T c1_xk;
  real_T c1_yk;
  real_T c1_c_x;
  real_T c1_c_y;
  real_T c1_b_varargin_1;
  real_T c1_c_varargin_2;
  real_T c1_d_varargin_2;
  real_T c1_b_varargin_3;
  real_T c1_d_x;
  real_T c1_d_y;
  real_T c1_e_x;
  real_T c1_e_y;
  real_T c1_b_xk;
  real_T c1_b_yk;
  real_T c1_f_x;
  real_T c1_f_y;
  real_T *c1_b_u_ctrl;
  real_T *c1_b_u_ctrl_out;
  real_T (*c1_b_U_bounds)[2];
  c1_b_U_bounds = (real_T (*)[2])ssGetInputPortSignal(chartInstance->S, 1);
  c1_b_u_ctrl_out = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
  c1_b_u_ctrl = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
  _sfTime_ = (real_T)ssGetT(chartInstance->S);
  _SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 0U, chartInstance->c1_sfEvent);
  _SFD_DATA_RANGE_CHECK(*c1_b_u_ctrl, 0U);
  _SFD_DATA_RANGE_CHECK(*c1_b_u_ctrl_out, 1U);
  for (c1_i0 = 0; c1_i0 < 2; c1_i0++) {
    _SFD_DATA_RANGE_CHECK((*c1_b_U_bounds)[c1_i0], 2U);
  }

  chartInstance->c1_sfEvent = CALL_EVENT;
  _SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 0U, chartInstance->c1_sfEvent);
  c1_hoistedGlobal = *c1_b_u_ctrl;
  c1_u_ctrl = c1_hoistedGlobal;
  for (c1_i1 = 0; c1_i1 < 2; c1_i1++) {
    c1_U_bounds[c1_i1] = (*c1_b_U_bounds)[c1_i1];
  }

  _SFD_SYMBOL_SCOPE_PUSH_EML(0U, 6U, 6U, c1_debug_family_names,
    c1_debug_family_var_map);
  _SFD_SYMBOL_SCOPE_ADD_EML(&c1_i, 0U, c1_sf_marshallOut);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c1_nargin, 1U, c1_sf_marshallOut,
    c1_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c1_nargout, 2U, c1_sf_marshallOut,
    c1_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML(&c1_u_ctrl, 3U, c1_sf_marshallOut);
  _SFD_SYMBOL_SCOPE_ADD_EML(c1_U_bounds, 4U, c1_b_sf_marshallOut);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c1_u_ctrl_out, 5U, c1_sf_marshallOut,
    c1_sf_marshallIn);
  CV_EML_FCN(0, 0);
  _SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 9);
  c1_u_ctrl_out = c1_u_ctrl;
  _SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 11);
  CV_EML_IF(0, 1, 0, FALSE);
  _SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 17);
  c1_i = 1.0;
  CV_EML_FOR(0, 1, 0, 1);
  _SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 18);
  c1_varargin_1 = c1_u_ctrl;
  c1_varargin_2 = c1_U_bounds[0];
  c1_b_varargin_2 = c1_varargin_1;
  c1_varargin_3 = c1_varargin_2;
  c1_x = c1_b_varargin_2;
  c1_y = c1_varargin_3;
  c1_b_x = c1_x;
  c1_b_y = c1_y;
  c1_eml_scalar_eg(chartInstance);
  c1_xk = c1_b_x;
  c1_yk = c1_b_y;
  c1_c_x = c1_xk;
  c1_c_y = c1_yk;
  c1_eml_scalar_eg(chartInstance);
  c1_u_ctrl_out = muDoubleScalarMax(c1_c_x, c1_c_y);
  _SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 19);
  c1_b_varargin_1 = c1_u_ctrl;
  c1_c_varargin_2 = c1_U_bounds[1];
  c1_d_varargin_2 = c1_b_varargin_1;
  c1_b_varargin_3 = c1_c_varargin_2;
  c1_d_x = c1_d_varargin_2;
  c1_d_y = c1_b_varargin_3;
  c1_e_x = c1_d_x;
  c1_e_y = c1_d_y;
  c1_eml_scalar_eg(chartInstance);
  c1_b_xk = c1_e_x;
  c1_b_yk = c1_e_y;
  c1_f_x = c1_b_xk;
  c1_f_y = c1_b_yk;
  c1_eml_scalar_eg(chartInstance);
  c1_u_ctrl_out = muDoubleScalarMin(c1_f_x, c1_f_y);
  CV_EML_FOR(0, 1, 0, 0);
  _SFD_EML_CALL(0U, chartInstance->c1_sfEvent, -19);
  _SFD_SYMBOL_SCOPE_POP();
  *c1_b_u_ctrl_out = c1_u_ctrl_out;
  _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 0U, chartInstance->c1_sfEvent);
  _SFD_CHECK_FOR_STATE_INCONSISTENCY(_TTR_RobustMPC_RTmdlMachineNumber_,
    chartInstance->chartNumber, chartInstance->instanceNumber);
}
コード例 #15
0
static void sf_gateway_c14_Demo_P_IdleRand(SFc14_Demo_P_IdleRandInstanceStruct
  *chartInstance)
{
  real_T c14_hoistedGlobal;
  real_T c14_interactionState;
  uint32_T c14_debug_family_var_map[4];
  real_T c14_nargin = 1.0;
  real_T c14_nargout = 1.0;
  real_T c14_arousalFlag;
  real_T *c14_b_interactionState;
  real_T *c14_b_arousalFlag;
  c14_b_arousalFlag = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
  c14_b_interactionState = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
  _SFD_SYMBOL_SCOPE_PUSH(0U, 0U);
  _sfTime_ = sf_get_time(chartInstance->S);
  _SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 10U, chartInstance->c14_sfEvent);
  _SFD_DATA_RANGE_CHECK(*c14_b_interactionState, 0U);
  chartInstance->c14_sfEvent = CALL_EVENT;
  _SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 10U, chartInstance->c14_sfEvent);
  c14_hoistedGlobal = *c14_b_interactionState;
  c14_interactionState = c14_hoistedGlobal;
  _SFD_SYMBOL_SCOPE_PUSH_EML(0U, 4U, 4U, c14_debug_family_names,
    c14_debug_family_var_map);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c14_nargin, 0U, c14_sf_marshallOut,
    c14_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c14_nargout, 1U, c14_sf_marshallOut,
    c14_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML(&c14_interactionState, 2U, c14_sf_marshallOut);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c14_arousalFlag, 3U, c14_sf_marshallOut,
    c14_sf_marshallIn);
  CV_EML_FCN(0, 0);
  _SFD_EML_CALL(0U, chartInstance->c14_sfEvent, 13);
  if (CV_EML_IF(0, 1, 0, c14_interactionState == 1.0)) {
    _SFD_EML_CALL(0U, chartInstance->c14_sfEvent, 14);
    c14_arousalFlag = 1.0;
  } else {
    _SFD_EML_CALL(0U, chartInstance->c14_sfEvent, 15);
    if (CV_EML_IF(0, 1, 1, c14_interactionState == 0.0)) {
      _SFD_EML_CALL(0U, chartInstance->c14_sfEvent, 16);
      c14_arousalFlag = 1.0;
    } else {
      _SFD_EML_CALL(0U, chartInstance->c14_sfEvent, 18);
      if (CV_EML_IF(0, 1, 2, c14_interactionState == 2.0)) {
        _SFD_EML_CALL(0U, chartInstance->c14_sfEvent, 19);
        c14_arousalFlag = -1.0;
      } else {
        _SFD_EML_CALL(0U, chartInstance->c14_sfEvent, 20);
        if (CV_EML_IF(0, 1, 3, c14_interactionState == 6.0)) {
          _SFD_EML_CALL(0U, chartInstance->c14_sfEvent, 21);
          c14_arousalFlag = -1.0;
        } else {
          _SFD_EML_CALL(0U, chartInstance->c14_sfEvent, 22);
          if (CV_EML_IF(0, 1, 4, c14_interactionState == 3.0)) {
            _SFD_EML_CALL(0U, chartInstance->c14_sfEvent, 23);
            c14_arousalFlag = -1.0;
          } else {
            _SFD_EML_CALL(0U, chartInstance->c14_sfEvent, 26);
            c14_arousalFlag = 0.0;
          }
        }
      }
    }
  }

  _SFD_EML_CALL(0U, chartInstance->c14_sfEvent, -26);
  _SFD_SYMBOL_SCOPE_POP();
  *c14_b_arousalFlag = c14_arousalFlag;
  _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 10U, chartInstance->c14_sfEvent);
  _SFD_SYMBOL_SCOPE_POP();
  _SFD_CHECK_FOR_STATE_INCONSISTENCY(_Demo_P_IdleRandMachineNumber_,
    chartInstance->chartNumber, chartInstance->instanceNumber);
  _SFD_DATA_RANGE_CHECK(*c14_b_arousalFlag, 1U);
}
コード例 #16
0
static void sf_c14_Model_justmodel(SFc14_Model_justmodelInstanceStruct
  *chartInstance)
{
  int32_T c14_i4;
  int32_T c14_i5;
  int32_T c14_i6;
  int32_T c14_i7;
  real_T c14_eta_s_in[3];
  uint32_T c14_debug_family_var_map[9];
  real_T c14_eta_s[3];
  real_T c14_psi;
  real_T c14_c;
  real_T c14_s;
  real_T c14_nargin = 1.0;
  real_T c14_nargout = 2.0;
  real_T c14_Rs[9];
  real_T c14_Rst[9];
  int32_T c14_i8;
  real_T c14_x;
  real_T c14_b_x;
  real_T c14_c_x;
  real_T c14_d_x;
  int32_T c14_i9;
  int32_T c14_i10;
  static real_T c14_dv2[3] = { 0.0, 0.0, 1.0 };

  int32_T c14_i11;
  int32_T c14_i12;
  int32_T c14_i13;
  int32_T c14_i14;
  int32_T c14_i15;
  int32_T c14_i16;
  real_T (*c14_b_Rs)[9];
  real_T (*c14_b_Rst)[9];
  real_T (*c14_b_eta_s_in)[3];
  c14_b_Rst = (real_T (*)[9])ssGetOutputPortSignal(chartInstance->S, 2);
  c14_b_Rs = (real_T (*)[9])ssGetOutputPortSignal(chartInstance->S, 1);
  c14_b_eta_s_in = (real_T (*)[3])ssGetInputPortSignal(chartInstance->S, 0);
  _sfTime_ = (real_T)ssGetT(chartInstance->S);
  _SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 13U, chartInstance->c14_sfEvent);
  for (c14_i4 = 0; c14_i4 < 3; c14_i4++) {
    _SFD_DATA_RANGE_CHECK((*c14_b_eta_s_in)[c14_i4], 0U);
  }

  for (c14_i5 = 0; c14_i5 < 9; c14_i5++) {
    _SFD_DATA_RANGE_CHECK((*c14_b_Rs)[c14_i5], 1U);
  }

  for (c14_i6 = 0; c14_i6 < 9; c14_i6++) {
    _SFD_DATA_RANGE_CHECK((*c14_b_Rst)[c14_i6], 2U);
  }

  chartInstance->c14_sfEvent = CALL_EVENT;
  _SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 13U, chartInstance->c14_sfEvent);
  for (c14_i7 = 0; c14_i7 < 3; c14_i7++) {
    c14_eta_s_in[c14_i7] = (*c14_b_eta_s_in)[c14_i7];
  }

  _SFD_SYMBOL_SCOPE_PUSH_EML(0U, 9U, 9U, c14_debug_family_names,
    c14_debug_family_var_map);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(c14_eta_s, 0U, c14_b_sf_marshallOut,
    c14_c_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c14_psi, 1U, c14_c_sf_marshallOut,
    c14_b_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c14_c, 2U, c14_c_sf_marshallOut,
    c14_b_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c14_s, 3U, c14_c_sf_marshallOut,
    c14_b_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c14_nargin, 4U, c14_c_sf_marshallOut,
    c14_b_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c14_nargout, 5U, c14_c_sf_marshallOut,
    c14_b_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML(c14_eta_s_in, 6U, c14_b_sf_marshallOut);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(c14_Rs, 7U, c14_sf_marshallOut,
    c14_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(c14_Rst, 8U, c14_sf_marshallOut,
    c14_sf_marshallIn);
  CV_EML_FCN(0, 0);
  _SFD_EML_CALL(0U, chartInstance->c14_sfEvent, 3);
  CV_EML_IF(0, 1, 0, TRUE);
  _SFD_EML_CALL(0U, chartInstance->c14_sfEvent, 4);
  for (c14_i8 = 0; c14_i8 < 3; c14_i8++) {
    c14_eta_s[c14_i8] = c14_eta_s_in[c14_i8];
  }

  _SFD_EML_CALL(0U, chartInstance->c14_sfEvent, 9);
  c14_psi = c14_eta_s[2];
  _SFD_EML_CALL(0U, chartInstance->c14_sfEvent, 11);
  c14_x = c14_psi;
  c14_c = c14_x;
  c14_b_x = c14_c;
  c14_c = c14_b_x;
  c14_c = muDoubleScalarCos(c14_c);
  _SFD_EML_CALL(0U, chartInstance->c14_sfEvent, 12);
  c14_c_x = c14_psi;
  c14_s = c14_c_x;
  c14_d_x = c14_s;
  c14_s = c14_d_x;
  c14_s = muDoubleScalarSin(c14_s);
  _SFD_EML_CALL(0U, chartInstance->c14_sfEvent, 14);
  c14_Rs[0] = c14_c;
  c14_Rs[3] = -c14_s;
  c14_Rs[6] = 0.0;
  c14_Rs[1] = c14_s;
  c14_Rs[4] = c14_c;
  c14_Rs[7] = 0.0;
  c14_i9 = 0;
  for (c14_i10 = 0; c14_i10 < 3; c14_i10++) {
    c14_Rs[c14_i9 + 2] = c14_dv2[c14_i10];
    c14_i9 += 3;
  }

  _SFD_EML_CALL(0U, chartInstance->c14_sfEvent, 17);
  c14_i11 = 0;
  for (c14_i12 = 0; c14_i12 < 3; c14_i12++) {
    c14_i13 = 0;
    for (c14_i14 = 0; c14_i14 < 3; c14_i14++) {
      c14_Rst[c14_i14 + c14_i11] = c14_Rs[c14_i13 + c14_i12];
      c14_i13 += 3;
    }

    c14_i11 += 3;
  }

  _SFD_EML_CALL(0U, chartInstance->c14_sfEvent, -17);
  _SFD_SYMBOL_SCOPE_POP();
  for (c14_i15 = 0; c14_i15 < 9; c14_i15++) {
    (*c14_b_Rs)[c14_i15] = c14_Rs[c14_i15];
  }

  for (c14_i16 = 0; c14_i16 < 9; c14_i16++) {
    (*c14_b_Rst)[c14_i16] = c14_Rst[c14_i16];
  }

  _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 13U, chartInstance->c14_sfEvent);
  _SFD_CHECK_FOR_STATE_INCONSISTENCY(_Model_justmodelMachineNumber_,
    chartInstance->chartNumber, chartInstance->instanceNumber);
}
コード例 #17
0
static void chart_debug_initialization(SimStruct *S, unsigned int
  fullDebuggerInitialization)
{
  if (!sim_mode_is_rtw_gen(S)) {
    SFc14_Demo_P_IdleRandInstanceStruct *chartInstance;
    ChartRunTimeInfo * crtInfo = (ChartRunTimeInfo *)(ssGetUserData(S));
    ChartInfoStruct * chartInfo = (ChartInfoStruct *)(crtInfo->instanceInfo);
    chartInstance = (SFc14_Demo_P_IdleRandInstanceStruct *)
      chartInfo->chartInstance;
    if (ssIsFirstInitCond(S) && fullDebuggerInitialization==1) {
      /* do this only if simulation is starting */
      {
        unsigned int chartAlreadyPresent;
        chartAlreadyPresent = sf_debug_initialize_chart
          (sfGlobalDebugInstanceStruct,
           _Demo_P_IdleRandMachineNumber_,
           14,
           1,
           1,
           0,
           2,
           0,
           0,
           0,
           0,
           0,
           &(chartInstance->chartNumber),
           &(chartInstance->instanceNumber),
           (void *)S);

        /* Each instance must initialize ist own list of scripts */
        init_script_number_translation(_Demo_P_IdleRandMachineNumber_,
          chartInstance->chartNumber,chartInstance->instanceNumber);
        if (chartAlreadyPresent==0) {
          /* this is the first instance */
          sf_debug_set_chart_disable_implicit_casting
            (sfGlobalDebugInstanceStruct,_Demo_P_IdleRandMachineNumber_,
             chartInstance->chartNumber,1);
          sf_debug_set_chart_event_thresholds(sfGlobalDebugInstanceStruct,
            _Demo_P_IdleRandMachineNumber_,
            chartInstance->chartNumber,
            0,
            0,
            0);
          _SFD_SET_DATA_PROPS(0,1,1,0,"interactionState");
          _SFD_SET_DATA_PROPS(1,2,0,1,"arousalFlag");
          _SFD_STATE_INFO(0,0,2);
          _SFD_CH_SUBSTATE_COUNT(0);
          _SFD_CH_SUBSTATE_DECOMP(0);
        }

        _SFD_CV_INIT_CHART(0,0,0,0);

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

        _SFD_CV_INIT_TRANS(0,0,NULL,NULL,0,NULL);

        /* Initialization of MATLAB Function Model Coverage */
        _SFD_CV_INIT_EML(0,1,1,5,0,0,0,0,0,0,0);
        _SFD_CV_INIT_EML_FCN(0,0,"eML_blk_kernel",0,-1,768);
        _SFD_CV_INIT_EML_IF(0,1,0,370,393,440,768);
        _SFD_CV_INIT_EML_IF(0,1,1,440,467,516,768);
        _SFD_CV_INIT_EML_IF(0,1,2,516,543,592,768);
        _SFD_CV_INIT_EML_IF(0,1,3,592,619,666,768);
        _SFD_CV_INIT_EML_IF(0,1,4,666,693,740,768);
        _SFD_SET_DATA_COMPILED_PROPS(0,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,
          (MexFcnForType)c14_sf_marshallOut,(MexInFcnForType)NULL);
        _SFD_SET_DATA_COMPILED_PROPS(1,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,
          (MexFcnForType)c14_sf_marshallOut,(MexInFcnForType)c14_sf_marshallIn);

        {
          real_T *c14_interactionState;
          real_T *c14_arousalFlag;
          c14_arousalFlag = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
          c14_interactionState = (real_T *)ssGetInputPortSignal(chartInstance->S,
            0);
          _SFD_SET_DATA_VALUE_PTR(0U, c14_interactionState);
          _SFD_SET_DATA_VALUE_PTR(1U, c14_arousalFlag);
        }
      }
    } else {
      sf_debug_reset_current_state_configuration(sfGlobalDebugInstanceStruct,
        _Demo_P_IdleRandMachineNumber_,chartInstance->chartNumber,
        chartInstance->instanceNumber);
    }
  }
}
コード例 #18
0
static void sf_c13_Final_Project_v3c(SFc13_Final_Project_v3cInstanceStruct
  *chartInstance)
{
  int32_T c13_i2;
  int32_T c13_i3;
  int32_T c13_i4;
  real_T c13_hoistedGlobal;
  int32_T c13_i5;
  real_T c13_u[3];
  int32_T c13_i6;
  real_T c13_ur[3];
  real_T c13_coll;
  uint32_T c13_debug_family_var_map[6];
  real_T c13_nargin = 3.0;
  real_T c13_nargout = 1.0;
  real_T c13_y[3];
  int32_T c13_i7;
  int32_T c13_i8;
  int32_T c13_i9;
  real_T *c13_b_coll;
  real_T (*c13_b_y)[3];
  real_T (*c13_b_ur)[3];
  real_T (*c13_b_u)[3];
  c13_b_coll = (real_T *)ssGetInputPortSignal(chartInstance->S, 2);
  c13_b_ur = (real_T (*)[3])ssGetInputPortSignal(chartInstance->S, 1);
  c13_b_y = (real_T (*)[3])ssGetOutputPortSignal(chartInstance->S, 1);
  c13_b_u = (real_T (*)[3])ssGetInputPortSignal(chartInstance->S, 0);
  _sfTime_ = (real_T)ssGetT(chartInstance->S);
  _SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 12U, chartInstance->c13_sfEvent);
  for (c13_i2 = 0; c13_i2 < 3; c13_i2++) {
    _SFD_DATA_RANGE_CHECK((*c13_b_u)[c13_i2], 0U);
  }

  for (c13_i3 = 0; c13_i3 < 3; c13_i3++) {
    _SFD_DATA_RANGE_CHECK((*c13_b_y)[c13_i3], 1U);
  }

  for (c13_i4 = 0; c13_i4 < 3; c13_i4++) {
    _SFD_DATA_RANGE_CHECK((*c13_b_ur)[c13_i4], 2U);
  }

  _SFD_DATA_RANGE_CHECK(*c13_b_coll, 3U);
  chartInstance->c13_sfEvent = CALL_EVENT;
  _SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 12U, chartInstance->c13_sfEvent);
  c13_hoistedGlobal = *c13_b_coll;
  for (c13_i5 = 0; c13_i5 < 3; c13_i5++) {
    c13_u[c13_i5] = (*c13_b_u)[c13_i5];
  }

  for (c13_i6 = 0; c13_i6 < 3; c13_i6++) {
    c13_ur[c13_i6] = (*c13_b_ur)[c13_i6];
  }

  c13_coll = c13_hoistedGlobal;
  _SFD_SYMBOL_SCOPE_PUSH_EML(0U, 6U, 6U, c13_debug_family_names,
    c13_debug_family_var_map);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c13_nargin, 0U, c13_b_sf_marshallOut,
    c13_b_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c13_nargout, 1U, c13_b_sf_marshallOut,
    c13_b_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML(c13_u, 2U, c13_sf_marshallOut);
  _SFD_SYMBOL_SCOPE_ADD_EML(c13_ur, 3U, c13_sf_marshallOut);
  _SFD_SYMBOL_SCOPE_ADD_EML(&c13_coll, 4U, c13_b_sf_marshallOut);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(c13_y, 5U, c13_sf_marshallOut,
    c13_sf_marshallIn);
  CV_EML_FCN(0, 0);
  _SFD_EML_CALL(0U, chartInstance->c13_sfEvent, 6);
  if (CV_EML_IF(0, 1, 0, c13_coll == 0.0)) {
    _SFD_EML_CALL(0U, chartInstance->c13_sfEvent, 8);
    for (c13_i7 = 0; c13_i7 < 3; c13_i7++) {
      c13_y[c13_i7] = c13_ur[c13_i7];
    }
  } else {
    _SFD_EML_CALL(0U, chartInstance->c13_sfEvent, 12);
    for (c13_i8 = 0; c13_i8 < 3; c13_i8++) {
      c13_y[c13_i8] = c13_u[c13_i8];
    }
  }

  _SFD_EML_CALL(0U, chartInstance->c13_sfEvent, -12);
  _SFD_SYMBOL_SCOPE_POP();
  for (c13_i9 = 0; c13_i9 < 3; c13_i9++) {
    (*c13_b_y)[c13_i9] = c13_y[c13_i9];
  }

  _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 12U, chartInstance->c13_sfEvent);
  _SFD_CHECK_FOR_STATE_INCONSISTENCY(_Final_Project_v3cMachineNumber_,
    chartInstance->chartNumber, chartInstance->instanceNumber);
}
コード例 #19
0
static void chart_debug_initialization(SimStruct *S, unsigned int
  fullDebuggerInitialization)
{
  if (!sim_mode_is_rtw_gen(S)) {
    SFc6_ArrayInstanceStruct *chartInstance;
    chartInstance = (SFc6_ArrayInstanceStruct *) ((ChartInfoStruct *)
      (ssGetUserData(S)))->chartInstance;
    if (ssIsFirstInitCond(S) && fullDebuggerInitialization==1) {
      /* do this only if simulation is starting */
      {
        unsigned int chartAlreadyPresent;
        chartAlreadyPresent = sf_debug_initialize_chart(_ArrayMachineNumber_,
          6,
          1,
          1,
          4,
          0,
          0,
          0,
          0,
          0,
          &(chartInstance->chartNumber),
          &(chartInstance->instanceNumber),
          ssGetPath(S),
          (void *)S);
        if (chartAlreadyPresent==0) {
          /* this is the first instance */
          init_script_number_translation(_ArrayMachineNumber_,
            chartInstance->chartNumber);
          sf_debug_set_chart_disable_implicit_casting(_ArrayMachineNumber_,
            chartInstance->chartNumber,1);
          sf_debug_set_chart_event_thresholds(_ArrayMachineNumber_,
            chartInstance->chartNumber,
            0,
            0,
            0);
          _SFD_SET_DATA_PROPS(0,1,1,0,"V");
          _SFD_SET_DATA_PROPS(1,2,0,1,"I");
          _SFD_SET_DATA_PROPS(2,1,1,0,"Radiacion");
          _SFD_SET_DATA_PROPS(3,1,1,0,"Temp");
          _SFD_STATE_INFO(0,0,2);
          _SFD_CH_SUBSTATE_COUNT(0);
          _SFD_CH_SUBSTATE_DECOMP(0);
        }

        _SFD_CV_INIT_CHART(0,0,0,0);

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

        _SFD_CV_INIT_TRANS(0,0,NULL,NULL,0,NULL);

        /* Initialization of MATLAB Function Model Coverage */
        _SFD_CV_INIT_EML(0,1,1,0,0,0,1,0,0,0);
        _SFD_CV_INIT_EML_FCN(0,0,"eML_blk_kernel",0,-1,947);
        _SFD_CV_INIT_EML_FOR(0,1,0,777,788,942);
        _SFD_TRANS_COV_WTS(0,0,0,1,0);
        if (chartAlreadyPresent==0) {
          _SFD_TRANS_COV_MAPS(0,
                              0,NULL,NULL,
                              0,NULL,NULL,
                              1,NULL,NULL,
                              0,NULL,NULL);
        }

        _SFD_SET_DATA_COMPILED_PROPS(0,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,
          (MexFcnForType)c6_sf_marshallOut,(MexInFcnForType)NULL);
        _SFD_SET_DATA_COMPILED_PROPS(1,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,
          (MexFcnForType)c6_sf_marshallOut,(MexInFcnForType)c6_sf_marshallIn);
        _SFD_SET_DATA_COMPILED_PROPS(2,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,
          (MexFcnForType)c6_sf_marshallOut,(MexInFcnForType)NULL);
        _SFD_SET_DATA_COMPILED_PROPS(3,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,
          (MexFcnForType)c6_sf_marshallOut,(MexInFcnForType)NULL);

        {
          real_T *c6_V;
          real_T *c6_I;
          real_T *c6_Radiacion;
          real_T *c6_Temp;
          c6_Temp = (real_T *)ssGetInputPortSignal(chartInstance->S, 2);
          c6_Radiacion = (real_T *)ssGetInputPortSignal(chartInstance->S, 1);
          c6_I = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
          c6_V = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
          _SFD_SET_DATA_VALUE_PTR(0U, c6_V);
          _SFD_SET_DATA_VALUE_PTR(1U, c6_I);
          _SFD_SET_DATA_VALUE_PTR(2U, c6_Radiacion);
          _SFD_SET_DATA_VALUE_PTR(3U, c6_Temp);
        }
      }
    } else {
      sf_debug_reset_current_state_configuration(_ArrayMachineNumber_,
        chartInstance->chartNumber,chartInstance->instanceNumber);
    }
  }
}
コード例 #20
0
static void sf_c13_BoatLibraryTest01(SFc13_BoatLibraryTest01InstanceStruct
  *chartInstance)
{
  int32_T c13_i2;
  real_T c13_hoistedGlobal;
  real_T c13_b_hoistedGlobal;
  real_T c13_c_hoistedGlobal;
  real_T c13_Fx;
  real_T c13_Fy;
  real_T c13_M;
  uint32_T c13_debug_family_var_map[6];
  real_T c13_nargin = 3.0;
  real_T c13_nargout = 1.0;
  real_T c13_y[3];
  int32_T c13_i3;
  real_T *c13_b_Fx;
  real_T *c13_b_Fy;
  real_T *c13_b_M;
  real_T (*c13_b_y)[3];
  c13_b_M = (real_T *)ssGetInputPortSignal(chartInstance->S, 2);
  c13_b_Fy = (real_T *)ssGetInputPortSignal(chartInstance->S, 1);
  c13_b_y = (real_T (*)[3])ssGetOutputPortSignal(chartInstance->S, 1);
  c13_b_Fx = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
  _SFD_SYMBOL_SCOPE_PUSH(0U, 0U);
  _sfTime_ = (real_T)ssGetT(chartInstance->S);
  _SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 12U, chartInstance->c13_sfEvent);
  _SFD_DATA_RANGE_CHECK(*c13_b_Fx, 0U);
  for (c13_i2 = 0; c13_i2 < 3; c13_i2++) {
    _SFD_DATA_RANGE_CHECK((*c13_b_y)[c13_i2], 1U);
  }

  _SFD_DATA_RANGE_CHECK(*c13_b_Fy, 2U);
  _SFD_DATA_RANGE_CHECK(*c13_b_M, 3U);
  chartInstance->c13_sfEvent = CALL_EVENT;
  _SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 12U, chartInstance->c13_sfEvent);
  c13_hoistedGlobal = *c13_b_Fx;
  c13_b_hoistedGlobal = *c13_b_Fy;
  c13_c_hoistedGlobal = *c13_b_M;
  c13_Fx = c13_hoistedGlobal;
  c13_Fy = c13_b_hoistedGlobal;
  c13_M = c13_c_hoistedGlobal;
  _SFD_SYMBOL_SCOPE_PUSH_EML(0U, 6U, 6U, c13_debug_family_names,
    c13_debug_family_var_map);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c13_nargin, 0U, c13_b_sf_marshallOut,
    c13_b_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c13_nargout, 1U, c13_b_sf_marshallOut,
    c13_b_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML(&c13_Fx, 2U, c13_b_sf_marshallOut);
  _SFD_SYMBOL_SCOPE_ADD_EML(&c13_Fy, 3U, c13_b_sf_marshallOut);
  _SFD_SYMBOL_SCOPE_ADD_EML(&c13_M, 4U, c13_b_sf_marshallOut);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(c13_y, 5U, c13_sf_marshallOut,
    c13_sf_marshallIn);
  CV_EML_FCN(0, 0);
  _SFD_EML_CALL(0U, chartInstance->c13_sfEvent, 4);
  c13_y[0] = c13_Fx;
  c13_y[1] = c13_Fy;
  c13_y[2] = c13_M;
  _SFD_EML_CALL(0U, chartInstance->c13_sfEvent, -4);
  _SFD_SYMBOL_SCOPE_POP();
  for (c13_i3 = 0; c13_i3 < 3; c13_i3++) {
    (*c13_b_y)[c13_i3] = c13_y[c13_i3];
  }

  _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 12U, chartInstance->c13_sfEvent);
  _SFD_SYMBOL_SCOPE_POP();
  _SFD_CHECK_FOR_STATE_INCONSISTENCY(_BoatLibraryTest01MachineNumber_,
    chartInstance->chartNumber, chartInstance->instanceNumber);
}
コード例 #21
0
static void chart_debug_initialization(SimStruct *S, unsigned int
  fullDebuggerInitialization)
{
  if (!sim_mode_is_rtw_gen(S)) {
    SFc10_HIL_model_overallInstanceStruct *chartInstance;
    chartInstance = (SFc10_HIL_model_overallInstanceStruct *) ((ChartInfoStruct *)
      (ssGetUserData(S)))->chartInstance;
    if (ssIsFirstInitCond(S) && fullDebuggerInitialization==1) {
      /* do this only if simulation is starting */
      {
        unsigned int chartAlreadyPresent;
        chartAlreadyPresent = sf_debug_initialize_chart
          (sfGlobalDebugInstanceStruct,
           _HIL_model_overallMachineNumber_,
           10,
           1,
           1,
           2,
           0,
           0,
           0,
           0,
           0,
           &(chartInstance->chartNumber),
           &(chartInstance->instanceNumber),
           ssGetPath(S),
           (void *)S);
        if (chartAlreadyPresent==0) {
          /* this is the first instance */
          init_script_number_translation(_HIL_model_overallMachineNumber_,
            chartInstance->chartNumber);
          sf_debug_set_chart_disable_implicit_casting
            (sfGlobalDebugInstanceStruct,_HIL_model_overallMachineNumber_,
             chartInstance->chartNumber,1);
          sf_debug_set_chart_event_thresholds(sfGlobalDebugInstanceStruct,
            _HIL_model_overallMachineNumber_,
            chartInstance->chartNumber,
            0,
            0,
            0);
          _SFD_SET_DATA_PROPS(0,1,1,0,"eta");
          _SFD_SET_DATA_PROPS(1,2,0,1,"R");
          _SFD_STATE_INFO(0,0,2);
          _SFD_CH_SUBSTATE_COUNT(0);
          _SFD_CH_SUBSTATE_DECOMP(0);
        }

        _SFD_CV_INIT_CHART(0,0,0,0);

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

        _SFD_CV_INIT_TRANS(0,0,NULL,NULL,0,NULL);

        /* Initialization of MATLAB Function Model Coverage */
        _SFD_CV_INIT_EML(0,1,1,1,0,0,0,0,0,0,0);
        _SFD_CV_INIT_EML_FCN(0,0,"eML_blk_kernel",0,-1,149);
        _SFD_CV_INIT_EML_IF(0,1,0,23,41,60,81);
        _SFD_TRANS_COV_WTS(0,0,0,1,0);
        if (chartAlreadyPresent==0) {
          _SFD_TRANS_COV_MAPS(0,
                              0,NULL,NULL,
                              0,NULL,NULL,
                              1,NULL,NULL,
                              0,NULL,NULL);
        }

        {
          unsigned int dimVector[1];
          dimVector[0]= 3;
          _SFD_SET_DATA_COMPILED_PROPS(0,SF_DOUBLE,1,&(dimVector[0]),0,0,0,0.0,
            1.0,0,0,(MexFcnForType)c10_b_sf_marshallOut,(MexInFcnForType)NULL);
        }

        {
          unsigned int dimVector[2];
          dimVector[0]= 3;
          dimVector[1]= 3;
          _SFD_SET_DATA_COMPILED_PROPS(1,SF_DOUBLE,2,&(dimVector[0]),0,0,0,0.0,
            1.0,0,0,(MexFcnForType)c10_sf_marshallOut,(MexInFcnForType)
            c10_sf_marshallIn);
        }

        {
          real_T (*c10_eta)[3];
          real_T (*c10_R)[9];
          c10_R = (real_T (*)[9])ssGetOutputPortSignal(chartInstance->S, 1);
          c10_eta = (real_T (*)[3])ssGetInputPortSignal(chartInstance->S, 0);
          _SFD_SET_DATA_VALUE_PTR(0U, *c10_eta);
          _SFD_SET_DATA_VALUE_PTR(1U, *c10_R);
        }
      }
    } else {
      sf_debug_reset_current_state_configuration(sfGlobalDebugInstanceStruct,
        _HIL_model_overallMachineNumber_,chartInstance->chartNumber,
        chartInstance->instanceNumber);
    }
  }
}
コード例 #22
0
static void sf_c13_Final_Project_v3b(SFc13_Final_Project_v3bInstanceStruct
  *chartInstance)
{
  int32_T c13_i2;
  int32_T c13_i3;
  real_T c13_hoistedGlobal;
  real_T c13_b_hoistedGlobal;
  real_T c13_c_hoistedGlobal;
  real_T c13_d_hoistedGlobal;
  real_T c13_e_hoistedGlobal;
  real_T c13_f_hoistedGlobal;
  real_T c13_g_hoistedGlobal;
  real_T c13_u1;
  real_T c13_u2;
  real_T c13_u3;
  real_T c13_u4;
  real_T c13_u5;
  real_T c13_u6;
  real_T c13_collision;
  int32_T c13_i4;
  real_T c13_memory[6];
  uint32_T c13_debug_family_var_map[11];
  real_T c13_nargin = 8.0;
  real_T c13_nargout = 1.0;
  real_T c13_y[6];
  int32_T c13_i5;
  real_T *c13_b_u1;
  real_T *c13_b_u2;
  real_T *c13_b_u3;
  real_T *c13_b_u4;
  real_T *c13_b_u5;
  real_T *c13_b_u6;
  real_T *c13_b_collision;
  real_T (*c13_b_y)[6];
  real_T (*c13_b_memory)[6];
  c13_b_memory = (real_T (*)[6])ssGetInputPortSignal(chartInstance->S, 7);
  c13_b_collision = (real_T *)ssGetInputPortSignal(chartInstance->S, 6);
  c13_b_u6 = (real_T *)ssGetInputPortSignal(chartInstance->S, 5);
  c13_b_u5 = (real_T *)ssGetInputPortSignal(chartInstance->S, 4);
  c13_b_u4 = (real_T *)ssGetInputPortSignal(chartInstance->S, 3);
  c13_b_u3 = (real_T *)ssGetInputPortSignal(chartInstance->S, 2);
  c13_b_u2 = (real_T *)ssGetInputPortSignal(chartInstance->S, 1);
  c13_b_y = (real_T (*)[6])ssGetOutputPortSignal(chartInstance->S, 1);
  c13_b_u1 = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
  _sfTime_ = (real_T)ssGetT(chartInstance->S);
  _SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 12U, chartInstance->c13_sfEvent);
  _SFD_DATA_RANGE_CHECK(*c13_b_u1, 0U);
  for (c13_i2 = 0; c13_i2 < 6; c13_i2++) {
    _SFD_DATA_RANGE_CHECK((*c13_b_y)[c13_i2], 1U);
  }

  _SFD_DATA_RANGE_CHECK(*c13_b_u2, 2U);
  _SFD_DATA_RANGE_CHECK(*c13_b_u3, 3U);
  _SFD_DATA_RANGE_CHECK(*c13_b_u4, 4U);
  _SFD_DATA_RANGE_CHECK(*c13_b_u5, 5U);
  _SFD_DATA_RANGE_CHECK(*c13_b_u6, 6U);
  _SFD_DATA_RANGE_CHECK(*c13_b_collision, 7U);
  for (c13_i3 = 0; c13_i3 < 6; c13_i3++) {
    _SFD_DATA_RANGE_CHECK((*c13_b_memory)[c13_i3], 8U);
  }

  chartInstance->c13_sfEvent = CALL_EVENT;
  _SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 12U, chartInstance->c13_sfEvent);
  c13_hoistedGlobal = *c13_b_u1;
  c13_b_hoistedGlobal = *c13_b_u2;
  c13_c_hoistedGlobal = *c13_b_u3;
  c13_d_hoistedGlobal = *c13_b_u4;
  c13_e_hoistedGlobal = *c13_b_u5;
  c13_f_hoistedGlobal = *c13_b_u6;
  c13_g_hoistedGlobal = *c13_b_collision;
  c13_u1 = c13_hoistedGlobal;
  c13_u2 = c13_b_hoistedGlobal;
  c13_u3 = c13_c_hoistedGlobal;
  c13_u4 = c13_d_hoistedGlobal;
  c13_u5 = c13_e_hoistedGlobal;
  c13_u6 = c13_f_hoistedGlobal;
  c13_collision = c13_g_hoistedGlobal;
  for (c13_i4 = 0; c13_i4 < 6; c13_i4++) {
    c13_memory[c13_i4] = (*c13_b_memory)[c13_i4];
  }

  _SFD_SYMBOL_SCOPE_PUSH_EML(0U, 11U, 11U, c13_debug_family_names,
    c13_debug_family_var_map);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c13_nargin, 0U, c13_b_sf_marshallOut,
    c13_b_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c13_nargout, 1U, c13_b_sf_marshallOut,
    c13_b_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML(&c13_u1, 2U, c13_b_sf_marshallOut);
  _SFD_SYMBOL_SCOPE_ADD_EML(&c13_u2, 3U, c13_b_sf_marshallOut);
  _SFD_SYMBOL_SCOPE_ADD_EML(&c13_u3, 4U, c13_b_sf_marshallOut);
  _SFD_SYMBOL_SCOPE_ADD_EML(&c13_u4, 5U, c13_b_sf_marshallOut);
  _SFD_SYMBOL_SCOPE_ADD_EML(&c13_u5, 6U, c13_b_sf_marshallOut);
  _SFD_SYMBOL_SCOPE_ADD_EML(&c13_u6, 7U, c13_b_sf_marshallOut);
  _SFD_SYMBOL_SCOPE_ADD_EML(&c13_collision, 8U, c13_b_sf_marshallOut);
  _SFD_SYMBOL_SCOPE_ADD_EML(c13_memory, 9U, c13_sf_marshallOut);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(c13_y, 10U, c13_sf_marshallOut,
    c13_sf_marshallIn);
  CV_EML_FCN(0, 0);
  _SFD_EML_CALL(0U, chartInstance->c13_sfEvent, 5);
  if (CV_EML_IF(0, 1, 0, c13_collision == 1.0)) {
    _SFD_EML_CALL(0U, chartInstance->c13_sfEvent, 7);
    c13_y[0] = c13_u1;
    c13_y[1] = c13_u2;
    c13_y[2] = c13_u3;
    c13_y[3] = c13_u4;
    c13_y[4] = c13_u5;
    c13_y[5] = c13_u6;
  } else {
    _SFD_EML_CALL(0U, chartInstance->c13_sfEvent, 11);
    c13_y[0] = c13_u1;
    c13_y[1] = c13_u2;
    c13_y[2] = c13_u3;
    c13_y[3] = c13_memory[3];
    c13_y[4] = c13_memory[4];
    c13_y[5] = c13_memory[5];
  }

  _SFD_EML_CALL(0U, chartInstance->c13_sfEvent, -11);
  _SFD_SYMBOL_SCOPE_POP();
  for (c13_i5 = 0; c13_i5 < 6; c13_i5++) {
    (*c13_b_y)[c13_i5] = c13_y[c13_i5];
  }

  _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 12U, chartInstance->c13_sfEvent);
  _SFD_CHECK_FOR_STATE_INCONSISTENCY(_Final_Project_v3bMachineNumber_,
    chartInstance->chartNumber, chartInstance->instanceNumber);
}
コード例 #23
0
static void chart_debug_initialization(SimStruct *S, unsigned int
  fullDebuggerInitialization)
{
  if (!sim_mode_is_rtw_gen(S)) {
    if (ssIsFirstInitCond(S) && fullDebuggerInitialization==1) {
      /* do this only if simulation is starting */
      {
        unsigned int chartAlreadyPresent;
        chartAlreadyPresent = sf_debug_initialize_chart
          (_adcs_v15_integral_PowerMachineNumber_,
           30,
           1,
           1,
           5,
           0,
           0,
           0,
           0,
           0,
           &(chartInstance.chartNumber),
           &(chartInstance.instanceNumber),
           ssGetPath(S),
           (void *)S);
        if (chartAlreadyPresent==0) {
          /* this is the first instance */
          init_script_number_translation(_adcs_v15_integral_PowerMachineNumber_,
            chartInstance.chartNumber);
          sf_debug_set_chart_disable_implicit_casting
            (_adcs_v15_integral_PowerMachineNumber_,chartInstance.chartNumber,1);
          sf_debug_set_chart_event_thresholds
            (_adcs_v15_integral_PowerMachineNumber_,
             chartInstance.chartNumber,
             0,
             0,
             0);
          _SFD_SET_DATA_PROPS(0,10,0,0,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,"today",
                              0,(MexFcnForType)c30_b_sf_marshall);

          {
            unsigned int dimVector[1];
            dimVector[0]= 3;
            _SFD_SET_DATA_PROPS(1,2,0,1,SF_DOUBLE,1,&(dimVector[0]),0,0,0,0.0,
                                1.0,0,"r_ECEF",0,(MexFcnForType)c30_sf_marshall);
          }

          _SFD_SET_DATA_PROPS(2,10,0,0,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,
                              "equinox",0,(MexFcnForType)c30_b_sf_marshall);

          {
            unsigned int dimVector[1];
            dimVector[0]= 3;
            _SFD_SET_DATA_PROPS(3,1,1,0,SF_DOUBLE,1,&(dimVector[0]),0,0,0,0.0,
                                1.0,0,"r_I",0,(MexFcnForType)c30_sf_marshall);
          }

          _SFD_SET_DATA_PROPS(4,1,1,0,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,"t",0,
                              (MexFcnForType)c30_b_sf_marshall);
          _SFD_STATE_INFO(0,0,2);
          _SFD_CH_SUBSTATE_COUNT(0);
          _SFD_CH_SUBSTATE_DECOMP(0);
        }

        _SFD_CV_INIT_CHART(0,0,0,0);

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

        _SFD_CV_INIT_TRANS(0,0,NULL,NULL,0,NULL);

        /* Initialization of EML Model Coverage */
        _SFD_CV_INIT_EML(0,1,0,0,0,0,0,0);
        _SFD_CV_INIT_EML_FCN(0,0,"eML_blk_kernel",0,-1,568);
        _SFD_TRANS_COV_WTS(0,0,0,1,0);
        if (chartAlreadyPresent==0) {
          _SFD_TRANS_COV_MAPS(0,
                              0,NULL,NULL,
                              0,NULL,NULL,
                              1,NULL,NULL,
                              0,NULL,NULL);
        }

        {
          real_T (*c30_r_ECEF)[3];
          real_T (*c30_r_I)[3];
          real_T *c30_t;
          c30_r_ECEF = (real_T (*)[3])ssGetOutputPortSignal(chartInstance.S, 1);
          c30_t = (real_T *)ssGetInputPortSignal(chartInstance.S, 1);
          c30_r_I = (real_T (*)[3])ssGetInputPortSignal(chartInstance.S, 0);
          _SFD_SET_DATA_VALUE_PTR(0U, &chartInstance.c30_today);
          _SFD_SET_DATA_VALUE_PTR(1U, c30_r_ECEF);
          _SFD_SET_DATA_VALUE_PTR(2U, &chartInstance.c30_equinox);
          _SFD_SET_DATA_VALUE_PTR(3U, c30_r_I);
          _SFD_SET_DATA_VALUE_PTR(4U, c30_t);
        }
      }
    } else {
      sf_debug_reset_current_state_configuration
        (_adcs_v15_integral_PowerMachineNumber_,chartInstance.chartNumber,
         chartInstance.instanceNumber);
    }
  }
}
コード例 #24
0
static void chart_debug_initialization(SimStruct *S, unsigned int
  fullDebuggerInitialization)
{
  if (!sim_mode_is_rtw_gen(S)) {
    SFc13_Final_Project_v3bInstanceStruct *chartInstance;
    chartInstance = (SFc13_Final_Project_v3bInstanceStruct *) ((ChartInfoStruct *)
      (ssGetUserData(S)))->chartInstance;
    if (ssIsFirstInitCond(S) && fullDebuggerInitialization==1) {
      /* do this only if simulation is starting */
      {
        unsigned int chartAlreadyPresent;
        chartAlreadyPresent = sf_debug_initialize_chart
          (sfGlobalDebugInstanceStruct,
           _Final_Project_v3bMachineNumber_,
           13,
           1,
           1,
           9,
           0,
           0,
           0,
           0,
           0,
           &(chartInstance->chartNumber),
           &(chartInstance->instanceNumber),
           ssGetPath(S),
           (void *)S);
        if (chartAlreadyPresent==0) {
          /* this is the first instance */
          init_script_number_translation(_Final_Project_v3bMachineNumber_,
            chartInstance->chartNumber);
          sf_debug_set_chart_disable_implicit_casting
            (sfGlobalDebugInstanceStruct,_Final_Project_v3bMachineNumber_,
             chartInstance->chartNumber,1);
          sf_debug_set_chart_event_thresholds(sfGlobalDebugInstanceStruct,
            _Final_Project_v3bMachineNumber_,
            chartInstance->chartNumber,
            0,
            0,
            0);
          _SFD_SET_DATA_PROPS(0,1,1,0,"u1");
          _SFD_SET_DATA_PROPS(1,2,0,1,"y");
          _SFD_SET_DATA_PROPS(2,1,1,0,"u2");
          _SFD_SET_DATA_PROPS(3,1,1,0,"u3");
          _SFD_SET_DATA_PROPS(4,1,1,0,"u4");
          _SFD_SET_DATA_PROPS(5,1,1,0,"u5");
          _SFD_SET_DATA_PROPS(6,1,1,0,"u6");
          _SFD_SET_DATA_PROPS(7,1,1,0,"collision");
          _SFD_SET_DATA_PROPS(8,1,1,0,"memory");
          _SFD_STATE_INFO(0,0,2);
          _SFD_CH_SUBSTATE_COUNT(0);
          _SFD_CH_SUBSTATE_DECOMP(0);
        }

        _SFD_CV_INIT_CHART(0,0,0,0);

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

        _SFD_CV_INIT_TRANS(0,0,NULL,NULL,0,NULL);

        /* Initialization of MATLAB Function Model Coverage */
        _SFD_CV_INIT_EML(0,1,1,1,0,0,0,0,0,0,0);
        _SFD_CV_INIT_EML_FCN(0,0,"eML_blk_kernel",0,-1,165);
        _SFD_CV_INIT_EML_IF(0,1,0,66,81,107,165);
        _SFD_TRANS_COV_WTS(0,0,0,1,0);
        if (chartAlreadyPresent==0) {
          _SFD_TRANS_COV_MAPS(0,
                              0,NULL,NULL,
                              0,NULL,NULL,
                              1,NULL,NULL,
                              0,NULL,NULL);
        }

        _SFD_SET_DATA_COMPILED_PROPS(0,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,
          (MexFcnForType)c13_b_sf_marshallOut,(MexInFcnForType)NULL);

        {
          unsigned int dimVector[1];
          dimVector[0]= 6;
          _SFD_SET_DATA_COMPILED_PROPS(1,SF_DOUBLE,1,&(dimVector[0]),0,0,0,0.0,
            1.0,0,0,(MexFcnForType)c13_sf_marshallOut,(MexInFcnForType)
            c13_sf_marshallIn);
        }

        _SFD_SET_DATA_COMPILED_PROPS(2,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,
          (MexFcnForType)c13_b_sf_marshallOut,(MexInFcnForType)NULL);
        _SFD_SET_DATA_COMPILED_PROPS(3,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,
          (MexFcnForType)c13_b_sf_marshallOut,(MexInFcnForType)NULL);
        _SFD_SET_DATA_COMPILED_PROPS(4,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,
          (MexFcnForType)c13_b_sf_marshallOut,(MexInFcnForType)NULL);
        _SFD_SET_DATA_COMPILED_PROPS(5,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,
          (MexFcnForType)c13_b_sf_marshallOut,(MexInFcnForType)NULL);
        _SFD_SET_DATA_COMPILED_PROPS(6,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,
          (MexFcnForType)c13_b_sf_marshallOut,(MexInFcnForType)NULL);
        _SFD_SET_DATA_COMPILED_PROPS(7,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,
          (MexFcnForType)c13_b_sf_marshallOut,(MexInFcnForType)NULL);

        {
          unsigned int dimVector[1];
          dimVector[0]= 6;
          _SFD_SET_DATA_COMPILED_PROPS(8,SF_DOUBLE,1,&(dimVector[0]),0,0,0,0.0,
            1.0,0,0,(MexFcnForType)c13_sf_marshallOut,(MexInFcnForType)NULL);
        }

        {
          real_T *c13_u1;
          real_T *c13_u2;
          real_T *c13_u3;
          real_T *c13_u4;
          real_T *c13_u5;
          real_T *c13_u6;
          real_T *c13_collision;
          real_T (*c13_y)[6];
          real_T (*c13_memory)[6];
          c13_memory = (real_T (*)[6])ssGetInputPortSignal(chartInstance->S, 7);
          c13_collision = (real_T *)ssGetInputPortSignal(chartInstance->S, 6);
          c13_u6 = (real_T *)ssGetInputPortSignal(chartInstance->S, 5);
          c13_u5 = (real_T *)ssGetInputPortSignal(chartInstance->S, 4);
          c13_u4 = (real_T *)ssGetInputPortSignal(chartInstance->S, 3);
          c13_u3 = (real_T *)ssGetInputPortSignal(chartInstance->S, 2);
          c13_u2 = (real_T *)ssGetInputPortSignal(chartInstance->S, 1);
          c13_y = (real_T (*)[6])ssGetOutputPortSignal(chartInstance->S, 1);
          c13_u1 = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
          _SFD_SET_DATA_VALUE_PTR(0U, c13_u1);
          _SFD_SET_DATA_VALUE_PTR(1U, *c13_y);
          _SFD_SET_DATA_VALUE_PTR(2U, c13_u2);
          _SFD_SET_DATA_VALUE_PTR(3U, c13_u3);
          _SFD_SET_DATA_VALUE_PTR(4U, c13_u4);
          _SFD_SET_DATA_VALUE_PTR(5U, c13_u5);
          _SFD_SET_DATA_VALUE_PTR(6U, c13_u6);
          _SFD_SET_DATA_VALUE_PTR(7U, c13_collision);
          _SFD_SET_DATA_VALUE_PTR(8U, *c13_memory);
        }
      }
    } else {
      sf_debug_reset_current_state_configuration(sfGlobalDebugInstanceStruct,
        _Final_Project_v3bMachineNumber_,chartInstance->chartNumber,
        chartInstance->instanceNumber);
    }
  }
}
コード例 #25
0
static void sf_gateway_c3_ARP_02_RPSsmile_WirelessGlove
  (SFc3_ARP_02_RPSsmile_WirelessGloveInstanceStruct *chartInstance)
{
  real_T c3_hoistedGlobal;
  real_T c3_u;
  uint32_T c3_debug_family_var_map[4];
  real_T c3_nargin = 1.0;
  real_T c3_nargout = 1.0;
  real_T c3_y;
  real_T *c3_b_u;
  real_T *c3_b_y;
  c3_b_y = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
  c3_b_u = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
  _SFD_SYMBOL_SCOPE_PUSH(0U, 0U);
  _sfTime_ = sf_get_time(chartInstance->S);
  _SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 2U, chartInstance->c3_sfEvent);
  _SFD_DATA_RANGE_CHECK(*c3_b_u, 0U);
  chartInstance->c3_sfEvent = CALL_EVENT;
  _SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 2U, chartInstance->c3_sfEvent);
  c3_hoistedGlobal = *c3_b_u;
  c3_u = c3_hoistedGlobal;
  _SFD_SYMBOL_SCOPE_PUSH_EML(0U, 4U, 4U, c3_debug_family_names,
    c3_debug_family_var_map);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c3_nargin, 0U, c3_sf_marshallOut,
    c3_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c3_nargout, 1U, c3_sf_marshallOut,
    c3_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML(&c3_u, 2U, c3_sf_marshallOut);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c3_y, 3U, c3_sf_marshallOut,
    c3_sf_marshallIn);
  CV_EML_FCN(0, 0);
  _SFD_EML_CALL(0U, chartInstance->c3_sfEvent, 6);
  if (CV_EML_IF(0, 1, 0, c3_u == 0.0)) {
    _SFD_EML_CALL(0U, chartInstance->c3_sfEvent, 7);
    c3_u = 1.0;
  } else {
    _SFD_EML_CALL(0U, chartInstance->c3_sfEvent, 8);
    if (CV_EML_IF(0, 1, 1, c3_u == 1.0)) {
      _SFD_EML_CALL(0U, chartInstance->c3_sfEvent, 9);
      c3_u = 0.0;
    } else {
      _SFD_EML_CALL(0U, chartInstance->c3_sfEvent, 10);
      if (CV_EML_IF(0, 1, 2, c3_u == 3.0)) {
        _SFD_EML_CALL(0U, chartInstance->c3_sfEvent, 11);
        c3_u = 2.0;
      } else {
        _SFD_EML_CALL(0U, chartInstance->c3_sfEvent, 13);
        c3_u = 3.0;
      }
    }
  }

  _SFD_EML_CALL(0U, chartInstance->c3_sfEvent, 15);
  c3_y = c3_u;
  _SFD_EML_CALL(0U, chartInstance->c3_sfEvent, -15);
  _SFD_SYMBOL_SCOPE_POP();
  *c3_b_y = c3_y;
  _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 2U, chartInstance->c3_sfEvent);
  _SFD_SYMBOL_SCOPE_POP();
  _SFD_CHECK_FOR_STATE_INCONSISTENCY
    (_ARP_02_RPSsmile_WirelessGloveMachineNumber_, chartInstance->chartNumber,
     chartInstance->instanceNumber);
  _SFD_DATA_RANGE_CHECK(*c3_b_y, 1U);
}
コード例 #26
0
ファイル: c45_Expriment_All.c プロジェクト: maryamsab/realact
static void sf_gateway_c45_Expriment_All(SFc45_Expriment_AllInstanceStruct
  *chartInstance)
{
  real_T c45_hoistedGlobal;
  real_T c45_b_hoistedGlobal;
  real_T c45_c_hoistedGlobal;
  real_T c45_d_hoistedGlobal;
  real_T c45_e_hoistedGlobal;
  real_T c45_f_hoistedGlobal;
  real_T c45_r1;
  real_T c45_r2;
  real_T c45_r3;
  real_T c45_r4;
  real_T c45_r5;
  real_T c45_r6;
  uint32_T c45_debug_family_var_map[9];
  real_T c45_nargin = 6.0;
  real_T c45_nargout = 1.0;
  real_T c45_y[6];
  int32_T c45_i2;
  real_T c45_x;
  real_T c45_b_x;
  real_T c45_c_x;
  real_T c45_d_x;
  real_T c45_e_x;
  real_T c45_f_x;
  real_T c45_g_x;
  real_T c45_h_x;
  real_T c45_i_x;
  real_T c45_j_x;
  real_T c45_k_x;
  real_T c45_l_x;
  int32_T c45_i3;
  int32_T c45_i4;
  real_T *c45_b_r1;
  real_T *c45_b_r2;
  real_T *c45_b_r3;
  real_T *c45_b_r4;
  real_T *c45_b_r5;
  real_T *c45_b_r6;
  real_T (*c45_b_y)[6];
  c45_b_r6 = (real_T *)ssGetInputPortSignal(chartInstance->S, 5);
  c45_b_r5 = (real_T *)ssGetInputPortSignal(chartInstance->S, 4);
  c45_b_r4 = (real_T *)ssGetInputPortSignal(chartInstance->S, 3);
  c45_b_r3 = (real_T *)ssGetInputPortSignal(chartInstance->S, 2);
  c45_b_r2 = (real_T *)ssGetInputPortSignal(chartInstance->S, 1);
  c45_b_y = (real_T (*)[6])ssGetOutputPortSignal(chartInstance->S, 1);
  c45_b_r1 = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
  _SFD_SYMBOL_SCOPE_PUSH(0U, 0U);
  _sfTime_ = sf_get_time(chartInstance->S);
  _SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 25U, chartInstance->c45_sfEvent);
  _SFD_DATA_RANGE_CHECK(*c45_b_r1, 0U);
  chartInstance->c45_sfEvent = CALL_EVENT;
  _SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 25U, chartInstance->c45_sfEvent);
  c45_hoistedGlobal = *c45_b_r1;
  c45_b_hoistedGlobal = *c45_b_r2;
  c45_c_hoistedGlobal = *c45_b_r3;
  c45_d_hoistedGlobal = *c45_b_r4;
  c45_e_hoistedGlobal = *c45_b_r5;
  c45_f_hoistedGlobal = *c45_b_r6;
  c45_r1 = c45_hoistedGlobal;
  c45_r2 = c45_b_hoistedGlobal;
  c45_r3 = c45_c_hoistedGlobal;
  c45_r4 = c45_d_hoistedGlobal;
  c45_r5 = c45_e_hoistedGlobal;
  c45_r6 = c45_f_hoistedGlobal;
  _SFD_SYMBOL_SCOPE_PUSH_EML(0U, 9U, 9U, c45_debug_family_names,
    c45_debug_family_var_map);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c45_nargin, 0U, c45_b_sf_marshallOut,
    c45_b_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c45_nargout, 1U, c45_b_sf_marshallOut,
    c45_b_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML(&c45_r1, 2U, c45_b_sf_marshallOut);
  _SFD_SYMBOL_SCOPE_ADD_EML(&c45_r2, 3U, c45_b_sf_marshallOut);
  _SFD_SYMBOL_SCOPE_ADD_EML(&c45_r3, 4U, c45_b_sf_marshallOut);
  _SFD_SYMBOL_SCOPE_ADD_EML(&c45_r4, 5U, c45_b_sf_marshallOut);
  _SFD_SYMBOL_SCOPE_ADD_EML(&c45_r5, 6U, c45_b_sf_marshallOut);
  _SFD_SYMBOL_SCOPE_ADD_EML(&c45_r6, 7U, c45_b_sf_marshallOut);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(c45_y, 8U, c45_sf_marshallOut,
    c45_sf_marshallIn);
  CV_EML_FCN(0, 0);
  _SFD_EML_CALL(0U, chartInstance->c45_sfEvent, 3);
  for (c45_i2 = 0; c45_i2 < 6; c45_i2++) {
    c45_y[c45_i2] = 0.0;
  }

  _SFD_EML_CALL(0U, chartInstance->c45_sfEvent, 4);
  c45_x = c45_r1;
  c45_b_x = c45_x;
  c45_b_x = muDoubleScalarFloor(c45_b_x);
  c45_y[0] = c45_b_x;
  _SFD_EML_CALL(0U, chartInstance->c45_sfEvent, 5);
  c45_c_x = c45_r2;
  c45_d_x = c45_c_x;
  c45_d_x = muDoubleScalarFloor(c45_d_x);
  c45_y[1] = c45_d_x;
  _SFD_EML_CALL(0U, chartInstance->c45_sfEvent, 6);
  c45_e_x = c45_r3;
  c45_f_x = c45_e_x;
  c45_f_x = muDoubleScalarFloor(c45_f_x);
  c45_y[2] = c45_f_x;
  _SFD_EML_CALL(0U, chartInstance->c45_sfEvent, 7);
  c45_g_x = c45_r4;
  c45_h_x = c45_g_x;
  c45_h_x = muDoubleScalarFloor(c45_h_x);
  c45_y[3] = c45_h_x;
  _SFD_EML_CALL(0U, chartInstance->c45_sfEvent, 8);
  c45_i_x = c45_r5;
  c45_j_x = c45_i_x;
  c45_j_x = muDoubleScalarFloor(c45_j_x);
  c45_y[4] = c45_j_x;
  _SFD_EML_CALL(0U, chartInstance->c45_sfEvent, 9);
  c45_k_x = c45_r6;
  c45_l_x = c45_k_x;
  c45_l_x = muDoubleScalarFloor(c45_l_x);
  c45_y[5] = c45_l_x;
  _SFD_EML_CALL(0U, chartInstance->c45_sfEvent, -9);
  _SFD_SYMBOL_SCOPE_POP();
  for (c45_i3 = 0; c45_i3 < 6; c45_i3++) {
    (*c45_b_y)[c45_i3] = c45_y[c45_i3];
  }

  _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 25U, chartInstance->c45_sfEvent);
  _SFD_SYMBOL_SCOPE_POP();
  _SFD_CHECK_FOR_STATE_INCONSISTENCY(_Expriment_AllMachineNumber_,
    chartInstance->chartNumber, chartInstance->instanceNumber);
  for (c45_i4 = 0; c45_i4 < 6; c45_i4++) {
    _SFD_DATA_RANGE_CHECK((*c45_b_y)[c45_i4], 1U);
  }

  _SFD_DATA_RANGE_CHECK(*c45_b_r2, 2U);
  _SFD_DATA_RANGE_CHECK(*c45_b_r3, 3U);
  _SFD_DATA_RANGE_CHECK(*c45_b_r4, 4U);
  _SFD_DATA_RANGE_CHECK(*c45_b_r5, 5U);
  _SFD_DATA_RANGE_CHECK(*c45_b_r6, 6U);
}
コード例 #27
0
static void c38_chartstep_c38_Expriment_FacialExpr
  (SFc38_Expriment_FacialExprInstanceStruct *chartInstance)
{
  real_T c38_hoistedGlobal;
  real_T c38_b_hoistedGlobal;
  real_T c38_V;
  real_T c38_A;
  uint32_T c38_debug_family_var_map[13];
  boolean_T c38_aVarTruthTableCondition_1;
  boolean_T c38_aVarTruthTableCondition_2;
  boolean_T c38_aVarTruthTableCondition_3;
  boolean_T c38_aVarTruthTableCondition_4;
  boolean_T c38_aVarTruthTableCondition_5;
  boolean_T c38_aVarTruthTableCondition_6;
  boolean_T c38_aVarTruthTableCondition_7;
  boolean_T c38_aVarTruthTableCondition_8;
  real_T c38_nargin = 2.0;
  real_T c38_nargout = 1.0;
  real_T c38_e;
  boolean_T c38_b0;
  boolean_T c38_b1;
  boolean_T c38_b2;
  boolean_T c38_b3;
  boolean_T c38_b4;
  boolean_T c38_b5;
  boolean_T c38_b6;
  boolean_T c38_b7;
  real_T *c38_b_e;
  real_T *c38_b_V;
  real_T *c38_b_A;
  boolean_T guard1 = false;
  boolean_T guard2 = false;
  boolean_T guard3 = false;
  boolean_T guard4 = false;
  boolean_T guard5 = false;
  boolean_T guard6 = false;
  boolean_T guard7 = false;
  boolean_T guard8 = false;
  boolean_T guard9 = false;
  boolean_T guard10 = false;
  boolean_T guard11 = false;
  boolean_T guard12 = false;
  c38_b_A = (real_T *)ssGetInputPortSignal(chartInstance->S, 1);
  c38_b_e = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
  c38_b_V = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
  _SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 18U, chartInstance->c38_sfEvent);
  c38_hoistedGlobal = *c38_b_V;
  c38_b_hoistedGlobal = *c38_b_A;
  c38_V = c38_hoistedGlobal;
  c38_A = c38_b_hoistedGlobal;
  _SFD_SYMBOL_SCOPE_PUSH_EML(0U, 13U, 13U, c38_debug_family_names,
    c38_debug_family_var_map);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c38_aVarTruthTableCondition_1, 0U,
    c38_b_sf_marshallOut, c38_b_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c38_aVarTruthTableCondition_2, 1U,
    c38_b_sf_marshallOut, c38_b_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c38_aVarTruthTableCondition_3, 2U,
    c38_b_sf_marshallOut, c38_b_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c38_aVarTruthTableCondition_4, 3U,
    c38_b_sf_marshallOut, c38_b_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c38_aVarTruthTableCondition_5, 4U,
    c38_b_sf_marshallOut, c38_b_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c38_aVarTruthTableCondition_6, 5U,
    c38_b_sf_marshallOut, c38_b_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c38_aVarTruthTableCondition_7, 6U,
    c38_b_sf_marshallOut, c38_b_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c38_aVarTruthTableCondition_8, 7U,
    c38_b_sf_marshallOut, c38_b_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c38_nargin, 8U, c38_sf_marshallOut,
    c38_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c38_nargout, 9U, c38_sf_marshallOut,
    c38_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML(&c38_V, 10U, c38_sf_marshallOut);
  _SFD_SYMBOL_SCOPE_ADD_EML(&c38_A, 11U, c38_sf_marshallOut);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c38_e, 12U, c38_sf_marshallOut,
    c38_sf_marshallIn);
  CV_EML_FCN(0, 0);
  _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 3);
  c38_aVarTruthTableCondition_1 = false;
  _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 4);
  c38_aVarTruthTableCondition_2 = false;
  _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 5);
  c38_aVarTruthTableCondition_3 = false;
  _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 6);
  c38_aVarTruthTableCondition_4 = false;
  _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 7);
  c38_aVarTruthTableCondition_5 = false;
  _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 8);
  c38_aVarTruthTableCondition_6 = false;
  _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 9);
  c38_aVarTruthTableCondition_7 = false;
  _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 10);
  c38_aVarTruthTableCondition_8 = false;
  _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 15);
  guard11 = false;
  guard12 = false;
  if (c38_V > 10.0) {
    if (c38_A < 40.0) {
      if (c38_A > 10.0) {
        c38_b0 = true;
      } else {
        guard11 = true;
      }
    } else {
      guard12 = true;
    }
  } else {
    guard12 = true;
  }

  if (guard12 == true) {
    guard11 = true;
  }

  if (guard11 == true) {
    c38_b0 = false;
  }

  c38_aVarTruthTableCondition_1 = c38_b0;
  _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 19);
  guard10 = false;
  if (c38_V > 0.0) {
    if (c38_A > 40.0) {
      c38_b1 = true;
    } else {
      guard10 = true;
    }
  } else {
    guard10 = true;
  }

  if (guard10 == true) {
    c38_b1 = false;
  }

  c38_aVarTruthTableCondition_2 = c38_b1;
  _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 23);
  guard9 = false;
  if (c38_V < 0.0) {
    if (c38_A > 40.0) {
      c38_b2 = true;
    } else {
      guard9 = true;
    }
  } else {
    guard9 = true;
  }

  if (guard9 == true) {
    c38_b2 = false;
  }

  c38_aVarTruthTableCondition_3 = c38_b2;
  _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 27);
  guard7 = false;
  guard8 = false;
  if (c38_V < -10.0) {
    if (c38_A < 40.0) {
      if (c38_A > 10.0) {
        c38_b3 = true;
      } else {
        guard7 = true;
      }
    } else {
      guard8 = true;
    }
  } else {
    guard8 = true;
  }

  if (guard8 == true) {
    guard7 = true;
  }

  if (guard7 == true) {
    c38_b3 = false;
  }

  c38_aVarTruthTableCondition_4 = c38_b3;
  _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 31);
  guard5 = false;
  guard6 = false;
  if (c38_V > 10.0) {
    if (c38_A < -10.0) {
      if (c38_A > -40.0) {
        c38_b4 = true;
      } else {
        guard5 = true;
      }
    } else {
      guard6 = true;
    }
  } else {
    guard6 = true;
  }

  if (guard6 == true) {
    guard5 = true;
  }

  if (guard5 == true) {
    c38_b4 = false;
  }

  c38_aVarTruthTableCondition_5 = c38_b4;
  _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 35);
  guard4 = false;
  if (c38_V > 0.0) {
    if (c38_A < -40.0) {
      c38_b5 = true;
    } else {
      guard4 = true;
    }
  } else {
    guard4 = true;
  }

  if (guard4 == true) {
    c38_b5 = false;
  }

  c38_aVarTruthTableCondition_6 = c38_b5;
  _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 39);
  guard3 = false;
  if (c38_V < 0.0) {
    if (c38_A < -40.0) {
      c38_b6 = true;
    } else {
      guard3 = true;
    }
  } else {
    guard3 = true;
  }

  if (guard3 == true) {
    c38_b6 = false;
  }

  c38_aVarTruthTableCondition_7 = c38_b6;
  _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 43);
  guard1 = false;
  guard2 = false;
  if (c38_V < -10.0) {
    if (c38_A < -10.0) {
      if (c38_A > -40.0) {
        c38_b7 = true;
      } else {
        guard1 = true;
      }
    } else {
      guard2 = true;
    }
  } else {
    guard2 = true;
  }

  if (guard2 == true) {
    guard1 = true;
  }

  if (guard1 == true) {
    c38_b7 = false;
  }

  c38_aVarTruthTableCondition_8 = c38_b7;
  _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 45);
  if (CV_EML_IF(0, 1, 0, c38_aVarTruthTableCondition_1)) {
    _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 46);
    CV_EML_FCN(0, 1);
    _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 69);
    c38_e = 7.0;
    _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, -69);
  } else {
    _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 47);
    if (CV_EML_IF(0, 1, 1, c38_aVarTruthTableCondition_2)) {
      _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 48);
      CV_EML_FCN(0, 2);
      _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 75);
      c38_e = 8.0;
      _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, -75);
    } else {
      _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 49);
      if (CV_EML_IF(0, 1, 2, c38_aVarTruthTableCondition_3)) {
        _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 50);
        CV_EML_FCN(0, 3);
        _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 81);
        c38_e = 4.0;
        _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, -81);
      } else {
        _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 51);
        if (CV_EML_IF(0, 1, 3, c38_aVarTruthTableCondition_4)) {
          _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 52);
          CV_EML_FCN(0, 4);
          _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 87);
          c38_e = 3.0;
          _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, -87);
        } else {
          _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 53);
          if (CV_EML_IF(0, 1, 4, c38_aVarTruthTableCondition_5)) {
            _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 54);
            CV_EML_FCN(0, 5);
            _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 93);
            c38_e = 6.0;
            _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, -93);
          } else {
            _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 55);
            if (CV_EML_IF(0, 1, 5, c38_aVarTruthTableCondition_6)) {
              _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 56);
              CV_EML_FCN(0, 6);
              _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 99);
              c38_e = 5.0;
              _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, -99);
            } else {
              _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 57);
              if (CV_EML_IF(0, 1, 6, c38_aVarTruthTableCondition_7)) {
                _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 58);
                CV_EML_FCN(0, 7);
                _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 105);
                c38_e = 1.0;
                _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, -105);
              } else {
                _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 59);
                if (CV_EML_IF(0, 1, 7, c38_aVarTruthTableCondition_8)) {
                  _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 60);
                  CV_EML_FCN(0, 8);
                  _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 111);
                  c38_e = 2.0;
                  _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, -111);
                } else {
                  _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 62);
                  CV_EML_FCN(0, 5);
                  _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, 93);
                  c38_e = 6.0;
                  _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, -93);
                }
              }
            }
          }
        }
      }
    }
  }

  _SFD_EML_CALL(0U, chartInstance->c38_sfEvent, -62);
  _SFD_SYMBOL_SCOPE_POP();
  *c38_b_e = c38_e;
  _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 18U, chartInstance->c38_sfEvent);
}
コード例 #28
0
ファイル: c45_Expriment_All.c プロジェクト: maryamsab/realact
static void chart_debug_initialization(SimStruct *S, unsigned int
  fullDebuggerInitialization)
{
  if (!sim_mode_is_rtw_gen(S)) {
    SFc45_Expriment_AllInstanceStruct *chartInstance;
    ChartRunTimeInfo * crtInfo = (ChartRunTimeInfo *)(ssGetUserData(S));
    ChartInfoStruct * chartInfo = (ChartInfoStruct *)(crtInfo->instanceInfo);
    chartInstance = (SFc45_Expriment_AllInstanceStruct *)
      chartInfo->chartInstance;
    if (ssIsFirstInitCond(S) && fullDebuggerInitialization==1) {
      /* do this only if simulation is starting */
      {
        unsigned int chartAlreadyPresent;
        chartAlreadyPresent = sf_debug_initialize_chart
          (sfGlobalDebugInstanceStruct,
           _Expriment_AllMachineNumber_,
           45,
           1,
           1,
           0,
           7,
           0,
           0,
           0,
           0,
           0,
           &(chartInstance->chartNumber),
           &(chartInstance->instanceNumber),
           (void *)S);

        /* Each instance must initialize ist own list of scripts */
        init_script_number_translation(_Expriment_AllMachineNumber_,
          chartInstance->chartNumber,chartInstance->instanceNumber);
        if (chartAlreadyPresent==0) {
          /* this is the first instance */
          sf_debug_set_chart_disable_implicit_casting
            (sfGlobalDebugInstanceStruct,_Expriment_AllMachineNumber_,
             chartInstance->chartNumber,1);
          sf_debug_set_chart_event_thresholds(sfGlobalDebugInstanceStruct,
            _Expriment_AllMachineNumber_,
            chartInstance->chartNumber,
            0,
            0,
            0);
          _SFD_SET_DATA_PROPS(0,1,1,0,"r1");
          _SFD_SET_DATA_PROPS(1,2,0,1,"y");
          _SFD_SET_DATA_PROPS(2,1,1,0,"r2");
          _SFD_SET_DATA_PROPS(3,1,1,0,"r3");
          _SFD_SET_DATA_PROPS(4,1,1,0,"r4");
          _SFD_SET_DATA_PROPS(5,1,1,0,"r5");
          _SFD_SET_DATA_PROPS(6,1,1,0,"r6");
          _SFD_STATE_INFO(0,0,2);
          _SFD_CH_SUBSTATE_COUNT(0);
          _SFD_CH_SUBSTATE_DECOMP(0);
        }

        _SFD_CV_INIT_CHART(0,0,0,0);

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

        _SFD_CV_INIT_TRANS(0,0,NULL,NULL,0,NULL);

        /* Initialization of MATLAB Function Model Coverage */
        _SFD_CV_INIT_EML(0,1,1,0,0,0,0,0,0,0,0);
        _SFD_CV_INIT_EML_FCN(0,0,"eML_blk_kernel",0,-1,184);
        _SFD_SET_DATA_COMPILED_PROPS(0,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,
          (MexFcnForType)c45_b_sf_marshallOut,(MexInFcnForType)NULL);

        {
          unsigned int dimVector[2];
          dimVector[0]= 1;
          dimVector[1]= 6;
          _SFD_SET_DATA_COMPILED_PROPS(1,SF_DOUBLE,2,&(dimVector[0]),0,0,0,0.0,
            1.0,0,0,(MexFcnForType)c45_sf_marshallOut,(MexInFcnForType)
            c45_sf_marshallIn);
        }

        _SFD_SET_DATA_COMPILED_PROPS(2,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,
          (MexFcnForType)c45_b_sf_marshallOut,(MexInFcnForType)NULL);
        _SFD_SET_DATA_COMPILED_PROPS(3,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,
          (MexFcnForType)c45_b_sf_marshallOut,(MexInFcnForType)NULL);
        _SFD_SET_DATA_COMPILED_PROPS(4,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,
          (MexFcnForType)c45_b_sf_marshallOut,(MexInFcnForType)NULL);
        _SFD_SET_DATA_COMPILED_PROPS(5,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,
          (MexFcnForType)c45_b_sf_marshallOut,(MexInFcnForType)NULL);
        _SFD_SET_DATA_COMPILED_PROPS(6,SF_DOUBLE,0,NULL,0,0,0,0.0,1.0,0,0,
          (MexFcnForType)c45_b_sf_marshallOut,(MexInFcnForType)NULL);

        {
          real_T *c45_r1;
          real_T *c45_r2;
          real_T *c45_r3;
          real_T *c45_r4;
          real_T *c45_r5;
          real_T *c45_r6;
          real_T (*c45_y)[6];
          c45_r6 = (real_T *)ssGetInputPortSignal(chartInstance->S, 5);
          c45_r5 = (real_T *)ssGetInputPortSignal(chartInstance->S, 4);
          c45_r4 = (real_T *)ssGetInputPortSignal(chartInstance->S, 3);
          c45_r3 = (real_T *)ssGetInputPortSignal(chartInstance->S, 2);
          c45_r2 = (real_T *)ssGetInputPortSignal(chartInstance->S, 1);
          c45_y = (real_T (*)[6])ssGetOutputPortSignal(chartInstance->S, 1);
          c45_r1 = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
          _SFD_SET_DATA_VALUE_PTR(0U, c45_r1);
          _SFD_SET_DATA_VALUE_PTR(1U, *c45_y);
          _SFD_SET_DATA_VALUE_PTR(2U, c45_r2);
          _SFD_SET_DATA_VALUE_PTR(3U, c45_r3);
          _SFD_SET_DATA_VALUE_PTR(4U, c45_r4);
          _SFD_SET_DATA_VALUE_PTR(5U, c45_r5);
          _SFD_SET_DATA_VALUE_PTR(6U, c45_r6);
        }
      }
    } else {
      sf_debug_reset_current_state_configuration(sfGlobalDebugInstanceStruct,
        _Expriment_AllMachineNumber_,chartInstance->chartNumber,
        chartInstance->instanceNumber);
    }
  }
}
コード例 #29
0
ファイル: c55_Expriment_All.c プロジェクト: maryamsab/realact
static void sf_gateway_c55_Expriment_All(SFc55_Expriment_AllInstanceStruct
  *chartInstance)
{
  real_T c55_hoistedGlobal;
  real_T c55_v1;
  uint32_T c55_debug_family_var_map[6];
  boolean_T c55_aVarTruthTableCondition_1;
  boolean_T c55_aVarTruthTableCondition_2;
  real_T c55_nargin = 1.0;
  real_T c55_nargout = 1.0;
  real_T c55_v2;
  real_T *c55_b_v2;
  real_T *c55_b_v1;
  c55_b_v1 = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
  c55_b_v2 = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
  _SFD_SYMBOL_SCOPE_PUSH(0U, 0U);
  _sfTime_ = sf_get_time(chartInstance->S);
  _SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 30U, chartInstance->c55_sfEvent);
  chartInstance->c55_sfEvent = CALL_EVENT;
  _SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 30U, chartInstance->c55_sfEvent);
  c55_hoistedGlobal = *c55_b_v1;
  c55_v1 = c55_hoistedGlobal;
  _SFD_SYMBOL_SCOPE_PUSH_EML(0U, 6U, 6U, c55_debug_family_names,
    c55_debug_family_var_map);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c55_aVarTruthTableCondition_1, 0U,
    c55_b_sf_marshallOut, c55_b_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c55_aVarTruthTableCondition_2, 1U,
    c55_b_sf_marshallOut, c55_b_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c55_nargin, 2U, c55_sf_marshallOut,
    c55_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c55_nargout, 3U, c55_sf_marshallOut,
    c55_sf_marshallIn);
  _SFD_SYMBOL_SCOPE_ADD_EML(&c55_v1, 4U, c55_sf_marshallOut);
  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c55_v2, 5U, c55_sf_marshallOut,
    c55_sf_marshallIn);
  CV_EML_FCN(0, 0);
  _SFD_EML_CALL(0U, chartInstance->c55_sfEvent, 3);
  c55_aVarTruthTableCondition_1 = false;
  _SFD_EML_CALL(0U, chartInstance->c55_sfEvent, 4);
  c55_aVarTruthTableCondition_2 = false;
  _SFD_EML_CALL(0U, chartInstance->c55_sfEvent, 8);
  c55_aVarTruthTableCondition_1 = (c55_v1 > 25.0);
  _SFD_EML_CALL(0U, chartInstance->c55_sfEvent, 11);
  c55_aVarTruthTableCondition_2 = (c55_v1 < -25.0);
  _SFD_EML_CALL(0U, chartInstance->c55_sfEvent, 13);
  if (CV_EML_IF(0, 1, 0, c55_aVarTruthTableCondition_1)) {
    _SFD_EML_CALL(0U, chartInstance->c55_sfEvent, 14);
    CV_EML_FCN(0, 1);
    _SFD_EML_CALL(0U, chartInstance->c55_sfEvent, 24);
    c55_v2 = c55_v1;
    _SFD_EML_CALL(0U, chartInstance->c55_sfEvent, -24);
  } else {
    _SFD_EML_CALL(0U, chartInstance->c55_sfEvent, 15);
    if (CV_EML_IF(0, 1, 1, c55_aVarTruthTableCondition_2)) {
      _SFD_EML_CALL(0U, chartInstance->c55_sfEvent, 16);
      CV_EML_FCN(0, 2);
      _SFD_EML_CALL(0U, chartInstance->c55_sfEvent, 29);
      c55_v2 = c55_v1;
      _SFD_EML_CALL(0U, chartInstance->c55_sfEvent, -29);
    } else {
      _SFD_EML_CALL(0U, chartInstance->c55_sfEvent, 18);
      CV_EML_FCN(0, 3);
      _SFD_EML_CALL(0U, chartInstance->c55_sfEvent, 34);
      c55_v2 = 0.0;
      _SFD_EML_CALL(0U, chartInstance->c55_sfEvent, -34);
    }
  }

  _SFD_EML_CALL(0U, chartInstance->c55_sfEvent, -18);
  _SFD_SYMBOL_SCOPE_POP();
  *c55_b_v2 = c55_v2;
  _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 30U, chartInstance->c55_sfEvent);
  _SFD_SYMBOL_SCOPE_POP();
  _SFD_CHECK_FOR_STATE_INCONSISTENCY(_Expriment_AllMachineNumber_,
    chartInstance->chartNumber, chartInstance->instanceNumber);
  _SFD_DATA_RANGE_CHECK(*c55_b_v2, 0U);
  _SFD_DATA_RANGE_CHECK(*c55_b_v1, 1U);
}
コード例 #30
0
static void sf_c20_ekffede(SFc20_ekffedeInstanceStruct *chartInstance)
{
  int32_T c20_i0;
  real_T c20_hoistedGlobal;
  real_T c20_b_hoistedGlobal;
  int32_T c20_i1;
  real_T c20_mag[3];
  real_T c20_phi;
  real_T c20_theta;
  uint32_T c20_debug_family_var_map[8];
  real_T c20_mn;
  real_T c20_me;
  real_T c20_nargin = 3.0;
  real_T c20_nargout = 1.0;
  real_T c20_psi;
  real_T c20_x;
  real_T c20_b_x;
  real_T c20_a;
  real_T c20_b;
  real_T c20_y;
  real_T c20_c_x;
  real_T c20_d_x;
  real_T c20_e_x;
  real_T c20_f_x;
  real_T c20_b_a;
  real_T c20_b_b;
  real_T c20_b_y;
  real_T c20_c_a;
  real_T c20_c_b;
  real_T c20_c_y;
  real_T c20_g_x;
  real_T c20_h_x;
  real_T c20_i_x;
  real_T c20_j_x;
  real_T c20_d_a;
  real_T c20_d_b;
  real_T c20_d_y;
  real_T c20_e_a;
  real_T c20_e_b;
  real_T c20_e_y;
  real_T c20_k_x;
  real_T c20_l_x;
  real_T c20_f_a;
  real_T c20_f_b;
  real_T c20_f_y;
  real_T c20_m_x;
  real_T c20_n_x;
  real_T c20_g_a;
  real_T c20_g_b;
  real_T c20_g_y;
  real_T c20_h_y;
  real_T c20_o_x;
  real_T c20_i_y;
  real_T c20_p_x;
  real_T c20_r;
  real_T *c20_b_psi;
  real_T *c20_b_phi;
  real_T *c20_b_theta;
  real_T (*c20_b_mag)[3];
  c20_b_theta = (real_T *)ssGetInputPortSignal(chartInstance->S, 2);
  c20_b_phi = (real_T *)ssGetInputPortSignal(chartInstance->S, 1);
  c20_b_psi = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
  c20_b_mag = (real_T (*)[3])ssGetInputPortSignal(chartInstance->S, 0);
  _sfTime_ = (real_T)ssGetT(chartInstance->S);
  _SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 19U, chartInstance->c20_sfEvent);
  for (c20_i0 = 0; c20_i0 < 3; c20_i0++) {
    _SFD_DATA_RANGE_CHECK((*c20_b_mag)[c20_i0], 0U);
  }

  _SFD_DATA_RANGE_CHECK(*c20_b_psi, 1U);
  _SFD_DATA_RANGE_CHECK(*c20_b_phi, 2U);
  _SFD_DATA_RANGE_CHECK(*c20_b_theta, 3U);
  chartInstance->c20_sfEvent = CALL_EVENT;
  _SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 19U, chartInstance->c20_sfEvent);
  c20_hoistedGlobal = *c20_b_phi;
  c20_b_hoistedGlobal = *c20_b_theta;
  for (c20_i1 = 0; c20_i1 < 3; c20_i1++) {
    c20_mag[c20_i1] = (*c20_b_mag)[c20_i1];
  }

  c20_phi = c20_hoistedGlobal;
  c20_theta = c20_b_hoistedGlobal;
  sf_debug_symbol_scope_push_eml(0U, 8U, 8U, c20_debug_family_names,
    c20_debug_family_var_map);
  sf_debug_symbol_scope_add_eml_importable(&c20_mn, 0U, c20_sf_marshallOut,
    c20_sf_marshallIn);
  sf_debug_symbol_scope_add_eml_importable(&c20_me, 1U, c20_sf_marshallOut,
    c20_sf_marshallIn);
  sf_debug_symbol_scope_add_eml_importable(&c20_nargin, 2U, c20_sf_marshallOut,
    c20_sf_marshallIn);
  sf_debug_symbol_scope_add_eml_importable(&c20_nargout, 3U, c20_sf_marshallOut,
    c20_sf_marshallIn);
  sf_debug_symbol_scope_add_eml(c20_mag, 4U, c20_b_sf_marshallOut);
  sf_debug_symbol_scope_add_eml(&c20_phi, 5U, c20_sf_marshallOut);
  sf_debug_symbol_scope_add_eml(&c20_theta, 6U, c20_sf_marshallOut);
  sf_debug_symbol_scope_add_eml_importable(&c20_psi, 7U, c20_sf_marshallOut,
    c20_sf_marshallIn);
  CV_EML_FCN(0, 0);
  _SFD_EML_CALL(0U, chartInstance->c20_sfEvent, 3);
  c20_x = c20_theta;
  c20_b_x = c20_x;
  c20_b_x = muDoubleScalarCos(c20_b_x);
  c20_a = c20_b_x;
  c20_b = c20_mag[0];
  c20_y = c20_a * c20_b;
  c20_c_x = c20_phi;
  c20_d_x = c20_c_x;
  c20_d_x = muDoubleScalarSin(c20_d_x);
  c20_e_x = c20_theta;
  c20_f_x = c20_e_x;
  c20_f_x = muDoubleScalarSin(c20_f_x);
  c20_b_a = c20_d_x;
  c20_b_b = c20_f_x;
  c20_b_y = c20_b_a * c20_b_b;
  c20_c_a = c20_b_y;
  c20_c_b = c20_mag[1];
  c20_c_y = c20_c_a * c20_c_b;
  c20_g_x = c20_phi;
  c20_h_x = c20_g_x;
  c20_h_x = muDoubleScalarCos(c20_h_x);
  c20_i_x = c20_theta;
  c20_j_x = c20_i_x;
  c20_j_x = muDoubleScalarSin(c20_j_x);
  c20_d_a = c20_h_x;
  c20_d_b = c20_j_x;
  c20_d_y = c20_d_a * c20_d_b;
  c20_e_a = c20_d_y;
  c20_e_b = c20_mag[2];
  c20_e_y = c20_e_a * c20_e_b;
  c20_mn = (c20_y + c20_c_y) + c20_e_y;
  _SFD_EML_CALL(0U, chartInstance->c20_sfEvent, 7);
  c20_k_x = c20_phi;
  c20_l_x = c20_k_x;
  c20_l_x = muDoubleScalarCos(c20_l_x);
  c20_f_a = c20_l_x;
  c20_f_b = c20_mag[1];
  c20_f_y = c20_f_a * c20_f_b;
  c20_m_x = c20_phi;
  c20_n_x = c20_m_x;
  c20_n_x = muDoubleScalarSin(c20_n_x);
  c20_g_a = -c20_n_x;
  c20_g_b = c20_mag[2];
  c20_g_y = c20_g_a * c20_g_b;
  c20_me = c20_f_y + c20_g_y;
  _SFD_EML_CALL(0U, chartInstance->c20_sfEvent, 10);
  c20_h_y = c20_me;
  c20_o_x = c20_mn;
  c20_i_y = c20_h_y;
  c20_p_x = c20_o_x;
  c20_r = muDoubleScalarAtan2(c20_i_y, c20_p_x);
  c20_psi = -c20_r;
  _SFD_EML_CALL(0U, chartInstance->c20_sfEvent, -10);
  sf_debug_symbol_scope_pop();
  *c20_b_psi = c20_psi;
  _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 19U, chartInstance->c20_sfEvent);
  sf_debug_check_for_state_inconsistency(_ekffedeMachineNumber_,
    chartInstance->chartNumber, chartInstance->instanceNumber);
}