pt_print.c

simulink real-time workshop for dragon12 development board from

      /* print each instance to standard output */
      for(paramIdx = 0; paramIdx < nParams; paramIdx++) {
          int16_T *param = (int16_T *)(pMap[mapOffset + paramIdx]);
          
          switch( ptinfoGetClass(ptRec) ) {
            case rt_SCALAR:
              printf("Scalar (instance %d):\n", paramIdx);
              printf("\t%hi\n", (int_T)*param);
              break;
              
            case rt_VECTOR:
              printf("Column Vector[%d] (instance %d):\n", nCols, paramIdx);
              for(colIdx = 0; colIdx < nCols; colIdx++) {
                  printf("\t%d: %hi\n", colIdx, (int_T)param[colIdx]);
              }
              break;
              
            case rt_MATRIX_ROW_MAJOR:
              printf("Matrix[%d][%d] (row major, instance %d):\n", nRows, nCols, paramIdx);
              for(rowIdx = 0; rowIdx < nRows; rowIdx++) {
                  printf("\trow %d:", rowIdx);
                  for(colIdx = 0; colIdx < nCols; colIdx++) {
                      printf("\t%hi", (int_T)param[rowIdx*nCols + colIdx]);
                  }
                  putchar('\n');
              }
              break;
              
            case rt_MATRIX_COL_MAJOR:
              printf("Matrix[%d][%d] (column major, instance %d):\n", nRows, nCols, paramIdx);
              for(rowIdx = 0; rowIdx < nRows; rowIdx++) {
                  printf("\trow %d:", rowIdx);
                  for(colIdx = 0; colIdx < nCols; colIdx++) {
                      printf("\t%hi", (int_T)param[colIdx*nRows + rowIdx]);
                  }
                  putchar('\n');
              }
              break;
              
            default:
              return(1);
          }
          /* set the parameter to itself (to test rt_ModifyParameter) */
          if(rt_ModifyParameter(mpi, ptRec, (void *)param)) {
              fprintf(stderr, "Problem with rt_ModifyParameter\n");
              return(1);
          }
      }
      break;
    case SS_UINT16:
      /* print each instance to standard output */
      for(paramIdx = 0; paramIdx < nParams; paramIdx++) {
          uint16_T *param = (uint16_T *)(pMap[mapOffset + paramIdx]);
          
          switch( ptinfoGetClass(ptRec) ) {
            case rt_SCALAR:
              printf("Scalar (instance %d):\n", paramIdx);
              printf("\t%hu\n", (int_T)*param);
              break;
              
            case rt_VECTOR:
              printf("Column Vector[%d] (instance %d):\n", nCols, paramIdx);
              for(colIdx = 0; colIdx < nCols; colIdx++) {
                  printf("\t%d: %hu\n", colIdx, (int_T)param[colIdx]);
              }
              break;
              
            case rt_MATRIX_ROW_MAJOR:
              printf("Matrix[%d][%d] (row major, instance %d):\n", nRows, nCols, paramIdx);
              for(rowIdx = 0; rowIdx < nRows; rowIdx++) {
                  printf("\trow %d:", rowIdx);
                  for(colIdx = 0; colIdx < nCols; colIdx++) {
                      printf("\t%hu", (int_T)param[rowIdx*nCols + colIdx]);
                  }
                  putchar('\n');
              }
              break;
              
            case rt_MATRIX_COL_MAJOR:
              printf("Matrix[%d][%d] (column major, instance %d):\n", nRows, nCols, paramIdx);
              for(rowIdx = 0; rowIdx < nRows; rowIdx++) {
                  printf("\trow %d:", rowIdx);
                  for(colIdx = 0; colIdx < nCols; colIdx++) {
                      printf("\t%hu", (int_T)param[colIdx*nRows + rowIdx]);
                  }
                  putchar('\n');
              }
              break;
              
            default:
              return(1);
          }
          /* set the parameter to itself (to test rt_ModifyParameter) */
          if(rt_ModifyParameter(mpi, ptRec, (void *)param)) {
              fprintf(stderr, "Problem with rt_ModifyParameter\n");
              return(1);
          }
      }
      break;
    case SS_INT32:
      /* print each instance to standard output */
      for(paramIdx = 0; paramIdx < nParams; paramIdx++) {
          int32_T *param = (int32_T *)(pMap[mapOffset + paramIdx]);
          
          switch( ptinfoGetClass(ptRec) ) {
            case rt_SCALAR:
              printf("Scalar (instance %d):\n", paramIdx);
              printf("\t%i\n", *param);
              break;
              
            case rt_VECTOR:
              printf("Column Vector[%d] (instance %d):\n", nCols, paramIdx);
              for(colIdx = 0; colIdx < nCols; colIdx++) {
                  printf("\t%d: %i\n", colIdx, param[colIdx]);
              }
              break;
              
            case rt_MATRIX_ROW_MAJOR:
              printf("Matrix[%d][%d] (row major, instance %d):\n", nRows, nCols, paramIdx);
              for(rowIdx = 0; rowIdx < nRows; rowIdx++) {
                  printf("\trow %d:", rowIdx);
                  for(colIdx = 0; colIdx < nCols; colIdx++) {
                      printf("\t%i", param[rowIdx*nCols + colIdx]);
                  }
                  putchar('\n');
              }
              break;
              
            case rt_MATRIX_COL_MAJOR:
              printf("Matrix[%d][%d] (column major, instance %d):\n", nRows, nCols, paramIdx);
              for(rowIdx = 0; rowIdx < nRows; rowIdx++) {
                  printf("\trow %d:", rowIdx);
                  for(colIdx = 0; colIdx < nCols; colIdx++) {
                      printf("\t%i", param[colIdx*nRows + rowIdx]);
                  }
                  putchar('\n');
              }
              break;
              
            default:
              return(1);
          }
          /* set the parameter to itself (to test rt_ModifyParameter) */
          if(rt_ModifyParameter(mpi, ptRec, (void *)param)) {
              fprintf(stderr, "Problem with rt_ModifyParameter\n");
              return(1);
          }
      }
      break;
    case SS_UINT32:
      /* print each instance to standard output */
      for(paramIdx = 0; paramIdx < nParams; paramIdx++) {
          uint32_T *param = (uint32_T *)(pMap[mapOffset + paramIdx]);
          
          switch( ptinfoGetClass(ptRec) ) {
            case rt_SCALAR:
              printf("Scalar (instance %d):\n", paramIdx);
              printf("\t%u\n", *param);
              break;
              
            case rt_VECTOR:
              printf("Column Vector[%d] (instance %d):\n", nCols, paramIdx);
              for(colIdx = 0; colIdx < nCols; colIdx++) {
                  printf("\t%d: %u\n", colIdx, param[colIdx]);
              }
              break;
              
            case rt_MATRIX_ROW_MAJOR:
              printf("Matrix[%d][%d] (row major, instance %d):\n", nRows, nCols, paramIdx);
              for(rowIdx = 0; rowIdx < nRows; rowIdx++) {
                  printf("\trow %d:", rowIdx);
                  for(colIdx = 0; colIdx < nCols; colIdx++) {
                      printf("\t%u", param[rowIdx*nCols + colIdx]);
                  }
                  putchar('\n');
              }
              break;
              
            case rt_MATRIX_COL_MAJOR:
              printf("Matrix[%d][%d] (column major, instance %d):\n", nRows, nCols, paramIdx);
              for(rowIdx = 0; rowIdx < nRows; rowIdx++) {
                  printf("\trow %d:", rowIdx);
                  for(colIdx = 0; colIdx < nCols; colIdx++) {
                      printf("\t%u", param[colIdx*nRows + rowIdx]);
                  }
                  putchar('\n');
              }
              break;
              
            default:
              return(1);
          }
          /* set the parameter to itself (to test rt_ModifyParameter) */
          if(rt_ModifyParameter(mpi, ptRec, (void *)param)) {
              fprintf(stderr, "Problem with rt_ModifyParameter\n");
              return(1);
          }
      }
      break;
    case SS_BOOLEAN:
      /* print each instance to standard output */
      for(paramIdx = 0; paramIdx < nParams; paramIdx++) {
          boolean_T *param = (boolean_T *)(pMap[mapOffset + paramIdx]);
          
          switch( ptinfoGetClass(ptRec) ) {
            case rt_SCALAR:
              printf("Scalar (instance %d):\n", paramIdx);
              printf("\t%hu\n", (int_T)*param);
              break;
              
            case rt_VECTOR:
              printf("Column Vector[%d] (instance %d):\n", nCols, paramIdx);
              for(colIdx = 0; colIdx < nCols; colIdx++) {
                  printf("\t%d: %hu\n", colIdx, (int_T)param[colIdx]);
              }
              break;
              
            case rt_MATRIX_ROW_MAJOR:
              printf("Matrix[%d][%d] (row major, instance %d):\n", nRows, nCols, paramIdx);
              for(rowIdx = 0; rowIdx < nRows; rowIdx++) {
                  printf("\trow %d:", rowIdx);
                  for(colIdx = 0; colIdx < nCols; colIdx++) {
                      printf("\t%hu", (int_T)param[rowIdx*nCols + colIdx]);
                  }
                  putchar('\n');
              }
              break;
              
            case rt_MATRIX_COL_MAJOR:
              printf("Matrix[%d][%d] (column major, instance %d):\n", nRows, nCols, paramIdx);
              for(rowIdx = 0; rowIdx < nRows; rowIdx++) {
                  printf("\trow %d:", rowIdx);
                  for(colIdx = 0; colIdx < nCols; colIdx++) {
                      printf("\t%hu", (int_T)param[colIdx*nRows + rowIdx]);
                  }
                  putchar('\n');
              }
              break;
              
            default:
              return(1);
          }
          /* set the parameter to itself (to test rt_ModifyParameter) */
          if(rt_ModifyParameter(mpi, ptRec, (void *)param)) {
              fprintf(stderr, "Problem with rt_ModifyParameter\n");
              return(1);
          }
      }
      break;

    default:
      /* unknown data type */
      return(1);
  }
  return(0);
}

