c2_auto_netcon.c

RFID读卡器与标签之间在AWGN和加入其它读写器干扰下的BER仿真

          static unsigned int sStartGuardMap[] = {1};
          static unsigned int sEndGuardMap[] = {5};
          _SFD_TRANS_COV_MAPS(10,
           0,NULL,NULL,
           1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),
           5,NULL,NULL,
           0,NULL,NULL);
        }
        _SFD_TRANS_COV_WTS(4,0,1,4,0);
        if(chartAlreadyPresent==0)
        {
          static unsigned int sStartGuardMap[] = {1};
          static unsigned int sEndGuardMap[] = {4};
          _SFD_TRANS_COV_MAPS(4,
           0,NULL,NULL,
           1,&(sStartGuardMap[0]),&(sEndGuardMap[0]),
           4,NULL,NULL,
           0,NULL,NULL);
        }
        _SFD_SET_DATA_VALUE_PTR(4U, &chartInstance.c2_code);
        _SFD_SET_DATA_VALUE_PTR(7U, &chartInstance.c2_convec);
        _SFD_SET_DATA_VALUE_PTR(0U, &chartInstance.c2_i);
        _SFD_SET_DATA_VALUE_PTR(1U, &chartInstance.c2_count);
        _SFD_SET_DATA_VALUE_PTR(5U, c2_outdp());
        _SFD_SET_DATA_VALUE_PTR(2U, &chartInstance.c2_i1);
        _SFD_SET_DATA_VALUE_PTR(3U, &chartInstance.c2_j);
        _SFD_SET_DATA_VALUE_PTR(6U, c2_indp());
      }
    }
  } else {
    sf_debug_reset_current_state_configuration(_auto_netconMachineNumber_,chartInstance.chartNumber,chartInstance.instanceNumber);
  }
}

static void sf_opaque_initialize_c2_auto_netcon(void *chartInstanceVar)
{
  chart_debug_initialization(chartInstance.S);
  initialize_params_c2_auto_netcon();
  initialize_c2_auto_netcon();
}

static void sf_opaque_enable_c2_auto_netcon(void *chartInstanceVar)
{
  enable_c2_auto_netcon();
}

static void sf_opaque_disable_c2_auto_netcon(void *chartInstanceVar)
{
  disable_c2_auto_netcon();
}

static void sf_opaque_gateway_c2_auto_netcon(void *chartInstanceVar)
{
  sf_c2_auto_netcon();
}

static void sf_opaque_terminate_c2_auto_netcon(void *chartInstanceVar)
{
  finalize_c2_auto_netcon();
}

static void mdlProcessParameters_c2_auto_netcon(SimStruct *S)
{
  int i;
  for(i=0;i<ssGetNumRunTimeParams(S);i++) {
    if(ssGetSFcnParamTunable(S,i)) {
      ssUpdateDlgParamAsRunTimeParam(S,i);
    }
  }
  initialize_params_c2_auto_netcon();
}

static void mdlSetWorkWidths_c2_auto_netcon(SimStruct *S)
{
  if(sim_mode_is_rtw_gen(S)) {
    int_T chartIsInlinable =
      (int_T)sf_is_chart_inlinable("auto_netcon",2);
    ssSetStateflowIsInlinable(S,chartIsInlinable);
    ssSetEnableFcnIsTrivial(S,1);
    ssSetDisableFcnIsTrivial(S,1);
    ssSetNotMultipleInlinable(S,sf_rtw_info_uint_prop("auto_netcon",2,"gatewayCannotBeInlinedMultipleTimes"));
    if(chartIsInlinable) {
      ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL);
      sf_mark_chart_expressionable_inputs(S,"auto_netcon",2,1);
      sf_mark_chart_reusable_outputs(S,"auto_netcon",2,1);
    }
    ssSetInputPortOptimOpts(S, 1, SS_REUSABLE_AND_LOCAL);
    if (!sf_is_chart_instance_optimized_out("auto_netcon",2)) {
      int dtId;
      char *chartInstanceTypedefName =
        sf_chart_instance_typedef_name("auto_netcon",2);
      dtId = ssRegisterDataType(S, chartInstanceTypedefName);
      if (dtId == INVALID_DTYPE_ID ) return;
      /* Register the size of the udt */
      if (!ssSetDataTypeSize(S, dtId, 8)) return;
      if(!ssSetNumDWork(S,1)) return;
      ssSetDWorkDataType(S, 0, dtId);
      ssSetDWorkWidth(S, 0, 1);
      ssSetDWorkName(S, 0, "ChartInstance"); /*optional name, less than 16 chars*/
      sf_set_rtw_identifier(S);
    }
    ssSetHasSubFunctions(S,!(chartIsInlinable));
    ssSetOptions(S,ssGetOptions(S)|SS_OPTION_WORKS_WITH_CODE_REUSE);
  }

  ssSetChecksum0(S,(391293651U));
  ssSetChecksum1(S,(1351365001U));
  ssSetChecksum2(S,(3383138287U));
  ssSetChecksum3(S,(4222560106U));

  ssSetExplicitFCSSCtrl(S,1);
}

