static void sf_opaque_terminate_c2_ARP_02_RPSsmile_GloveAtomicBradNotImitateSmile(void *chartInstanceVar) { if (chartInstanceVar!=NULL) { SimStruct *S = ((SFc2_ARP_02_RPSsmile_GloveAtomicBradNotImitateSmileInstanceStruct*) chartInstanceVar)->S; ChartRunTimeInfo * crtInfo = (ChartRunTimeInfo *)(ssGetUserData(S)); if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) { sf_clear_rtw_identifier(S); unload_ARP_02_RPSsmile_GloveAtomicBradNotImitateSmile_optimization_info(); } finalize_c2_ARP_02_RPSsmile_GloveAtomicBradNotImitateSmile ((SFc2_ARP_02_RPSsmile_GloveAtomicBradNotImitateSmileInstanceStruct*) chartInstanceVar); utFree((void *)chartInstanceVar); if (crtInfo != NULL) { utFree((void *)crtInfo); } ssSetUserData(S,NULL); } }
/** Function: rtwCAPI_UpdateFullPaths =========================================* * */ const char_T* rtwCAPI_UpdateFullPaths(rtwCAPI_ModelMappingInfo* mmi, const char_T* path, boolean_T isCalledFromTopModel) { int_T i; int_T nCMMI; size_t pathLen; char_T* mmiPath; size_t mmiPathLen; char_T* relMMIPath; size_t relMMIPathLen; if (mmi == NULL) return NULL; utAssert(path != NULL); utAssert( rtwCAPI_GetFullPath(mmi) == NULL ); pathLen = strlen(path)+1; if (isCalledFromTopModel) { /* If called from top model - FullPath is same as path */ mmiPath = (char_T*)utMalloc(pathLen*sizeof(char_T)); (void)memcpy(mmiPath, path, pathLen*sizeof(char_T)); } else { relMMIPath = rtwCAPI_EncodePath(rtwCAPI_GetPath(mmi)); if ( (relMMIPath== NULL) && (rtwCAPI_GetPath(mmi) != NULL)) { return rtwCAPI_mallocError; } relMMIPathLen = relMMIPath ? (strlen(relMMIPath) + 1) : 0; mmiPathLen = pathLen + relMMIPathLen; mmiPath = (char_T*)utMalloc(mmiPathLen*sizeof(char_T)); if (mmiPath == NULL) return rtwCAPI_mallocError; (void)memcpy(mmiPath, path, pathLen*sizeof(char_T)); utAssert(mmiPath[pathLen-1] == '\0'); if (relMMIPath) { /* mmiPath = path + | + relMMIPath + '\0' */ mmiPath[pathLen-1] = '|'; (void)memcpy(&(mmiPath[pathLen]), relMMIPath, relMMIPathLen*sizeof(char_T)); utAssert(mmiPath[mmiPathLen-1] == '\0'); utFree(relMMIPath); } } rtwCAPI_SetFullPath(*mmi, mmiPath); nCMMI = rtwCAPI_GetChildMMIArrayLen(mmi); for (i = 0; i < nCMMI; ++i) { rtwCAPI_ModelMappingInfo* cMMI = rtwCAPI_GetChildMMI(mmi,i); const char_T* errstr = rtwCAPI_UpdateFullPaths(cMMI, mmiPath, 0); if (errstr != NULL) return errstr; } return NULL; } /* rtwCAPI_UpdateFullPaths */
static void sf_opaque_terminate_c6_CSE1_DP(void *chartInstanceVar) { if (chartInstanceVar!=NULL) { SimStruct *S = ((SFc6_CSE1_DPInstanceStruct*) chartInstanceVar)->S; ChartRunTimeInfo * crtInfo = (ChartRunTimeInfo *)(ssGetUserData(S)); if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) { sf_clear_rtw_identifier(S); unload_CSE1_DP_optimization_info(); } finalize_c6_CSE1_DP((SFc6_CSE1_DPInstanceStruct*) chartInstanceVar); utFree((void *)chartInstanceVar); if (crtInfo != NULL) { utFree((void *)crtInfo); } ssSetUserData(S,NULL); } }
static void sf_opaque_terminate_c1_Engine_Vehicle_CVT_RS_System2(void *chartInstanceVar) { if (chartInstanceVar!=NULL) { SimStruct *S = ((SFc1_Engine_Vehicle_CVT_RS_System2InstanceStruct*) chartInstanceVar)->S; ChartRunTimeInfo * crtInfo = (ChartRunTimeInfo *)(ssGetUserData(S)); if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) { sf_clear_rtw_identifier(S); unload_Engine_Vehicle_CVT_RS_System2_optimization_info(); } finalize_c1_Engine_Vehicle_CVT_RS_System2 ((SFc1_Engine_Vehicle_CVT_RS_System2InstanceStruct*) chartInstanceVar); utFree(chartInstanceVar); if (crtInfo != NULL) { utFree(crtInfo); } ssSetUserData(S,NULL); } }
static void sf_opaque_terminate_c1_main(void *chartInstanceVar) { if (chartInstanceVar!=NULL) { SimStruct *S = ((SFc1_mainInstanceStruct*) chartInstanceVar)->S; if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) { sf_clear_rtw_identifier(S); unload_main_optimization_info(); } finalize_c1_main((SFc1_mainInstanceStruct*) chartInstanceVar); utFree((void *)chartInstanceVar); ssSetUserData(S,NULL); } }
static void sf_opaque_terminate_c4_MigrationBGOW_Proto6_MultiSwarm(void *chartInstanceVar) { if (chartInstanceVar!=NULL) { SimStruct *S = ((SFc4_MigrationBGOW_Proto6_MultiSwarmInstanceStruct*) chartInstanceVar)->S; if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) { sf_clear_rtw_identifier(S); unload_MigrationBGOW_Proto6_MultiSwarm_optimization_info(); } finalize_c4_MigrationBGOW_Proto6_MultiSwarm ((SFc4_MigrationBGOW_Proto6_MultiSwarmInstanceStruct*) chartInstanceVar); utFree((void *)chartInstanceVar); ssSetUserData(S,NULL); } }
/** Function: rtwCAPI_GetFullStateBlockPath =================================== * */ char* rtwCAPI_GetFullStateBlockPath(const char* stateBlockPath, const char* mmiPath, size_t mmiPathLen, boolean_T crossingModel) { char_T* blockPath = NULL; char_T* fullStateBlockPath = NULL; size_t fullStateBlockPathLen; if (stateBlockPath == NULL) goto EXIT_POINT; /* fullStateBlockPath = mmiPath + | + blockPath + '\0' */ /* If crossing a model boundary encode, otherwise do not */ if (crossingModel) { blockPath = rtwCAPI_EncodePath(stateBlockPath); if (blockPath == NULL) goto EXIT_POINT; } else { size_t len = strlen(stateBlockPath)+1; blockPath = (char*)utMalloc(len*sizeof(char)); if (blockPath == NULL) goto EXIT_POINT; (void)strcpy(blockPath,stateBlockPath); } utAssert(blockPath != NULL); fullStateBlockPathLen = ( (mmiPath==NULL) ? strlen(blockPath) + 1 : mmiPathLen + strlen(blockPath) + 2 ); fullStateBlockPath = (char*)utMalloc(fullStateBlockPathLen*sizeof(char)); if (fullStateBlockPath == NULL) goto EXIT_POINT; if (mmiPath != NULL) { (void)strcpy(fullStateBlockPath, mmiPath); fullStateBlockPath[mmiPathLen] = '|'; fullStateBlockPath[mmiPathLen+1] = '\0'; (void)strcat(fullStateBlockPath, blockPath); } else { (void)strcpy(fullStateBlockPath, blockPath); fullStateBlockPath[fullStateBlockPathLen-1] = '\0'; } utAssert(fullStateBlockPath[fullStateBlockPathLen-1] == '\0'); EXIT_POINT: utFree(blockPath); return fullStateBlockPath; /* caller is responsible for free */ }
static void sf_opaque_terminate_c1_VrSubsystem(void *chartInstanceVar) { if (chartInstanceVar!=NULL) { SimStruct *S = ((SFc1_VrSubsystemInstanceStruct*) chartInstanceVar)->S; if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) { sf_clear_rtw_identifier(S); unload_VrSubsystem_optimization_info(); } finalize_c1_VrSubsystem((SFc1_VrSubsystemInstanceStruct*) chartInstanceVar); utFree(chartInstanceVar); if (ssGetUserData(S)!= NULL) { sf_free_ChartRunTimeInfo(S); } ssSetUserData(S,NULL); } }
static void sf_opaque_terminate_c2_MigrationOWBG_Proto4_1DLinear2DNonLinear(void *chartInstanceVar) { if (chartInstanceVar!=NULL) { SimStruct *S = ((SFc2_MigrationOWBG_Proto4_1DLinear2DNonLinearInstanceStruct*) chartInstanceVar)->S; if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) { sf_clear_rtw_identifier(S); unload_MigrationOWBG_Proto4_1DLinear2DNonLinear_optimization_info(); } finalize_c2_MigrationOWBG_Proto4_1DLinear2DNonLinear ((SFc2_MigrationOWBG_Proto4_1DLinear2DNonLinearInstanceStruct*) chartInstanceVar); utFree((void *)chartInstanceVar); ssSetUserData(S,NULL); } }
/** Function: rtwCAPI_FreeFullPaths ============================================ * */ void rtwCAPI_FreeFullPaths(rtwCAPI_ModelMappingInfo* mmi) { int_T i; int_T nCMMI; char_T* fullPath; if (mmi == NULL) return; fullPath = rtwCAPI_GetFullPath(mmi); utAssert(fullPath != NULL); utFree(fullPath); rtwCAPI_SetFullPath(*mmi, NULL); nCMMI = rtwCAPI_GetChildMMIArrayLen(mmi); for (i = 0; i < nCMMI; ++i) { rtwCAPI_ModelMappingInfo* cMMI = rtwCAPI_GetChildMMI(mmi,i); rtwCAPI_FreeFullPaths(cMMI); } } /* rtwCAPI_FreeFullPaths */
boolean_T Deadbeat_CUK_acc_rt_TDelayUpdateTailOrGrowBuf ( int_T * bufSzPtr , int_T * tailPtr , int_T * headPtr , int_T * lastPtr , real_T tMinusDelay , real_T * * tBufPtr , real_T * * uBufPtr , real_T * * xBufPtr , boolean_T isfixedbuf , boolean_T istransportdelay , int_T * maxNewBufSzPtr ) { int_T testIdx ; int_T tail = * tailPtr ; int_T bufSz = * bufSzPtr ; real_T * tBuf = * tBufPtr ; real_T * xBuf = ( NULL ) ; int_T numBuffer = 2 ; if ( istransportdelay ) { numBuffer = 3 ; xBuf = * xBufPtr ; } testIdx = ( tail < ( bufSz - 1 ) ) ? ( tail + 1 ) : 0 ; if ( ( tMinusDelay <= tBuf [ testIdx ] ) && ! isfixedbuf ) { int_T j ; real_T * tempT ; real_T * tempU ; real_T * tempX = ( NULL ) ; real_T * uBuf = * uBufPtr ; int_T newBufSz = bufSz + 1024 ; if ( newBufSz > * maxNewBufSzPtr ) { * maxNewBufSzPtr = newBufSz ; } tempU = ( real_T * ) utMalloc ( numBuffer * newBufSz * sizeof ( real_T ) ) ; if ( tempU == ( NULL ) ) { return ( false ) ; } tempT = tempU + newBufSz ; if ( istransportdelay ) tempX = tempT + newBufSz ; for ( j = tail ; j < bufSz ; j ++ ) { tempT [ j - tail ] = tBuf [ j ] ; tempU [ j - tail ] = uBuf [ j ] ; if ( istransportdelay ) tempX [ j - tail ] = xBuf [ j ] ; } for ( j = 0 ; j < tail ; j ++ ) { tempT [ j + bufSz - tail ] = tBuf [ j ] ; tempU [ j + bufSz - tail ] = uBuf [ j ] ; if ( istransportdelay ) tempX [ j + bufSz - tail ] = xBuf [ j ] ; } if ( * lastPtr > tail ) { * lastPtr -= tail ; } else { * lastPtr += ( bufSz - tail ) ; } * tailPtr = 0 ; * headPtr = bufSz ; utFree ( uBuf ) ; * bufSzPtr = newBufSz ; * tBufPtr = tempT ; * uBufPtr = tempU ; if ( istransportdelay ) * xBufPtr = tempX ; } else { * tailPtr = testIdx ; } return ( true ) ; } real_T Deadbeat_CUK_acc_rt_TDelayInterpolate ( real_T
void rt_CleanUpForStateLogWithMMI(RTWLogInfo *li) { int_T i; RTWLogSignalInfo *sigInfo = _rtliGetLogXSignalInfo(li); /* get the non-const ptr */ int_T nSignals = sigInfo->numSignals; if ( nSignals > 0 ) { for (i = 0; i < nSignals; ++i) utFree(sigInfo->blockNames.ptr[i]); FREE(sigInfo->blockNames.ptr); FREE(sigInfo->labels.ptr); FREE(sigInfo->crossMdlRef); FREE(sigInfo->dims); FREE(sigInfo->dataTypes); FREE(sigInfo->complexSignals); FREE(sigInfo->isVarDims); FREE(sigInfo); rtliSetLogXSignalInfo(li, NULL); FREE(_rtliGetLogXSignalPtrs(li)); /* get the non-const ptr */ rtliSetLogXSignalPtrs(li,NULL); } }
/* Function: rt_FillStateSigInfoFromMMI ======================================= * Abstract: * * Returns: * == NULL => success. * ~= NULL => failure, the return value is a pointer to the error * message, which is also set in the simstruct. */ const char_T * rt_FillStateSigInfoFromMMI(RTWLogInfo *li, const char_T **errStatus) { int_T i; int_T nSignals = 0; int_T *dims = NULL; BuiltInDTypeId *dTypes = NULL; int_T *cSgnls = NULL; char_T **labels = NULL; char_T **blockNames = NULL; char_T **stateNames = NULL; boolean_T *crossMdlRef = NULL; void **sigDataAddr = NULL; int_T *logDataType = NULL; boolean_T *isVarDims = NULL; const rtwCAPI_ModelMappingInfo *mmi = (const rtwCAPI_ModelMappingInfo *)rtliGetMMI(li); int_T sigIdx = 0; RTWLogSignalInfo * sigInfo; /* reset error status */ *errStatus = NULL; sigInfo = (RTWLogSignalInfo *)calloc(1,sizeof(RTWLogSignalInfo)); if (sigInfo == NULL) goto ERROR_EXIT; nSignals = rtwCAPI_GetNumStateRecordsForRTWLogging(mmi); if (nSignals >0) { /* These are all freed before exiting this function */ dims = (int_T *)calloc(nSignals,sizeof(int_T)); if (dims == NULL) goto ERROR_EXIT; dTypes = (BuiltInDTypeId *)calloc(nSignals,sizeof(BuiltInDTypeId)); if (dTypes == NULL) goto ERROR_EXIT; cSgnls = (int_T *)calloc(nSignals,sizeof(int_T)); if (cSgnls == NULL) goto ERROR_EXIT; labels = (char_T **)calloc(nSignals, sizeof(char_T*)); if (labels == NULL) goto ERROR_EXIT; blockNames = (char_T**)calloc(nSignals, sizeof(char_T*)); if (blockNames == NULL) goto ERROR_EXIT; stateNames = (char_T**)calloc(nSignals, sizeof(char_T*)); if (stateNames == NULL) goto ERROR_EXIT; crossMdlRef = (boolean_T*)calloc(nSignals, sizeof(boolean_T)); if (crossMdlRef == NULL) goto ERROR_EXIT; logDataType = (int_T *)calloc(nSignals,sizeof(int_T)); if (logDataType == NULL) goto ERROR_EXIT; /* Allocate memeory for isVarDims pointer and set all elements to 0's */ isVarDims = (boolean_T *)calloc(nSignals,sizeof(boolean_T)); if (isVarDims == NULL) goto ERROR_EXIT; /* This is freed in stopDataLogging (it's needed in the meantime) */ sigDataAddr = (void **)calloc(nSignals,sizeof(void *)); if (sigDataAddr == NULL) goto ERROR_EXIT; *errStatus = rtwCAPI_GetStateRecordInfo(mmi, (const char_T**) blockNames, (const char_T**) labels, (const char_T**) stateNames, dims, (int_T*)dTypes, logDataType, cSgnls, sigDataAddr, crossMdlRef, NULL, NULL, /* sigSampleTime */ &sigIdx, false, /* crossingModel */ NULL, /* stateDerivVector */ ACCESS_C_API_FOR_RTW_LOGGING); if (*errStatus != NULL) goto ERROR_EXIT; rtliSetLogXSignalPtrs(li,(LogSignalPtrsType)sigDataAddr); } sigInfo->numSignals = nSignals; sigInfo->numCols = dims; sigInfo->numDims = NULL; sigInfo->dims = dims; sigInfo->dataTypes = dTypes; sigInfo->complexSignals = cSgnls; sigInfo->frameData = NULL; sigInfo->labels.ptr = labels; sigInfo->titles = NULL; sigInfo->titleLengths = NULL; sigInfo->plotStyles = NULL; sigInfo->blockNames.ptr = blockNames; sigInfo->stateNames.ptr = stateNames; sigInfo->crossMdlRef = crossMdlRef; sigInfo->dataTypeConvert = NULL; sigInfo->isVarDims = isVarDims; sigInfo->currSigDims = NULL; rtliSetLogXSignalInfo(li,sigInfo); /* Free logDataType it's not needed any more, * the rest of them will be freed later */ FREE(logDataType); return(NULL); /* NORMAL_EXIT */ ERROR_EXIT: if (*errStatus == NULL) { *errStatus = rtMemAllocError; } /* Free local stuff that was allocated. It is no longer needed */ for (i = 0; i < nSignals; ++i) utFree(blockNames[i]); FREE(blockNames); for (i = 0; i < nSignals; ++i) utFree(stateNames[i]); FREE(stateNames); FREE(labels); FREE(dims); FREE(dTypes); FREE(logDataType); FREE(cSgnls); FREE(isVarDims); return(*errStatus); } /* end rt_InitSignalsStruct */
/** Function: rtwCAPI_GetSigLogRecordInfo ====================================== * */ const char_T* rtwCAPI_GetSigLogRecordInfo(const rtwCAPI_ModelMappingInfo* mmi, const char_T** sigBlockName, const char_T** sigLabel, int_T* sigWidth, int_T* sigDataType, int_T* logDataType, int_T* sigComplexity, void** sigDataAddr, boolean_T* sigCrossMdlRef, int_T* sigIdx, boolean_T crossingModel, boolean_T rtwLogging) { int_T i; int_T nCMMI; int_T nSignals; const char_T* mmiPath; size_t mmiPathLen; const rtwCAPI_Signals* signals; const rtwCAPI_DimensionMap* dimMap; const uint_T* dimArray; const rtwCAPI_DataTypeMap* dataTypeMap; void** dataAddrMap; const char_T* errstr = NULL; uint8_T isPointer = 0; char* blockPath = NULL; if (mmi == NULL) goto EXIT_POINT; nCMMI = rtwCAPI_GetChildMMIArrayLen(mmi); for (i = 0; i < nCMMI; ++i) { rtwCAPI_ModelMappingInfo* cMMI = rtwCAPI_GetChildMMI(mmi,i); errstr = rtwCAPI_GetSigLogRecordInfo(cMMI, sigBlockName, sigLabel, sigWidth, sigDataType, logDataType, sigComplexity, sigDataAddr, sigCrossMdlRef, sigIdx, true, rtwLogging); if (errstr != NULL) goto EXIT_POINT; } nSignals = rtwCAPI_GetNumSignals(mmi); if (nSignals < 1) goto EXIT_POINT; mmiPath = rtwCAPI_GetFullPath(mmi); mmiPathLen = (mmiPath==NULL)? 0 : strlen(mmiPath); signals = rtwCAPI_GetSignals(mmi); dimMap = rtwCAPI_GetDimensionMap(mmi); dimArray = rtwCAPI_GetDimensionArray(mmi); dataTypeMap = rtwCAPI_GetDataTypeMap(mmi); dataAddrMap = rtwCAPI_GetDataAddressMap(mmi); for (i = 0; i < nSignals; ++i) { uint_T mapIdx; size_t sigPathLen; char* sigPath; /* For RTW logging, skip states that cannot be logged to MAT-File. */ if ((rtwLogging) && (rtwCAPI_CanLogSignalToMATFile(dataTypeMap, signals, i) == false)) continue; /* sigBlockPath = mmiPath + | + BlockPath + '\0' */ /* If crossing a model boundary encode, otherwise do not */ if (crossingModel) { blockPath = rtwCAPI_EncodePath(rtwCAPI_GetSignalBlockPath(signals, i)); if ( (blockPath == NULL) && (rtwCAPI_GetSignalBlockPath(signals, i) != NULL)) { errstr = rtwCAPI_mallocError; goto EXIT_POINT; } } else { const char* constBlockPath = rtwCAPI_GetSignalBlockPath(signals, i); blockPath = (char*)utMalloc((strlen(constBlockPath)+1)*sizeof(char)); (void)strcpy(blockPath, constBlockPath); } utAssert(blockPath != NULL); sigPathLen = ( (mmiPath==NULL) ? strlen(blockPath) + 1 : mmiPathLen + strlen(blockPath) + 2 ); sigPath = (char*)utMalloc(sigPathLen*sizeof(char)); if (sigPath == NULL) { errstr = rtwCAPI_mallocError; goto EXIT_POINT; } if (mmiPath != NULL) { (void)strcpy(sigPath, mmiPath); sigPath[mmiPathLen] = '|'; sigPath[mmiPathLen+1] = '\0'; (void)strcat(sigPath, blockPath); } else { (void)strcpy(sigPath, blockPath); sigPath[sigPathLen-1] = '\0'; } /* need to free for every iteration of the loop, but also have * the free below EXIT_POINT in case of error */ utFree(blockPath); blockPath = NULL; utAssert(sigPath[sigPathLen-1] == '\0'); sigBlockName[*sigIdx] = sigPath; /* caller is responsible for free */ /* Label */ sigLabel[*sigIdx] = rtwCAPI_GetSignalName(signals, i); /* Width */ mapIdx = rtwCAPI_GetSignalDimensionIdx(signals, i); utAssert( rtwCAPI_GetNumDims(dimMap,mapIdx) == 2 ); mapIdx = rtwCAPI_GetDimArrayIndex(dimMap, mapIdx); sigWidth[*sigIdx] = dimArray[mapIdx] * dimArray[mapIdx+1]; /* DataType and logDataType */ mapIdx = rtwCAPI_GetSignalDataTypeIdx(signals, i); sigDataType[*sigIdx] = rtwCAPI_GetDataTypeSLId(dataTypeMap, mapIdx); /* this mimics code in simulink.dll:mapSigDataTypeToLogDataType */ if ( SS_DOUBLE || SS_SINGLE || SS_INT8 || SS_UINT8 || SS_INT16 || SS_UINT16 || SS_INT32 || SS_UINT32 || SS_BOOLEAN ) { logDataType[*sigIdx] = sigDataType[*sigIdx]; } else { logDataType[*sigIdx] = SS_DOUBLE; } /* Complexity */ sigComplexity[*sigIdx] = rtwCAPI_GetDataIsComplex(dataTypeMap, mapIdx); /* Data Access - Pointer or Direct*/ isPointer = ((uint8_T)rtwCAPI_GetDataIsPointer(dataTypeMap, mapIdx)); /* Address */ mapIdx = rtwCAPI_GetSignalAddrIdx(signals, i); rtwCAPI_GetSigAddrFromMap(isPointer, sigComplexity, sigDataType, sigDataAddr, sigIdx, mapIdx, dataAddrMap); /* CrossingModelBoundary */ sigCrossMdlRef[*sigIdx] = crossingModel; ++(*sigIdx); } EXIT_POINT: utFree(blockPath); return(errstr); } /* rtwCAPI_GetSigLogRecordInfo */