/*
* ControlPID.c
*
* Real-Time Workshop code generation for Simulink model "ControlPID.mdl".
*
* Model Version : 1.4
* Real-Time Workshop version : 7.4 (R2009b) 29-Jun-2009
* C source code generated on : Tue Mar 09 20:28:17 2010
*
* Target selection: rsim.tlc
* Note: GRT includes extra infrastructure and instrumentation for prototyping
* Embedded hardware selection: 32-bit Generic
* Emulation hardware selection:
* Differs from embedded hardware (MATLAB Host)
* Code generation objectives: Unspecified
* Validation result: Not run
*/
#include <math.h>
#include "ControlPID.h"
#include "ControlPID_private.h"
#include "ControlPID_dt.h"
/* user code (top of parameter file) */
const int_T gblNumToFiles = 0;
const int_T gblNumFrFiles = 0;
const int_T gblNumFrWksBlocks = 0;
/* Root inports information */
const int_T gblNumRootInportBlks = 0;
const int_T gblNumModelInputs = 0;
extern rtInportTUtable *gblInportTUtables;
extern const char *gblInportFileName;
const int_T gblInportDataTypeIdx[] = { -1 };
const int_T gblInportDims[] = { -1 } ;
const int_T gblInportComplex[] = { -1 };
const int_T gblInportInterpoFlag[] = { -1 };
const int_T gblInportContinuous[] = { -1 };
#include "simstruc.h"
#include "fixedpoint.h"
/* Block signals (auto storage) */
BlockIO rtB;
/* Continuous states */
ContinuousStates rtX;
/* Block states (auto storage) */
D_Work rtDWork;
/* Parent Simstruct */
static SimStruct model_S;
SimStruct *const rtS = &model_S;
/* Initial conditions for root system: '<Root>' */
void MdlInitialize(void)
{
/* InitializeConditions for TransferFcn: '<Root>/Transfer Fcn' */
rtX.TransferFcn_CSTATE = 0.0;
/* InitializeConditions for DiscreteIntegrator: '<S1>/Filter' */
rtDWork.Filter_DSTATE = rtP.Filter_IC;
/* InitializeConditions for DiscreteIntegrator: '<S1>/Integrator' */
rtDWork.Integrator_DSTATE = rtP.Integrator_IC;
}
/* Start for root system: '<Root>' */
void MdlStart(void)
{
MdlInitialize();
}
/* Outputs for root system: '<Root>' */
void MdlOutputs(int_T tid)
{
/* local block i/o variables */
real_T rtb_TransferFcn;
{
real_T currentTime;
if (ssIsSampleHit(rtS, 1, 0)) {
/* Step: '<Root>/Step' */
currentTime = ssGetTaskTime(rtS,0);
if (ssIsMajorTimeStep(rtS)) {
if (currentTime >= rtP.Step_Time) {
rtDWork.Step_MODE = 1;
} else {
rtDWork.Step_MODE = 0;
}
}
rtB.Step = rtDWork.Step_MODE == 1 ? rtP.Step_YFinal : rtP.Step_Y0;
}
/* TransferFcn: '<Root>/Transfer Fcn' */
rtb_TransferFcn = rtP.TransferFcn_C*rtX.TransferFcn_CSTATE;
/* Sum: '<Root>/Sum' */
rtB.Sum = rtB.Step - rtb_TransferFcn;
if (ssIsSampleHit(rtS, 2, 0)) {
/* Gain: '<S1>/Filter Coefficient' incorporates:
* DiscreteIntegrator: '<S1>/Filter'
* Gain: '<S1>/Derivative Gain'
* Sum: '<S1>/SumD'
*/
rtB.FilterCoefficient = ((real_T)rtP.DerivativeGain_Gain * rtB.Sum -
rtDWork.Filter_DSTATE) * (real_T)rtP.FilterCoefficient_Gain;
/* Gain: '<S1>/Integral Gain' */
rtB.IntegralGain = (real_T)rtP.IntegralGain_Gain * rtB.Sum;
/* Sum: '<S1>/Sum' incorporates:
* DiscreteIntegrator: '<S1>/Integrator'
* Gain: '<S1>/Proportional Gain'
*/
rtB.Sum_e = ((real_T)rtP.ProportionalGain_Gain * rtB.Sum +
rtDWork.Integrator_DSTATE) + rtB.FilterCoefficient;
}
}
/* tid is required for a uniform function interface.
* Argument tid is not used in the function. */
UNUSED_PARAMETER(tid);
}
/* Update for root system: '<Root>' */
void MdlUpdate(int_T tid)
{
if (ssIsSampleHit(rtS, 2, 0)) {
/* Update for DiscreteIntegrator: '<S1>/Filter' */
rtDWork.Filter_DSTATE = rtP.Filter_gainval * rtB.FilterCoefficient +
rtDWork.Filter_DSTATE;
/* Update for DiscreteIntegrator: '<S1>/Integrator' */
rtDWork.Integrator_DSTATE = rtP.Integrator_gainval * rtB.IntegralGain +
rtDWork.Integrator_DSTATE;
}
/* tid is required for a uniform function interface.
* Argument tid is not used in the function. */
UNUSED_PARAMETER(tid);
}
/* Derivatives for root system: '<Root>' */
void MdlDerivatives(void)
{
/* Derivatives for TransferFcn: '<Root>/Transfer Fcn' */
{
((StateDerivatives *) ssGetdX(rtS))->TransferFcn_CSTATE = rtB.Sum_e;
((StateDerivatives *) ssGetdX(rtS))->TransferFcn_CSTATE +=
(rtP.TransferFcn_A)*rtX.TransferFcn_CSTATE;
}
}
/* Projection for root system: '<Root>' */
void MdlProjection(void)
{
}
/* InitSystemMatrices for root system: '<Root>' */
void MdlInitSystemMatrices(void)
{
}
/* ZeroCrossings for root system: '<Root>' */
void MdlZeroCrossings(void)
{
/* ZeroCrossings for Step: '<Root>/Step' */
((ZCSignalValues *) ssGetSolverZcSignalVector(rtS))->Step_StepTime_ZC = ssGetT
(rtS) - rtP.Step_Time;
}
/* Termination for root system: '<Root>' */
void MdlTerminate(void)
{
}
/* Function to initialize sizes */
void MdlInitializeSizes(void)
{
ssSetNumContStates(rtS, 1); /* Number of continuous states */
ssSetNumY(rtS, 0); /* Number of model outputs */
ssSetNumU(rtS, 0); /* Number of model inputs */
ssSetDirectFeedThrough(rtS, 0); /* The model is not direct feedthrough */
ssSetNumSampleTimes(rtS, 3); /* Number of sample times */
ssSetNumBlocks(rtS, 12); /* Number of blocks */
ssSetNumBlockIO(rtS, 5); /* Number of block outputs */
ssSetNumBlockParams(rtS, 13); /* Sum of parameter "widths" */
}
/* Function to initialize sample times. */
void MdlInitializeSampleTimes(void)
{
/* task periods */
ssSetSampleTime(rtS, 0, 0.0);
ssSetSampleTime(rtS, 1, 0.0);
ssSetSampleTime(rtS, 2, 0.01);
/* task offsets */
ssSetOffsetTime(rtS, 0, 0.0);
ssSetOffsetTime(rtS, 1, 1.0);
ssSetOffsetTime(rtS, 2, 0.0);
}
/* Function to register the model */
SimStruct * ControlPID(void)
{
static struct _ssMdlInfo mdlInfo;
sizeof(SimStruct));
(void) memset((char *)&mdlInfo
,0, sizeof(struct _ssMdlInfo));
ssSetMdlInfoPtr(rtS, &mdlInfo);
/* timing info */
{
static time_T mdlPeriod[NSAMPLE_TIMES];
static time_T mdlOffset[NSAMPLE_TIMES];
static time_T mdlTaskTimes[NSAMPLE_TIMES];
static int_T mdlTsMap[NSAMPLE_TIMES];
static int_T mdlSampleHits[NSAMPLE_TIMES];
static boolean_T mdlTNextWasAdjustedPtr[NSAMPLE_TIMES];
static int_T mdlPerTaskSampleHits[NSAMPLE_TIMES * NSAMPLE_TIMES];
static time_T mdlTimeOfNextSampleHit[NSAMPLE_TIMES];
{
int_T i;
for (i = 0; i < NSAMPLE_TIMES; i++) {
mdlPeriod[i] = 0.0;
mdlOffset[i] = 0.0;
mdlTaskTimes[i] = 0.0;
mdlTsMap[i] = i;
mdlSampleHits[i] = 1;
}
}
ssSetSampleTimePtr(rtS, &mdlPeriod[0]);
ssSetOffsetTimePtr(rtS, &mdlOffset[0]);
ssSetSampleTimeTaskIDPtr(rtS, &mdlTsMap[0]);
ssSetTPtr(rtS, &mdlTaskTimes[0]);
ssSetSampleHitPtr(rtS, &mdlSampleHits[0]);
ssSetTNextWasAdjustedPtr(rtS, &mdlTNextWasAdjustedPtr[0]);
ssSetPerTaskSampleHitsPtr(rtS, &mdlPerTaskSampleHits[0]);
ssSetTimeOfNextSampleHitPtr(rtS, &mdlTimeOfNextSampleHit[0]);
}
ssSetSolverMode(rtS, SOLVER_MODE_SINGLETASKING);
/*
* initialize model vectors and cache them in SimStruct
*/
/* block I/O */
{
ssSetBlockIO(rtS, ((void *) &rtB));
(void) memset(((void *) &rtB
),0, sizeof(BlockIO));
}
/* parameters */
ssSetDefaultParam(rtS, (real_T *) &rtP);
/* states (continuous)*/
{
real_T *x = (real_T *) &rtX;
ssSetContStates(rtS, x);
sizeof(ContinuousStates));
}
/* states (dwork) */
{
void *dwork = (void *) &rtDWork;
ssSetRootDWork(rtS, dwork);
sizeof(D_Work));
}
/* data type transition information */
{
static DataTypeTransInfo dtInfo;
(void) memset((char_T
*) &dtInfo
,0, sizeof(dtInfo));
ssSetModelMappingInfo(rtS, &dtInfo);
dtInfo.numDataTypes = 14;
dtInfo.dataTypeSizes = &rtDataTypeSizes[0];
dtInfo.dataTypeNames = &rtDataTypeNames[0];
/* Block I/O transition table */
dtInfo.B = &rtBTransTable;
/* Parameters transition table */
dtInfo.P = &rtPTransTable;
}
/* Model specific registration */
ssSetRootSS(rtS, rtS);
ssSetVersion(rtS, SIMSTRUCT_VERSION_LEVEL2);
ssSetModelName(rtS, "ControlPID");
ssSetPath(rtS, "ControlPID");
ssSetTStart(rtS, 0.0);
ssSetTFinal(rtS, 1.0);
/* Setup for data logging */
{
static RTWLogInfo rt_DataLoggingInfo;
ssSetRTWLogInfo(rtS, &rt_DataLoggingInfo);
}
/* Setup for data logging */
{
rtliSetLogXSignalInfo(ssGetRTWLogInfo(rtS), (NULL));
rtliSetLogXSignalPtrs(ssGetRTWLogInfo(rtS), (NULL));
rtliSetLogT(ssGetRTWLogInfo(rtS), "tout");
rtliSetLogX(ssGetRTWLogInfo(rtS), "");
rtliSetLogXFinal(ssGetRTWLogInfo(rtS), "");
rtliSetSigLog(ssGetRTWLogInfo(rtS), "");
rtliSetLogVarNameModifier(ssGetRTWLogInfo(rtS), "rt_");
rtliSetLogFormat(ssGetRTWLogInfo(rtS), 0);
rtliSetLogMaxRows(ssGetRTWLogInfo(rtS), 1000);
rtliSetLogDecimation(ssGetRTWLogInfo(rtS), 1);
rtliSetLogY(ssGetRTWLogInfo(rtS), "");
rtliSetLogYSignalInfo(ssGetRTWLogInfo(rtS), (NULL));
rtliSetLogYSignalPtrs(ssGetRTWLogInfo(rtS), (NULL));
}
{
static ssSolverInfo slvrInfo;
static boolean_T contStatesDisabled[1];
static real_T solverAbsTol[1] = { 1.0E-006 };
static boolean_T solverAutoAbsTol[1] = { 1 };
static uint8_T zcAttributes[1] = { (ZC_EVENT_ALL_UP) };
static ssNonContDerivSigInfo nonContDerivSigInfo[1] = {
{ 1*sizeof(real_T), (char*)(&rtB.Sum_e), (NULL) }
};
ssSetSolverRelTol(rtS, 0.001);
ssSetSolverAbsTol(rtS, solverAbsTol);
ssSetSolverAutoAbsTol(rtS, solverAutoAbsTol);
ssSetStepSize(rtS, 0.0);
ssSetMinStepSize(rtS, 0.0);
ssSetMaxNumMinSteps(rtS, -1);
ssSetMinStepViolatedError(rtS, 0);
ssSetMaxStepSize(rtS, 0.01);
ssSetSolverMaxOrder(rtS, -1);
ssSetSolverRefineFactor(rtS, 1);
ssSetOutputTimes(rtS, (NULL));
ssSetNumOutputTimes(rtS, 0);
ssSetOutputTimesOnly(rtS, 0);
ssSetOutputTimesIndex(rtS, 0);
ssSetZCCacheNeedsReset(rtS, 0);
ssSetDerivCacheNeedsReset(rtS, 0);
ssSetNumNonContDerivSigInfos(rtS, 1);
ssSetNonContDerivSigInfos(rtS, nonContDerivSigInfo);
ssSetSolverInfo(rtS, &slvrInfo);
ssSetSolverName(rtS, "ode45");
ssSetVariableStepSolver(rtS, 1);
ssSetSolverConsistencyChecking(rtS, 0);
ssSetSolverAdaptiveZcDetection(rtS, 0);
ssSetSolverRobustResetMethod(rtS, 0);
ssSetSolverStateProjection(rtS, 0);
ssSetSolverMassMatrixType(rtS, (ssMatrixType)0);
ssSetSolverMassMatrixNzMax(rtS, 0);
ssSetModelOutputs(rtS, MdlOutputs);
ssSetModelLogData(rtS, rt_UpdateTXYLogVars);
ssSetModelUpdate(rtS, MdlUpdate);
ssSetModelDerivatives(rtS, MdlDerivatives);
ssSetSolverZcSignalAttrib(rtS, zcAttributes);
ssSetSolverNumZcSignals(rtS, 1);
ssSetModelZeroCrossings(rtS, MdlZeroCrossings);
ssSetSolverConsecutiveZCsStepRelTol(rtS, 2.8421709430404007E-013);
ssSetSolverMaxConsecutiveZCs(rtS, 1000);
ssSetSolverConsecutiveZCsError(rtS, 2);
ssSetSolverMaxConsecutiveMinStep(rtS, 1);
ssSetSolverShapePreserveControl(rtS, 2);
ssSetTNextTid(rtS, INT_MIN);
ssSetTNext(rtS, rtMinusInf);
ssSetSolverNeedsReset(rtS);
ssSetNumNonsampledZCs(rtS, 1);
ssSetContStateDisabled(rtS, contStatesDisabled);
ssSetSolverMaxConsecutiveMinStep(rtS, 1);
}
ssSetChecksumVal(rtS, 0, 159084874U);
ssSetChecksumVal(rtS, 1, 215820345U);
ssSetChecksumVal(rtS, 2, 994859013U);
ssSetChecksumVal(rtS, 3, 1666355192U);
return rtS;
}