static void mdlRTW_c2_auto_netcon(SimStruct *S)
{
  if(sim_mode_is_rtw_gen(S)) {
    sf_write_symbol_mapping(S, "auto_netcon", 2);
    ssWriteRTWStrParam(S, "StateflowChartType", "Stateflow");
  }
}

static void sf_save_debug_c2_auto_netcon(SFc2_auto_netconInstanceStruct*
 chartInstance, FILE* file)
{
  int machineNumber = _auto_netconMachineNumber_;
  int chartNumber = chartInstance->chartNumber;
  int instanceNumber = chartInstance->instanceNumber;
  int bufferSize = sf_debug_get_state_vectors_data_size(machineNumber,
   chartNumber, instanceNumber);
  unsigned char* buffer = (unsigned char*) malloc(bufferSize);
  unsigned int chartActive = sf_debug_get_chart_active(machineNumber,
   chartNumber, instanceNumber);
  fwrite(&chartActive, sizeof(chartActive),1,file);
  sf_debug_get_state_vectors_data(machineNumber, chartNumber, instanceNumber,
   buffer, bufferSize);
  fwrite(&bufferSize, sizeof(bufferSize), 1, file); /* Write number of bytes */
  fwrite(buffer, 1, bufferSize,file);   /* Write buffer */
  free(buffer);
}
static void sf_load_debug_c2_auto_netcon(SFc2_auto_netconInstanceStruct*
 chartInstance,FILE* file)
{
  int machineNumber = _auto_netconMachineNumber_;
  int chartNumber = chartInstance->chartNumber;
  int instanceNumber = chartInstance->instanceNumber;
  int bufferSize = 0;
  unsigned char* buffer = NULL;
  unsigned int chartActive = 0;
  fread(&chartActive, sizeof(chartActive),1,file);
  sf_debug_set_chart_active(machineNumber, chartNumber, instanceNumber,
   chartActive);
  fread(&bufferSize, sizeof(bufferSize), 1, file);
  buffer = (unsigned char*) malloc(bufferSize);
  fread(buffer, 1, bufferSize, file);
  sf_debug_set_state_vectors_data(machineNumber, chartNumber, instanceNumber,
   buffer, bufferSize);
  free(buffer);
}
static void sf_c2_auto_netcon_sim_ctx_io(SimStruct* S, const char io, FILE* file)
{
  if(io == 'r') {
    sf_load_state_c2_auto_netcon(file);
    sf_load_debug_c2_auto_netcon(&chartInstance, file);
  } else {
    sf_save_state_c2_auto_netcon(file);
    sf_save_debug_c2_auto_netcon(&chartInstance, file);
  }
}
static void mdlStart_c2_auto_netcon(SimStruct *S)
{
  chartInstance.chartInfo.chartInstance = NULL;
  chartInstance.chartInfo.isEMLChart = 0;
  chartInstance.chartInfo.chartInitialized = 0;
  chartInstance.chartInfo.sFunctionGateway = sf_opaque_gateway_c2_auto_netcon;
  chartInstance.chartInfo.initializeChart = sf_opaque_initialize_c2_auto_netcon;
  chartInstance.chartInfo.terminateChart = sf_opaque_terminate_c2_auto_netcon;
  chartInstance.chartInfo.enableChart = sf_opaque_enable_c2_auto_netcon;
  chartInstance.chartInfo.disableChart = sf_opaque_disable_c2_auto_netcon;
  chartInstance.chartInfo.mdlRTW = mdlRTW_c2_auto_netcon;
  chartInstance.chartInfo.mdlStart = mdlStart_c2_auto_netcon;
  chartInstance.chartInfo.mdlSetWorkWidths = mdlSetWorkWidths_c2_auto_netcon;
  chartInstance.chartInfo.restoreLastMajorStepConfiguration = NULL;
  chartInstance.chartInfo.restoreBeforeLastMajorStepConfiguration = NULL;
  chartInstance.chartInfo.storeCurrentConfiguration = NULL;
  chartInstance.S = S;
  ssSetUserData(S,(void *)(&(chartInstance.chartInfo))); /* register the chart instance with simstruct */
  ssSetmdlSimulationContextIO(S, sf_c2_auto_netcon_sim_ctx_io);

  if(!sim_mode_is_rtw_gen(S)) {
    init_test_point_mapping_info(S);
  }
  if(!sim_mode_is_rtw_gen(S)) {
    init_dsm_address_info();
  }
}

void c2_auto_netcon_method_dispatcher(SimStruct *S, int_T method, void *data)
{
  switch (method) {
   case SS_CALL_MDL_START:
    mdlStart_c2_auto_netcon(S);
    break;
   case SS_CALL_MDL_SET_WORK_WIDTHS:
    mdlSetWorkWidths_c2_auto_netcon(S);
    break;
   case SS_CALL_MDL_PROCESS_PARAMETERS:
    mdlProcessParameters_c2_auto_netcon(S);
    break;
   default:
    /* Unhandled method */
    sf_mex_error_message("Stateflow Internal Error:\n"
     "Error calling c2_auto_netcon_method_dispatcher.\n"
     "Can't handle method %d.\n", method);
    break;
  }
}

