Exemplo n.º 1
0
static void set_sim_state_c45_Expriment_All(SFc45_Expriment_AllInstanceStruct
  *chartInstance, const mxArray *c45_st)
{
  const mxArray *c45_u;
  real_T c45_dv0[6];
  int32_T c45_i1;
  real_T (*c45_y)[6];
  c45_y = (real_T (*)[6])ssGetOutputPortSignal(chartInstance->S, 1);
  chartInstance->c45_doneDoubleBufferReInit = true;
  c45_u = sf_mex_dup(c45_st);
  c45_emlrt_marshallIn(chartInstance, sf_mex_dup(sf_mex_getcell(c45_u, 0)), "y",
                       c45_dv0);
  for (c45_i1 = 0; c45_i1 < 6; c45_i1++) {
    (*c45_y)[c45_i1] = c45_dv0[c45_i1];
  }

  chartInstance->c45_is_active_c45_Expriment_All = c45_e_emlrt_marshallIn
    (chartInstance, sf_mex_dup(sf_mex_getcell(c45_u, 1)),
     "is_active_c45_Expriment_All");
  sf_mex_destroy(&c45_u);
  c45_update_debugger_state_c45_Expriment_All(chartInstance);
  sf_mex_destroy(&c45_st);
}
static void set_sim_state_c10_HIL_model_overall
  (SFc10_HIL_model_overallInstanceStruct *chartInstance, const mxArray *c10_st)
{
  const mxArray *c10_u;
  real_T c10_dv0[9];
  int32_T c10_i1;
  real_T (*c10_R)[9];
  c10_R = (real_T (*)[9])ssGetOutputPortSignal(chartInstance->S, 1);
  chartInstance->c10_doneDoubleBufferReInit = TRUE;
  c10_u = sf_mex_dup(c10_st);
  c10_emlrt_marshallIn(chartInstance, sf_mex_dup(sf_mex_getcell(c10_u, 0)), "R",
                       c10_dv0);
  for (c10_i1 = 0; c10_i1 < 9; c10_i1++) {
    (*c10_R)[c10_i1] = c10_dv0[c10_i1];
  }

  chartInstance->c10_is_active_c10_HIL_model_overall = c10_e_emlrt_marshallIn
    (chartInstance, sf_mex_dup(sf_mex_getcell(c10_u, 1)),
     "is_active_c10_HIL_model_overall");
  sf_mex_destroy(&c10_u);
  c10_update_debugger_state_c10_HIL_model_overall(chartInstance);
  sf_mex_destroy(&c10_st);
}
Exemplo n.º 3
0
static uint8_T c1_c_emlrt_marshallIn
  (SFc1_MON_sl_after_replacement3InstanceStruct *chartInstance, const mxArray
   *c1_b_MANUAL, const char_T *c1_identifier)
{
  uint8_T c1_y;
  emlrtMsgIdentifier c1_thisId;
  c1_thisId.fIdentifier = c1_identifier;
  c1_thisId.fParent = NULL;
  c1_thisId.bParentIsCell = false;
  c1_y = c1_d_emlrt_marshallIn(chartInstance, sf_mex_dup(c1_b_MANUAL),
    &c1_thisId);
  sf_mex_destroy(&c1_b_MANUAL);
  return c1_y;
}
Exemplo n.º 4
0
static void set_sim_state_c13_Final_Project_v3b
  (SFc13_Final_Project_v3bInstanceStruct *chartInstance, const mxArray *c13_st)
{
  const mxArray *c13_u;
  real_T c13_dv0[6];
  int32_T c13_i1;
  real_T (*c13_y)[6];
  c13_y = (real_T (*)[6])ssGetOutputPortSignal(chartInstance->S, 1);
  chartInstance->c13_doneDoubleBufferReInit = TRUE;
  c13_u = sf_mex_dup(c13_st);
  c13_emlrt_marshallIn(chartInstance, sf_mex_dup(sf_mex_getcell(c13_u, 0)), "y",
                       c13_dv0);
  for (c13_i1 = 0; c13_i1 < 6; c13_i1++) {
    (*c13_y)[c13_i1] = c13_dv0[c13_i1];
  }

  chartInstance->c13_is_active_c13_Final_Project_v3b = c13_e_emlrt_marshallIn
    (chartInstance, sf_mex_dup(sf_mex_getcell(c13_u, 1)),
     "is_active_c13_Final_Project_v3b");
  sf_mex_destroy(&c13_u);
  c13_update_debugger_state_c13_Final_Project_v3b(chartInstance);
  sf_mex_destroy(&c13_st);
}
static void c14_b_emlrt_marshallIn(SFc14_Model_justmodelInstanceStruct
  *chartInstance, const mxArray *c14_u, const emlrtMsgIdentifier *c14_parentId,
  real_T c14_y[9])
{
  real_T c14_dv3[9];
  int32_T c14_i23;
  sf_mex_import(c14_parentId, sf_mex_dup(c14_u), c14_dv3, 1, 0, 0U, 1, 0U, 2, 3,
                3);
  for (c14_i23 = 0; c14_i23 < 9; c14_i23++) {
    c14_y[c14_i23] = c14_dv3[c14_i23];
  }

  sf_mex_destroy(&c14_u);
}
static void c14_c_sf_marshallIn(void *chartInstanceVoid, const mxArray
  *c14_mxArrayInData, const char_T *c14_varName, void *c14_outData)
{
  const mxArray *c14_eta_s;
  const char_T *c14_identifier;
  emlrtMsgIdentifier c14_thisId;
  real_T c14_y[3];
  int32_T c14_i30;
  SFc14_Model_justmodelInstanceStruct *chartInstance;
  chartInstance = (SFc14_Model_justmodelInstanceStruct *)chartInstanceVoid;
  c14_eta_s = sf_mex_dup(c14_mxArrayInData);
  c14_identifier = c14_varName;
  c14_thisId.fIdentifier = c14_identifier;
  c14_thisId.fParent = NULL;
  c14_d_emlrt_marshallIn(chartInstance, sf_mex_dup(c14_eta_s), &c14_thisId,
    c14_y);
  sf_mex_destroy(&c14_eta_s);
  for (c14_i30 = 0; c14_i30 < 3; c14_i30++) {
    (*(real_T (*)[3])c14_outData)[c14_i30] = c14_y[c14_i30];
  }

  sf_mex_destroy(&c14_mxArrayInData);
}
Exemplo n.º 7
0
static void c2_sf_marshallIn(void *chartInstanceVoid, const mxArray
  *c2_mxArrayInData, const char_T *c2_varName, void *c2_outData)
{
  const mxArray *c2_cell_voltages_out;
  const char_T *c2_identifier;
  emlrtMsgIdentifier c2_thisId;
  uint16_T c2_y[12];
  int32_T c2_i12;
  SFc2_Batman_CodeInstanceStruct *chartInstance;
  chartInstance = (SFc2_Batman_CodeInstanceStruct *)chartInstanceVoid;
  c2_cell_voltages_out = sf_mex_dup(c2_mxArrayInData);
  c2_identifier = c2_varName;
  c2_thisId.fIdentifier = c2_identifier;
  c2_thisId.fParent = NULL;
  c2_b_emlrt_marshallIn(chartInstance, sf_mex_dup(c2_cell_voltages_out),
                        &c2_thisId, c2_y);
  sf_mex_destroy(&c2_cell_voltages_out);
  for (c2_i12 = 0; c2_i12 < 12; c2_i12++) {
    (*(uint16_T (*)[12])c2_outData)[c2_i12] = c2_y[c2_i12];
  }

  sf_mex_destroy(&c2_mxArrayInData);
}
static void set_sim_state_c7_WEC_Sim_Driver(SFc7_WEC_Sim_DriverInstanceStruct
  *chartInstance, const mxArray *c7_st)
{
  const mxArray *c7_u;
  real_T c7_dv0[3];
  int32_T c7_i1;
  real_T (*c7_E)[3];
  c7_E = (real_T (*)[3])ssGetOutputPortSignal(chartInstance->S, 1);
  chartInstance->c7_doneDoubleBufferReInit = TRUE;
  c7_u = sf_mex_dup(c7_st);
  c7_emlrt_marshallIn(chartInstance, sf_mex_dup(sf_mex_getcell(c7_u, 0)), "E",
                      c7_dv0);
  for (c7_i1 = 0; c7_i1 < 3; c7_i1++) {
    (*c7_E)[c7_i1] = c7_dv0[c7_i1];
  }

  chartInstance->c7_is_active_c7_WEC_Sim_Driver = c7_e_emlrt_marshallIn
    (chartInstance, sf_mex_dup(sf_mex_getcell(c7_u, 1)),
     "is_active_c7_WEC_Sim_Driver");
  sf_mex_destroy(&c7_u);
  c7_update_debugger_state_c7_WEC_Sim_Driver(chartInstance);
  sf_mex_destroy(&c7_st);
}
Exemplo n.º 9
0
static void set_sim_state_c2_gesamtmodell(SFc2_gesamtmodellInstanceStruct
  *chartInstance, const mxArray *c2_st)
{
  const mxArray *c2_u;
  real_T c2_dv0[3];
  int32_T c2_i1;
  real_T (*c2_y)[3];
  c2_y = (real_T (*)[3])ssGetOutputPortSignal(chartInstance->S, 1);
  chartInstance->c2_doneDoubleBufferReInit = TRUE;
  c2_u = sf_mex_dup(c2_st);
  c2_emlrt_marshallIn(chartInstance, sf_mex_dup(sf_mex_getcell(c2_u, 0)), "y",
                      c2_dv0);
  for (c2_i1 = 0; c2_i1 < 3; c2_i1++) {
    (*c2_y)[c2_i1] = c2_dv0[c2_i1];
  }

  chartInstance->c2_is_active_c2_gesamtmodell = c2_f_emlrt_marshallIn
    (chartInstance, sf_mex_dup(sf_mex_getcell(c2_u, 1)),
     "is_active_c2_gesamtmodell");
  sf_mex_destroy(&c2_u);
  c2_update_debugger_state_c2_gesamtmodell(chartInstance);
  sf_mex_destroy(&c2_st);
}
static void c10_b_emlrt_marshallIn(SFc10_HIL_model_overallInstanceStruct
  *chartInstance, const mxArray *c10_u, const emlrtMsgIdentifier *c10_parentId,
  real_T c10_y[9])
{
  real_T c10_dv2[9];
  int32_T c10_i14;
  sf_mex_import(c10_parentId, sf_mex_dup(c10_u), c10_dv2, 1, 0, 0U, 1, 0U, 2, 3,
                3);
  for (c10_i14 = 0; c10_i14 < 9; c10_i14++) {
    c10_y[c10_i14] = c10_dv2[c10_i14];
  }

  sf_mex_destroy(&c10_u);
}
static uint8_T c3_d_emlrt_marshallIn
  (SFc3_ARP_02_RPSsmile_WirelessGloveInstanceStruct *chartInstance, const
   mxArray *c3_b_is_active_c3_ARP_02_RPSsmile_WirelessGlove, const char_T
   *c3_identifier)
{
  uint8_T c3_y;
  emlrtMsgIdentifier c3_thisId;
  c3_thisId.fIdentifier = c3_identifier;
  c3_thisId.fParent = NULL;
  c3_y = c3_e_emlrt_marshallIn(chartInstance, sf_mex_dup
    (c3_b_is_active_c3_ARP_02_RPSsmile_WirelessGlove), &c3_thisId);
  sf_mex_destroy(&c3_b_is_active_c3_ARP_02_RPSsmile_WirelessGlove);
  return c3_y;
}
Exemplo n.º 12
0
static uint8_T c3_c_emlrt_marshallIn(SFc3_MON_FunctionalInstanceStruct
  *chartInstance, const mxArray *c3_b_is_active_c3_MON_Functional, const char_T *
  c3_identifier)
{
  uint8_T c3_y;
  emlrtMsgIdentifier c3_thisId;
  c3_thisId.fIdentifier = c3_identifier;
  c3_thisId.fParent = NULL;
  c3_thisId.bParentIsCell = false;
  c3_y = c3_d_emlrt_marshallIn(chartInstance, sf_mex_dup
    (c3_b_is_active_c3_MON_Functional), &c3_thisId);
  sf_mex_destroy(&c3_b_is_active_c3_MON_Functional);
  return c3_y;
}
Exemplo n.º 13
0
static void set_sim_state_c9_CusakisME4901arcs2
  (SFc9_CusakisME4901arcs2InstanceStruct *chartInstance, const mxArray *c9_st)
{
  const mxArray *c9_u;
  real_T c9_dv0[4];
  int32_T c9_i2;
  real_T c9_dv1[2];
  int32_T c9_i3;
  real_T *c9_j;
  real_T (*c9_but)[4];
  real_T (*c9_b_u)[2];
  c9_j = (real_T *)ssGetOutputPortSignal(chartInstance->S, 3);
  c9_but = (real_T (*)[4])ssGetOutputPortSignal(chartInstance->S, 2);
  c9_b_u = (real_T (*)[2])ssGetOutputPortSignal(chartInstance->S, 1);
  chartInstance->c9_doneDoubleBufferReInit = TRUE;
  c9_u = sf_mex_dup(c9_st);
  c9_c_emlrt_marshallIn(chartInstance, sf_mex_dup(sf_mex_getcell(c9_u, 0)),
                        "but", c9_dv0);
  for (c9_i2 = 0; c9_i2 < 4; c9_i2++) {
    (*c9_but)[c9_i2] = c9_dv0[c9_i2];
  }

  *c9_j = c9_emlrt_marshallIn(chartInstance, sf_mex_dup(sf_mex_getcell(c9_u, 1)),
    "j");
  c9_e_emlrt_marshallIn(chartInstance, sf_mex_dup(sf_mex_getcell(c9_u, 2)), "u",
                        c9_dv1);
  for (c9_i3 = 0; c9_i3 < 2; c9_i3++) {
    (*c9_b_u)[c9_i3] = c9_dv1[c9_i3];
  }

  chartInstance->c9_is_active_c9_CusakisME4901arcs2 = c9_h_emlrt_marshallIn
    (chartInstance, sf_mex_dup(sf_mex_getcell(c9_u, 3)),
     "is_active_c9_CusakisME4901arcs2");
  sf_mex_destroy(&c9_u);
  c9_update_debugger_state_c9_CusakisME4901arcs2(chartInstance);
  sf_mex_destroy(&c9_st);
}
static void set_sim_state_c6_adcs_v15_integral_Power_no_charge_in_detumb(const
  mxArray *c6_st)
{
  const mxArray *c6_u;
  const mxArray *c6_y;
  real_T c6_d0;
  real_T c6_b_y;
  const mxArray *c6_is_active_c6_adcs_v15_integral_Power_no_charge_in_detumb;
  uint8_T c6_u0;
  uint8_T c6_c_y;
  boolean_T *c6_doneDoubleBufferReInit;
  real_T *c6_d_y;
  uint8_T *c6_b_is_active_c6_adcs_v15_integral_Power_no_charge_in_detumb;
  c6_d_y = (real_T *)ssGetOutputPortSignal(chartInstance.S, 1);
  c6_b_is_active_c6_adcs_v15_integral_Power_no_charge_in_detumb = (uint8_T *)
    ssGetDWork(chartInstance.S, 2);
  c6_doneDoubleBufferReInit = (boolean_T *)ssGetDWork(chartInstance.S, 1);
  *c6_doneDoubleBufferReInit = true;
  c6_u = sf_mex_dup(c6_st);
  c6_y = sf_mex_dup(sf_mex_getcell(c6_u, 0));
  sf_mex_import("y", sf_mex_dup(c6_y), &c6_d0, 1, 0, 0U, 0, 0U, 0);
  c6_b_y = c6_d0;
  sf_mex_destroy(&c6_y);
  *c6_d_y = c6_b_y;
  c6_is_active_c6_adcs_v15_integral_Power_no_charge_in_detumb = sf_mex_dup
    (sf_mex_getcell(c6_u, 1));
  sf_mex_import("is_active_c6_adcs_v15_integral_Power_no_charge_in_detumb",
                sf_mex_dup(
    c6_is_active_c6_adcs_v15_integral_Power_no_charge_in_detumb), &c6_u0, 1, 3,
                0U, 0, 0U, 0);
  c6_c_y = c6_u0;
  sf_mex_destroy(&c6_is_active_c6_adcs_v15_integral_Power_no_charge_in_detumb);
  *c6_b_is_active_c6_adcs_v15_integral_Power_no_charge_in_detumb = c6_c_y;
  sf_mex_destroy(&c6_u);
  c6_update_debugger_state_c6_adcs_v15_integral_Power_no_charge_i();
  sf_mex_destroy(&c6_st);
}
static void set_sim_state_c61_heart_model(SFc61_heart_modelInstanceStruct
  *chartInstance, const mxArray *c61_st)
{
  const mxArray *c61_u;
  boolean_T *c61_event1;
  boolean_T *c61_event2;
  boolean_T *c61_event3;
  c61_event3 = (boolean_T *)ssGetOutputPortSignal(chartInstance->S, 3);
  c61_event2 = (boolean_T *)ssGetOutputPortSignal(chartInstance->S, 2);
  c61_event1 = (boolean_T *)ssGetOutputPortSignal(chartInstance->S, 1);
  c61_u = sf_mex_dup(c61_st);
  *c61_event1 = c61_f_emlrt_marshallIn(chartInstance, sf_mex_dup(sf_mex_getcell
    (c61_u, 0)), "event1");
  *c61_event2 = c61_f_emlrt_marshallIn(chartInstance, sf_mex_dup(sf_mex_getcell
    (c61_u, 1)), "event2");
  *c61_event3 = c61_f_emlrt_marshallIn(chartInstance, sf_mex_dup(sf_mex_getcell
    (c61_u, 2)), "event3");
  chartInstance->c61_event1EventCounter = c61_emlrt_marshallIn(chartInstance,
    sf_mex_dup(sf_mex_getcell(c61_u, 3)), "event1EventCounter");
  chartInstance->c61_event2EventCounter = c61_emlrt_marshallIn(chartInstance,
    sf_mex_dup(sf_mex_getcell(c61_u, 4)), "event2EventCounter");
  chartInstance->c61_event3EventCounter = c61_emlrt_marshallIn(chartInstance,
    sf_mex_dup(sf_mex_getcell(c61_u, 5)), "event3EventCounter");
  chartInstance->c61_is_active_c61_heart_model = c61_d_emlrt_marshallIn
    (chartInstance, sf_mex_dup(sf_mex_getcell(c61_u, 6)),
     "is_active_c61_heart_model");
  chartInstance->c61_is_c61_heart_model = c61_d_emlrt_marshallIn(chartInstance,
    sf_mex_dup(sf_mex_getcell(c61_u, 7)), "is_c61_heart_model");
  sf_mex_assign(&chartInstance->c61_setSimStateSideEffectsInfo,
                c61_h_emlrt_marshallIn(chartInstance, sf_mex_dup(sf_mex_getcell
    (c61_u, 8)), "setSimStateSideEffectsInfo"), TRUE);
  sf_mex_destroy(&c61_u);
  chartInstance->c61_doSetSimStateSideEffects = 1U;
  c61_update_debugger_state_c61_heart_model(chartInstance);
  sf_mex_destroy(&c61_st);
}
static void set_sim_state_c3_Engine_Vehicle_CVT_Wit_System1_trial1
(SFc3_Engine_Vehicle_CVT_Wit_System1_trial1InstanceStruct *chartInstance,
 const mxArray *c3_st)
{
    const mxArray *c3_u;
    boolean_T c3_bv0[1];
    chartInstance->c3_doneDoubleBufferReInit = true;
    c3_u = sf_mex_dup(c3_st);
    *chartInstance->c3_ClutchON = c3_b_emlrt_marshallIn(chartInstance, sf_mex_dup
                                  (sf_mex_getcell(c3_u, 0)), "ClutchON");
    chartInstance->c3_is_active_c3_Engine_Vehicle_CVT_Wit_System1_trial1 =
        c3_e_emlrt_marshallIn(chartInstance, sf_mex_dup(sf_mex_getcell(c3_u, 1)),
                              "is_active_c3_Engine_Vehicle_CVT_Wit_System1_trial1");
    c3_g_emlrt_marshallIn(chartInstance, sf_mex_dup(sf_mex_getcell(c3_u, 2)),
                          "dataWrittenToVector", c3_bv0);
    chartInstance->c3_dataWrittenToVector[0] = c3_bv0[0];
    sf_mex_assign(&chartInstance->c3_setSimStateSideEffectsInfo,
                  c3_i_emlrt_marshallIn(chartInstance, sf_mex_dup(sf_mex_getcell
                                        (c3_u, 3)), "setSimStateSideEffectsInfo"), true);
    sf_mex_destroy(&c3_u);
    chartInstance->c3_doSetSimStateSideEffects = 1U;
    c3_update_debugger_state_c3_Engine_Vehicle_CVT_Wit_System1_trial(chartInstance);
    sf_mex_destroy(&c3_st);
}
Exemplo n.º 17
0
static const mxArray *c4_f_emlrt_marshallIn
  (SFc4_MON_sl_after_replacement3InstanceStruct *chartInstance, const mxArray
   *c4_b_setSimStateSideEffectsInfo, const char_T *c4_identifier)
{
  const mxArray *c4_y = NULL;
  emlrtMsgIdentifier c4_thisId;
  c4_y = NULL;
  c4_thisId.fIdentifier = c4_identifier;
  c4_thisId.fParent = NULL;
  c4_thisId.bParentIsCell = false;
  sf_mex_assign(&c4_y, c4_g_emlrt_marshallIn(chartInstance, sf_mex_dup
    (c4_b_setSimStateSideEffectsInfo), &c4_thisId), false);
  sf_mex_destroy(&c4_b_setSimStateSideEffectsInfo);
  return c4_y;
}
Exemplo n.º 18
0
static void c4_b_emlrt_marshallIn(SFc4_StateObserver_2InstanceStruct
  *chartInstance, const mxArray *c4_b_u, const emlrtMsgIdentifier *c4_parentId,
  real_T c4_y[112])
{
  real_T c4_dv1[112];
  int32_T c4_i16;
  (void)chartInstance;
  sf_mex_import(c4_parentId, sf_mex_dup(c4_b_u), c4_dv1, 1, 0, 0U, 1, 0U, 2, 14,
                8);
  for (c4_i16 = 0; c4_i16 < 112; c4_i16++) {
    c4_y[c4_i16] = c4_dv1[c4_i16];
  }

  sf_mex_destroy(&c4_b_u);
}
static void c26_sf_marshallIn(void *chartInstanceVoid, const mxArray
  *c26_mxArrayInData, const char_T *c26_varName, void *c26_outData)
{
  const mxArray *c26_eta_dot_ref;
  const char_T *c26_identifier;
  emlrtMsgIdentifier c26_thisId;
  real_T c26_y[3];
  int32_T c26_i25;
  SFc26_HIL_model_experiments2InstanceStruct *chartInstance;
  chartInstance = (SFc26_HIL_model_experiments2InstanceStruct *)
    chartInstanceVoid;
  c26_eta_dot_ref = sf_mex_dup(c26_mxArrayInData);
  c26_identifier = c26_varName;
  c26_thisId.fIdentifier = c26_identifier;
  c26_thisId.fParent = NULL;
  c26_b_emlrt_marshallIn(chartInstance, sf_mex_dup(c26_eta_dot_ref), &c26_thisId,
    c26_y);
  sf_mex_destroy(&c26_eta_dot_ref);
  for (c26_i25 = 0; c26_i25 < 3; c26_i25++) {
    (*(real_T (*)[3])c26_outData)[c26_i25] = c26_y[c26_i25];
  }

  sf_mex_destroy(&c26_mxArrayInData);
}
Exemplo n.º 20
0
static void c45_b_emlrt_marshallIn(SFc45_Expriment_GazeInstanceStruct
  *chartInstance, const mxArray *c45_u, const emlrtMsgIdentifier *c45_parentId,
  real_T c45_y[6])
{
  real_T c45_dv1[6];
  int32_T c45_i7;
  (void)chartInstance;
  sf_mex_import(c45_parentId, sf_mex_dup(c45_u), c45_dv1, 1, 0, 0U, 1, 0U, 2, 1,
                6);
  for (c45_i7 = 0; c45_i7 < 6; c45_i7++) {
    c45_y[c45_i7] = c45_dv1[c45_i7];
  }

  sf_mex_destroy(&c45_u);
}
static void set_sim_state_c26_HIL_model_experiments2
  (SFc26_HIL_model_experiments2InstanceStruct *chartInstance, const mxArray
   *c26_st)
{
  const mxArray *c26_u;
  real_T c26_dv0[3];
  int32_T c26_i1;
  real_T (*c26_eta_dot_ref)[3];
  c26_eta_dot_ref = (real_T (*)[3])ssGetOutputPortSignal(chartInstance->S, 1);
  chartInstance->c26_doneDoubleBufferReInit = TRUE;
  c26_u = sf_mex_dup(c26_st);
  c26_emlrt_marshallIn(chartInstance, sf_mex_dup(sf_mex_getcell(c26_u, 0)),
                       "eta_dot_ref", c26_dv0);
  for (c26_i1 = 0; c26_i1 < 3; c26_i1++) {
    (*c26_eta_dot_ref)[c26_i1] = c26_dv0[c26_i1];
  }

  chartInstance->c26_is_active_c26_HIL_model_experiments2 =
    c26_f_emlrt_marshallIn(chartInstance, sf_mex_dup(sf_mex_getcell(c26_u, 1)),
    "is_active_c26_HIL_model_experiments2");
  sf_mex_destroy(&c26_u);
  c26_update_debugger_state_c26_HIL_model_experiments2(chartInstance);
  sf_mex_destroy(&c26_st);
}
Exemplo n.º 22
0
static const mxArray *c3_e_emlrt_marshallIn(SFc3_MON_FunctionalInstanceStruct
  *chartInstance, const mxArray *c3_b_setSimStateSideEffectsInfo, const char_T
  *c3_identifier)
{
  const mxArray *c3_y = NULL;
  emlrtMsgIdentifier c3_thisId;
  c3_y = NULL;
  c3_thisId.fIdentifier = c3_identifier;
  c3_thisId.fParent = NULL;
  c3_thisId.bParentIsCell = false;
  sf_mex_assign(&c3_y, c3_f_emlrt_marshallIn(chartInstance, sf_mex_dup
    (c3_b_setSimStateSideEffectsInfo), &c3_thisId), false);
  sf_mex_destroy(&c3_b_setSimStateSideEffectsInfo);
  return c3_y;
}
static void set_sim_state_c31_adcs_v15_integral_Power_nom(const mxArray *c31_st)
{
  const mxArray *c31_u;
  const mxArray *c31_pow_drawn;
  real_T c31_d0;
  real_T c31_y;
  const mxArray *c31_is_active_c31_adcs_v15_integral_Power_nom;
  uint8_T c31_u0;
  uint8_T c31_b_y;
  boolean_T *c31_doneDoubleBufferReInit;
  real_T *c31_b_pow_drawn;
  uint8_T *c31_b_is_active_c31_adcs_v15_integral_Power_nom;
  c31_b_is_active_c31_adcs_v15_integral_Power_nom = (uint8_T *)ssGetDWork
    (chartInstance.S, 2);
  c31_doneDoubleBufferReInit = (boolean_T *)ssGetDWork(chartInstance.S, 1);
  c31_b_pow_drawn = (real_T *)ssGetOutputPortSignal(chartInstance.S, 1);
  *c31_doneDoubleBufferReInit = true;
  c31_u = sf_mex_dup(c31_st);
  c31_pow_drawn = sf_mex_dup(sf_mex_getcell(c31_u, 0));
  sf_mex_import("pow_drawn", sf_mex_dup(c31_pow_drawn), &c31_d0, 1, 0, 0U, 0, 0U,
                0);
  c31_y = c31_d0;
  sf_mex_destroy(&c31_pow_drawn);
  *c31_b_pow_drawn = c31_y;
  c31_is_active_c31_adcs_v15_integral_Power_nom = sf_mex_dup(sf_mex_getcell
    (c31_u, 1));
  sf_mex_import("is_active_c31_adcs_v15_integral_Power_nom", sf_mex_dup
                (c31_is_active_c31_adcs_v15_integral_Power_nom), &c31_u0, 1, 3
                , 0U, 0, 0U, 0);
  c31_b_y = c31_u0;
  sf_mex_destroy(&c31_is_active_c31_adcs_v15_integral_Power_nom);
  *c31_b_is_active_c31_adcs_v15_integral_Power_nom = c31_b_y;
  sf_mex_destroy(&c31_u);
  c31_update_debugger_state_c31_adcs_v15_integral_Power_nom();
  sf_mex_destroy(&c31_st);
}
Exemplo n.º 24
0
static void c35_b_emlrt_marshallIn(SFc35_Expriment_AllInstanceStruct
  *chartInstance, const mxArray *c35_u, const emlrtMsgIdentifier *c35_parentId,
  real_T c35_y[2000])
{
  real_T c35_dv1[2000];
  int32_T c35_i8;
  (void)chartInstance;
  sf_mex_import(c35_parentId, sf_mex_dup(c35_u), c35_dv1, 1, 0, 0U, 1, 0U, 1,
                2000);
  for (c35_i8 = 0; c35_i8 < 2000; c35_i8++) {
    c35_y[c35_i8] = c35_dv1[c35_i8];
  }

  sf_mex_destroy(&c35_u);
}
static void c39_b_emlrt_marshallIn(SFc39_CSE1_Oculus_gestureInstanceStruct
  *chartInstance, const mxArray *c39_u, const emlrtMsgIdentifier *c39_parentId,
  real_T c39_y[9])
{
  real_T c39_dv1[9];
  int32_T c39_i14;
  (void)chartInstance;
  sf_mex_import(c39_parentId, sf_mex_dup(c39_u), c39_dv1, 1, 0, 0U, 1, 0U, 2, 3,
                3);
  for (c39_i14 = 0; c39_i14 < 9; c39_i14++) {
    c39_y[c39_i14] = c39_dv1[c39_i14];
  }

  sf_mex_destroy(&c39_u);
}
Exemplo n.º 26
0
static void set_sim_state_c11_Batman_Code(SFc11_Batman_CodeInstanceStruct
  *chartInstance, const mxArray *c11_st)
{
  const mxArray *c11_u;
  uint16_T c11_uv0[12];
  int32_T c11_i1;
  uint16_T (*c11_cell_temperatures_out)[12];
  c11_cell_temperatures_out = (uint16_T (*)[12])ssGetOutputPortSignal
    (chartInstance->S, 1);
  chartInstance->c11_doneDoubleBufferReInit = TRUE;
  c11_u = sf_mex_dup(c11_st);
  c11_emlrt_marshallIn(chartInstance, sf_mex_dup(sf_mex_getcell(c11_u, 0)),
                       "cell_temperatures_out", c11_uv0);
  for (c11_i1 = 0; c11_i1 < 12; c11_i1++) {
    (*c11_cell_temperatures_out)[c11_i1] = c11_uv0[c11_i1];
  }

  chartInstance->c11_is_active_c11_Batman_Code = c11_f_emlrt_marshallIn
    (chartInstance, sf_mex_dup(sf_mex_getcell(c11_u, 1)),
     "is_active_c11_Batman_Code");
  sf_mex_destroy(&c11_u);
  c11_update_debugger_state_c11_Batman_Code(chartInstance);
  sf_mex_destroy(&c11_st);
}
Exemplo n.º 27
0
static void c7_b_emlrt_marshallIn(SFc7_NavigationObserver_2InstanceStruct
  *chartInstance, const mxArray *c7_b_u, const emlrtMsgIdentifier *c7_parentId,
  real_T c7_y[36])
{
  real_T c7_dv1[36];
  int32_T c7_i16;
  (void)chartInstance;
  sf_mex_import(c7_parentId, sf_mex_dup(c7_b_u), c7_dv1, 1, 0, 0U, 1, 0U, 2, 6,
                6);
  for (c7_i16 = 0; c7_i16 < 36; c7_i16++) {
    c7_y[c7_i16] = c7_dv1[c7_i16];
  }

  sf_mex_destroy(&c7_b_u);
}
static void c1_b_emlrt_marshallIn(SFc1_VrSubsystemInstanceStruct *chartInstance,
  const mxArray *c1_b_u, const emlrtMsgIdentifier *c1_parentId, real_T c1_b_y
  [128])
{
  real_T c1_dv1[128];
  int32_T c1_i16;
  (void)chartInstance;
  sf_mex_import(c1_parentId, sf_mex_dup(c1_b_u), c1_dv1, 1, 0, 0U, 1, 0U, 2, 1,
                128);
  for (c1_i16 = 0; c1_i16 < 128; c1_i16++) {
    c1_b_y[c1_i16] = c1_dv1[c1_i16];
  }

  sf_mex_destroy(&c1_b_u);
}
Exemplo n.º 29
0
static void c35_f_emlrt_marshallIn(SFc35_Expriment_PoseInstanceStruct
  *chartInstance, const mxArray *c35_u, const emlrtMsgIdentifier *c35_parentId,
  real_T c35_y[1000])
{
  real_T c35_dv2[1000];
  int32_T c35_i20;
  (void)chartInstance;
  sf_mex_import(c35_parentId, sf_mex_dup(c35_u), c35_dv2, 1, 0, 0U, 1, 0U, 2,
                1000, 1);
  for (c35_i20 = 0; c35_i20 < 1000; c35_i20++) {
    c35_y[c35_i20] = c35_dv2[c35_i20];
  }

  sf_mex_destroy(&c35_u);
}
Exemplo n.º 30
0
static real_T c1_b_emlrt_marshallIn(SFc1_my_demo_refInstanceStruct
  *chartInstance, const mxArray *c1_u, const emlrtMsgIdentifier *c1_parentId)
{
  real_T c1_y;
  real_T c1_d0;
  if (mxIsEmpty(c1_u)) {
    chartInstance->c1_i_not_empty = FALSE;
  } else {
    chartInstance->c1_i_not_empty = TRUE;
    sf_mex_import(c1_parentId, sf_mex_dup(c1_u), &c1_d0, 1, 0, 0U, 0, 0U, 0);
    c1_y = c1_d0;
  }

  sf_mex_destroy(&c1_u);
  return c1_y;
}