/** Function: rtwCAPI_GetNumSigLogRecordsForRTWLogging ========================= * */ int_T rtwCAPI_GetNumSigLogRecordsForRTWLogging(const rtwCAPI_ModelMappingInfo* mmi) { int_T i; int_T nRecs = 0; int_T nSignals = 0; int_T nCMMI; const rtwCAPI_Signals *signals = NULL; const rtwCAPI_DataTypeMap* dataTypeMap; if (mmi == NULL) return(0); nSignals = rtwCAPI_GetNumSignals(mmi); signals = rtwCAPI_GetSignals(mmi); dataTypeMap = rtwCAPI_GetDataTypeMap(mmi); for (i = 0; i < nSignals; ++i) { if (rtwCAPI_CanLogSignalToMATFile(dataTypeMap, signals, i)) { ++nRecs; } } nCMMI = rtwCAPI_GetChildMMIArrayLen(mmi); for (i = 0; i < nCMMI; ++i) { const rtwCAPI_ModelMappingInfo* cMMI = rtwCAPI_GetChildMMI(mmi,i); nRecs += rtwCAPI_GetNumSigLogRecordsForRTWLogging(cMMI); } return(nRecs); } /* rtwCAPI_GetNumSigLogRecords */
int ZenomMatlab::Xrt_GetSignalInfo(rtwCAPI_ModelMappingInfo* mmi){ const rtwCAPI_Signals* signals; const rtwCAPI_DataTypeMap* dataTypeMap; const rtwCAPI_DimensionMap* dimMap; const uint_T* dimArray; void** dataAddrMap; void* paramAddress; uint_T sigIdx; uint_T nSignals; uint_T addrIdx; uint16_T dataTypeIdx; uint16_T dimIndex; uint16_T fxpMapIdx; uint8_T slDataID; unsigned short isComplex; uint8_T numDims; uint_T dimArrayIdx; rtwCAPI_Orientation orientation; uint_T actualDimensions[10]; uint_T numRows; uint_T numColumns; uint_T rowIdx; uint_T colIdx; const char_T* SigName; const char_T* blockName; const char_T* cDataName; nSignals = rtwCAPI_GetNumSignals(mmi); signals = rtwCAPI_GetSignals(mmi); dataTypeMap = rtwCAPI_GetDataTypeMap(mmi); for(sigIdx=0; sigIdx < nSignals; sigIdx++){ strncpyz(xtsi[sigIdx].blockName, rtwCAPI_GetSignalBlockPath(signals,sigIdx), MAX_NAMES_SIZE); strncpyz(xtsi[sigIdx].signalName, rtwCAPI_GetSignalName(signals,sigIdx), MAX_NAMES_SIZE); dataTypeIdx = rtwCAPI_GetSignalDataTypeIdx(signals, sigIdx); slDataID = rtwCAPI_GetDataTypeSLId(dataTypeMap, dataTypeIdx); xtsi[sigIdx].dataType = slDataID; cDataName = rtwCAPI_GetDataTypeCName(dataTypeMap, dataTypeIdx); xtsi[sigIdx].isComplex = rtwCAPI_GetDataIsComplex(dataTypeMap,dataTypeIdx); } //Get Dimension dimMap = rtwCAPI_GetDimensionMap(mmi); dimArray = rtwCAPI_GetDimensionArray(mmi); if ((dimMap == NULL) || (dimArray == NULL)) exit(EXIT_FAILURE); for(sigIdx=0; sigIdx < nSignals; sigIdx++){ dimIndex = rtwCAPI_GetBlockParameterDimensionIdx(signals, sigIdx); numDims = rtwCAPI_GetNumDims(dimMap, dimIndex); dimArrayIdx = rtwCAPI_GetDimArrayIndex(dimMap, dimIndex); orientation = rtwCAPI_GetOrientation(dimMap, dimIndex); xtsi[sigIdx].dataOrientation = orientation; for(int idx=0; idx < numDims; idx++) { actualDimensions[idx] = dimArray[dimArrayIdx + idx]; } xtsi[sigIdx].numRows = actualDimensions[0]; xtsi[sigIdx].numColumns = actualDimensions[1]; } for(sigIdx=0; sigIdx < nSignals; sigIdx++){ dataAddrMap = rtwCAPI_GetDataAddressMap(mmi); addrIdx = rtwCAPI_GetBlockParameterAddrIdx(signals, sigIdx); paramAddress= (void *) rtwCAPI_GetDataAddress(dataAddrMap, addrIdx); uint_T numPages = 0; if (numDims == 3) numPages = actualDimensions[2]; switch ( xtsi[sigIdx].dataType) { RT_GET_SIG_INFO_IF(SS_DOUBLE, real_T) RT_GET_SIG_INFO_IF(SS_SINGLE, real32_T) RT_GET_SIG_INFO_IF(SS_INT8, int8_T) RT_GET_SIG_INFO_IF(SS_UINT8, uint8_T) RT_GET_SIG_INFO_IF(SS_INT16, int16_T) RT_GET_SIG_INFO_IF(SS_UINT16, uint16_T) RT_GET_SIG_INFO_IF(SS_INT32, int32_T) RT_GET_SIG_INFO_IF(SS_UINT32, uint32_T) RT_GET_SIG_INFO_IF(SS_BOOLEAN, boolean_T) default: {return -1;} }//switch } return 0; }
/** * This function is called when the control program is loaded to zenom. * Use this function to register control parameters, to register log variables * and to initialize control parameters. * * @return Return non-zero to indicate an error. */ int ZenomMatlab::initialize() { int paramIdx, sigIdx; int nBlockParams, nSignals; const char* status; // İsmi gözükmeyen parametrelerin sayısını tutar. unknown_param_counter = 0; /* Here is where Q8 dirver is loaded to kernel space */ //system(STR(sudo insmod DQ8)); fd = rt_dev_open(DEV_NAME, O_RDWR); if(fd < 0) fprintf(stderr, "target:Q8 device open error!\n"); init_xenomai(); rtM = MODEL(); if (rtmGetErrorStatus(rtM) != NULL) { (void)fprintf(stderr,"Error during model registration: %s\n", rtmGetErrorStatus(rtM)); exit(EXIT_FAILURE); } MdlInitializeSizes(); MdlInitializeSampleTimes(); status = rt_SimInitTimingEngine(rtmGetNumSampleTimes(rtM), rtmGetStepSize(rtM), rtmGetSampleTimePtr(rtM), rtmGetOffsetTimePtr(rtM), rtmGetSampleHitPtr(rtM), rtmGetSampleTimeTaskIDPtr(rtM), rtmGetTStart(rtM), &rtmGetSimTimeStep(rtM), &rtmGetTimingData(rtM)); if (status != NULL) { (void)fprintf(stderr, "Failed to initialize sample time engine: %s\n", status); exit(EXIT_FAILURE); } rt_CreateIntegrationData(rtM); mmi = &(rtmGetDataMapInfo(rtM).mmi); if (mmi!=NULL){ //exception here } bp = rtwCAPI_GetBlockParameters(mmi); sig = rtwCAPI_GetSignals(mmi); nBlockParams = rtwCAPI_GetNumBlockParameters(mmi); nSignals = rtwCAPI_GetNumSignals(mmi); xrtpi = new XrtTargetParamInfo[nBlockParams]; xtsi = new XrtTargetSignalInfo[nSignals]; /** Get parameter and register */ Xrt_GetParameterInfo(mmi); Xrt_GetSignalInfo(mmi); /**************** ZENOM PART ***************/ for(paramIdx = 0; paramIdx < rtwCAPI_GetNumBlockParameters(mmi); paramIdx++){ std::string paramName(xrtpi[paramIdx].paramName); std::string blockName(xrtpi[paramIdx].blockName); if(paramName.empty()){ paramName = std::string("unknownBlock"); } for (std::size_t found = paramName.find_first_of(" "); found != std::string::npos ; found = paramName.find_first_of(" ")) { paramName.erase (found); } for (std::size_t found = blockName.find_first_of(" "); found != std::string::npos ; found = blockName.find_first_of(" ")) { blockName.erase (found); } paramName = blockName + "-" + paramName; registerControlVariable( xrtpi[paramIdx].dataValue, paramName, xrtpi[paramIdx].numRows, xrtpi[paramIdx].numColumns ); } for (sigIdx = 0; sigIdx < rtwCAPI_GetNumSignals(mmi); ++sigIdx){ std::string sigName(xtsi[sigIdx].signalName); if(sigName.empty()){ sigName = std::string("unknownSignal"); sigName += unknown_param_counter; } for (std::size_t found = sigName.find_first_of(" "); found != std::string::npos ; found = sigName.find_first_of(" ")) { sigName.erase (found); } registerLogVariable(xtsi[sigIdx].dataValue, sigName, xtsi[sigIdx].numRows, xtsi[sigIdx].numColumns); } setFrequency( (double)rtmGetStepSize(rtM) ); setDuration ( (double)rtmGetTFinal(rtM) ); fprintf(stderr, "init done!"); return 0; }
/** 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 */