/** 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 */
/** Function: rtwCAPI_GetNumSigLogRecords ======================================
*
*/
int_T rtwCAPI_GetNumSigLogRecords(const rtwCAPI_ModelMappingInfo* mmi)
{
int_T i;
int_T nRecs;
int_T nCMMI;
if (mmi == NULL) return(0);
nRecs = rtwCAPI_GetNumSignals(mmi);
nCMMI = rtwCAPI_GetChildMMIArrayLen(mmi);
for (i = 0; i < nCMMI; ++i) {
const rtwCAPI_ModelMappingInfo* cMMI = rtwCAPI_GetChildMMI(mmi,i);
nRecs += rtwCAPI_GetNumSigLogRecords(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 */