static const rtwCAPI_DataTypeMap dataTypeMap[] = {
  /* cName, mwName, numElements, elemMapIndex, dataSize, slDataId, isComplex, isPointer */
  {"int8_T", "int8_T", 0, 0, sizeof(int8_T), SS_INT8, 0, 0},
  {"uint16_T", "uint16_T", 0, 0, sizeof(uint16_T), SS_UINT16, 0, 0},
  {"uint8_T", "uint8_T", 0, 0, sizeof(uint8_T), SS_UINT8, 0, 0}
};

static const rtwCAPI_FixPtMap fixedPointMap[] = {
  /* *fracSlope, *bias, scaleType, wordLength, exponent, isSigned */
  {NULL, NULL, rtwCAPI_FIX_RESERVED, 64, 0, 0}
};

static const rtwCAPI_DimensionMap dimensionMap[] = {
  /* dataOrientation, dimArrayIndex, numDims*/
  {rtwCAPI_SCALAR, 0, 2},
  {rtwCAPI_VECTOR, 2, 2}
};

static const uint_T dimensionArray[] = {
  1, 1,
  2, 1
};

static real_T sfCAPIsampleTimeZero = 0.0;
static const rtwCAPI_SampleTimeMap sampleTimeMap[] = {
  /* *period, *offset, taskId, mode */
  {&sfCAPIsampleTimeZero, &sfCAPIsampleTimeZero, 0, 0}
};

static const rtwCAPI_Signals testPointSignals[] = {
  /* addrMapIndex, sysNum, SFRelativePath, dataName, portNumber, dataTypeIndex, dimIndex, fixPtIdx, sTimeIndex */
  {0, 0,"StateflowChart/code", "code", 0, 2, 0, 0, 0},
  {1, 0,"StateflowChart/convec", "convec", 0, 2, 1, 0, 0},
  {2, 0,"StateflowChart/i", "i", 0, 2, 0, 0, 0},
  {3, 0,"StateflowChart/count", "count", 0, 1, 0, 0, 0},
  {4, 0,"StateflowChart/i1", "i1", 0, 0, 0, 0, 0},
  {5, 0,"StateflowChart/j", "j", 0, 0, 0, 0, 0},
  {6, 0, "StateflowChart/ROAD1", "ROAD1", 0, 2, 0, 0, 0},
  {7, 0, "StateflowChart/ROAD2", "ROAD2", 0, 2, 0, 0, 0},
  {8, 0, "StateflowChart/ROAD3", "ROAD3", 0, 2, 0, 0, 0},
  {9, 0, "StateflowChart/ROAD4", "ROAD4", 0, 2, 0, 0, 0},
  {10, 0, "StateflowChart/STOP", "STOP", 0, 2, 0, 0, 0},
  {11, 0, "StateflowChart/start", "start", 0, 2, 0, 0, 0}
};

static rtwCAPI_ModelMappingStaticInfo testPointMappingStaticInfo = {
  /* block signal monitoring */
  {
    testPointSignals,                   /* Block signals Array  */
    12                                  /* Num Block IO signals */
  },

  /* parameter tuning */
  {
    NULL,                               /* Block parameters Array    */
    0,                                  /* Num block parameters      */
    NULL,                               /* Variable parameters Array */
    0                                   /* Num variable parameters   */
  },

  /* block states */
  {
    NULL,                               /* Block States array        */
    0                                   /* Num Block States          */
  },

  /* Static maps */
  {
    dataTypeMap,                        /* Data Type Map            */
    dimensionMap,                       /* Data Dimension Map       */
    fixedPointMap,                      /* Fixed Point Map          */
    NULL,                               /* Structure Element map    */
    sampleTimeMap,                      /* Sample Times Map         */
    dimensionArray                      /* Dimension Array          */
  },

  /* Target type */
  "float"
};

static void init_test_point_mapping_info(SimStruct *S) {
  rtwCAPI_ModelMappingInfo *testPointMappingInfo;
  void **testPointAddrMap;

  init_test_point_addr_map();
  testPointMappingInfo = get_test_point_mapping_info();
  testPointAddrMap = get_test_point_address_map();

  rtwCAPI_SetStaticMap(*testPointMappingInfo, &testPointMappingStaticInfo);
  rtwCAPI_SetLoggingStaticMap(*testPointMappingInfo, NULL);
  rtwCAPI_SetInstanceLoggingInfo(*testPointMappingInfo, NULL);
  rtwCAPI_SetPath(*testPointMappingInfo, "");
  rtwCAPI_SetFullPath(*testPointMappingInfo, NULL);
  rtwCAPI_SetDataAddressMap(*testPointMappingInfo, testPointAddrMap);
  rtwCAPI_SetChildMMIArray(*testPointMappingInfo, NULL);
  rtwCAPI_SetChildMMIArrayLen(*testPointMappingInfo, 0);

  ssSetModelMappingInfoPtr(S, testPointMappingInfo);
}