/* =============================================================================
 * Function:
 *   rt_PrintParamInfo
 *
 * Abstract:
 *   This function prints the tunable parameters to standard output.  For
 *   modifiable block parameters the printed information is
 *
 *       o block name
 *       o parameter name
 *       o parameter type
 *       o value
 *
 *   For the modifiable variables the information is
 *
 *       o variable name
 *       o parameter type
 *       o value of each instance
 */
 
void rt_PrintParamInfo(void *mpi)
{
    uint_T i;
    
    ModelMappingInfo *mmi  = (ModelMappingInfo *)mpi;
    
    uint_T nBlockParams = mmiGetNumBlockParams(mmi);
    uint_T nVarParams   = mmiGetNumVariableParams(mmi);
    
    /* block parameters */
    if (nBlockParams == 0) {
        printf("No block parameters in model.\n");
    } else {
        printf("Modifiable block parameters:\n\n");
        for (i = 0; i < nBlockParams; i++) {
            const char_T *bName = mmiGetBlockTuningBlockName(mmi,i);
            const char_T *pName = mmiGetBlockTuningParamName(mmi,i);
            printf("Block: %s\n", bName);
            printf("Parameter: %s\n", pName);
            if (rt_PrintPTRec(mpi, (ParameterTuning*)mmiGetBlockTuningParamInfo(mmi,i))) {
                fprintf(stderr, "Error printing parameter info: %s (%s)\n", bName,pName);
            }
            putchar('\n');
        }
    }
    
    /* variable parameters */
    if (nVarParams == 0) {
        printf("No tunable MATLAB variables in model\n");
    } else {
        printf("Modifiable variables:\n\n");
        for (i = 0; i < nVarParams; i++) {
            const char_T *varName = mmiGetVariableTuningVarName(mmi,i);
            printf("Variable: %s\n", varName);
            if (rt_PrintPTRec(mpi, (ParameterTuning*)mmiGetVariableTuningVarInfo(mmi,i))) {
                fprintf(stderr, "Error printing variable info: %s\n",varName);
            }
            putchar('\n');
        }
    }

}

#endif  /* __PT_PRINT__ */