/*
 * WheelSpd1.h
 *
 * Academic License - for use in teaching, academic research, and meeting
 * course requirements at degree granting institutions only.  Not for
 * government, commercial, or other organizational use.
 *
 * Code generation for model "WheelSpd1".
 *
 * Model version              : 1.397
 * Simulink Coder version : 8.14 (R2018a) 06-Feb-2018
 * C source code generated on : Tue Jul 11 16:56:29 2023
 *
 * Target selection: slrt.tlc
 * Note: GRT includes extra infrastructure and instrumentation for prototyping
 * Embedded hardware selection: Generic->32-bit x86 compatible
 * Code generation objectives: Unspecified
 * Validation result: Not run
 */

#ifndef RTW_HEADER_WheelSpd1_h_
#define RTW_HEADER_WheelSpd1_h_
#include <math.h>
#include <stddef.h>
#include <string.h>
#include "rtw_modelmap.h"
#ifndef WheelSpd1_COMMON_INCLUDES_
# define WheelSpd1_COMMON_INCLUDES_
#include <string.h>
#include <xpcimports.h>
#include <xpcdatatypes.h>
#include "rtwtypes.h"
#include "zero_crossing_types.h"
#include "simstruc.h"
#include "fixedpoint.h"
#include "rt_logging.h"
#include "can_message.h"
#endif                                 /* WheelSpd1_COMMON_INCLUDES_ */

#include "WheelSpd1_types.h"

/* Shared type includes */
#include "multiword_types.h"
#include "rt_nonfinite.h"
#include "rt_defines.h"

/* Macros for accessing real-time model data structure */
#ifndef rtmGetBlockIO
# define rtmGetBlockIO(rtm)            ((rtm)->blockIO)
#endif

#ifndef rtmSetBlockIO
# define rtmSetBlockIO(rtm, val)       ((rtm)->blockIO = (val))
#endif

#ifndef rtmGetChecksums
# define rtmGetChecksums(rtm)          ((rtm)->Sizes.checksums)
#endif

#ifndef rtmSetChecksums
# define rtmSetChecksums(rtm, val)     ((rtm)->Sizes.checksums = (val))
#endif

#ifndef rtmGetConstBlockIO
# define rtmGetConstBlockIO(rtm)       ((rtm)->constBlockIO)
#endif

#ifndef rtmSetConstBlockIO
# define rtmSetConstBlockIO(rtm, val)  ((rtm)->constBlockIO = (val))
#endif

#ifndef rtmGetContStateDisabled
# define rtmGetContStateDisabled(rtm)  ((rtm)->contStateDisabled)
#endif

#ifndef rtmSetContStateDisabled
# define rtmSetContStateDisabled(rtm, val) ((rtm)->contStateDisabled = (val))
#endif

#ifndef rtmGetContStates
# define rtmGetContStates(rtm)         ((rtm)->contStates)
#endif

#ifndef rtmSetContStates
# define rtmSetContStates(rtm, val)    ((rtm)->contStates = (val))
#endif

#ifndef rtmGetContTimeOutputInconsistentWithStateAtMajorStepFlag
# define rtmGetContTimeOutputInconsistentWithStateAtMajorStepFlag(rtm) ((rtm)->CTOutputIncnstWithState)
#endif

#ifndef rtmSetContTimeOutputInconsistentWithStateAtMajorStepFlag
# define rtmSetContTimeOutputInconsistentWithStateAtMajorStepFlag(rtm, val) ((rtm)->CTOutputIncnstWithState = (val))
#endif

#ifndef rtmGetCtrlRateMdlRefTiming
# define rtmGetCtrlRateMdlRefTiming(rtm) ()
#endif

#ifndef rtmSetCtrlRateMdlRefTiming
# define rtmSetCtrlRateMdlRefTiming(rtm, val) ()
#endif

#ifndef rtmGetCtrlRateMdlRefTimingPtr
# define rtmGetCtrlRateMdlRefTimingPtr(rtm) ()
#endif

#ifndef rtmSetCtrlRateMdlRefTimingPtr
# define rtmSetCtrlRateMdlRefTimingPtr(rtm, val) ()
#endif

#ifndef rtmGetCtrlRateNumTicksToNextHit
# define rtmGetCtrlRateNumTicksToNextHit(rtm) ()
#endif

#ifndef rtmSetCtrlRateNumTicksToNextHit
# define rtmSetCtrlRateNumTicksToNextHit(rtm, val) ()
#endif

#ifndef rtmGetDataMapInfo
# define rtmGetDataMapInfo(rtm)        ((rtm)->DataMapInfo)
#endif

#ifndef rtmSetDataMapInfo
# define rtmSetDataMapInfo(rtm, val)   ((rtm)->DataMapInfo = (val))
#endif

#ifndef rtmGetDefaultParam
# define rtmGetDefaultParam(rtm)       ((rtm)->defaultParam)
#endif

#ifndef rtmSetDefaultParam
# define rtmSetDefaultParam(rtm, val)  ((rtm)->defaultParam = (val))
#endif

#ifndef rtmGetDerivCacheNeedsReset
# define rtmGetDerivCacheNeedsReset(rtm) ((rtm)->derivCacheNeedsReset)
#endif

#ifndef rtmSetDerivCacheNeedsReset
# define rtmSetDerivCacheNeedsReset(rtm, val) ((rtm)->derivCacheNeedsReset = (val))
#endif

#ifndef rtmGetDirectFeedThrough
# define rtmGetDirectFeedThrough(rtm)  ((rtm)->Sizes.sysDirFeedThru)
#endif

#ifndef rtmSetDirectFeedThrough
# define rtmSetDirectFeedThrough(rtm, val) ((rtm)->Sizes.sysDirFeedThru = (val))
#endif

#ifndef rtmGetErrorStatusFlag
# define rtmGetErrorStatusFlag(rtm)    ((rtm)->errorStatus)
#endif

#ifndef rtmSetErrorStatusFlag
# define rtmSetErrorStatusFlag(rtm, val) ((rtm)->errorStatus = (val))
#endif

#ifndef rtmGetFinalTime
# define rtmGetFinalTime(rtm)          ((rtm)->Timing.tFinal)
#endif

#ifndef rtmSetFinalTime
# define rtmSetFinalTime(rtm, val)     ((rtm)->Timing.tFinal = (val))
#endif

#ifndef rtmGetFirstInitCondFlag
# define rtmGetFirstInitCondFlag(rtm)  ()
#endif

#ifndef rtmSetFirstInitCondFlag
# define rtmSetFirstInitCondFlag(rtm, val) ()
#endif

#ifndef rtmGetIntgData
# define rtmGetIntgData(rtm)           ()
#endif

#ifndef rtmSetIntgData
# define rtmSetIntgData(rtm, val)      ()
#endif

#ifndef rtmGetMdlRefGlobalTID
# define rtmGetMdlRefGlobalTID(rtm)    ()
#endif

#ifndef rtmSetMdlRefGlobalTID
# define rtmSetMdlRefGlobalTID(rtm, val) ()
#endif

#ifndef rtmGetMdlRefTriggerTID
# define rtmGetMdlRefTriggerTID(rtm)   ()
#endif

#ifndef rtmSetMdlRefTriggerTID
# define rtmSetMdlRefTriggerTID(rtm, val) ()
#endif

#ifndef rtmGetModelMappingInfo
# define rtmGetModelMappingInfo(rtm)   ((rtm)->SpecialInfo.mappingInfo)
#endif

#ifndef rtmSetModelMappingInfo
# define rtmSetModelMappingInfo(rtm, val) ((rtm)->SpecialInfo.mappingInfo = (val))
#endif

#ifndef rtmGetModelName
# define rtmGetModelName(rtm)          ((rtm)->modelName)
#endif

#ifndef rtmSetModelName
# define rtmSetModelName(rtm, val)     ((rtm)->modelName = (val))
#endif

#ifndef rtmGetNonInlinedSFcns
# define rtmGetNonInlinedSFcns(rtm)    ((rtm)->NonInlinedSFcns)
#endif

#ifndef rtmSetNonInlinedSFcns
# define rtmSetNonInlinedSFcns(rtm, val) ((rtm)->NonInlinedSFcns = (val))
#endif

#ifndef rtmGetNumBlockIO
# define rtmGetNumBlockIO(rtm)         ((rtm)->Sizes.numBlockIO)
#endif

#ifndef rtmSetNumBlockIO
# define rtmSetNumBlockIO(rtm, val)    ((rtm)->Sizes.numBlockIO = (val))
#endif

#ifndef rtmGetNumBlockParams
# define rtmGetNumBlockParams(rtm)     ((rtm)->Sizes.numBlockPrms)
#endif

#ifndef rtmSetNumBlockParams
# define rtmSetNumBlockParams(rtm, val) ((rtm)->Sizes.numBlockPrms = (val))
#endif

#ifndef rtmGetNumBlocks
# define rtmGetNumBlocks(rtm)          ((rtm)->Sizes.numBlocks)
#endif

#ifndef rtmSetNumBlocks
# define rtmSetNumBlocks(rtm, val)     ((rtm)->Sizes.numBlocks = (val))
#endif

#ifndef rtmGetNumContStates
# define rtmGetNumContStates(rtm)      ((rtm)->Sizes.numContStates)
#endif

#ifndef rtmSetNumContStates
# define rtmSetNumContStates(rtm, val) ((rtm)->Sizes.numContStates = (val))
#endif

#ifndef rtmGetNumDWork
# define rtmGetNumDWork(rtm)           ((rtm)->Sizes.numDwork)
#endif

#ifndef rtmSetNumDWork
# define rtmSetNumDWork(rtm, val)      ((rtm)->Sizes.numDwork = (val))
#endif

#ifndef rtmGetNumInputPorts
# define rtmGetNumInputPorts(rtm)      ((rtm)->Sizes.numIports)
#endif

#ifndef rtmSetNumInputPorts
# define rtmSetNumInputPorts(rtm, val) ((rtm)->Sizes.numIports = (val))
#endif

#ifndef rtmGetNumNonSampledZCs
# define rtmGetNumNonSampledZCs(rtm)   ((rtm)->Sizes.numNonSampZCs)
#endif

#ifndef rtmSetNumNonSampledZCs
# define rtmSetNumNonSampledZCs(rtm, val) ((rtm)->Sizes.numNonSampZCs = (val))
#endif

#ifndef rtmGetNumOutputPorts
# define rtmGetNumOutputPorts(rtm)     ((rtm)->Sizes.numOports)
#endif

#ifndef rtmSetNumOutputPorts
# define rtmSetNumOutputPorts(rtm, val) ((rtm)->Sizes.numOports = (val))
#endif

#ifndef rtmGetNumPeriodicContStates
# define rtmGetNumPeriodicContStates(rtm) ((rtm)->Sizes.numPeriodicContStates)
#endif

#ifndef rtmSetNumPeriodicContStates
# define rtmSetNumPeriodicContStates(rtm, val) ((rtm)->Sizes.numPeriodicContStates = (val))
#endif

#ifndef rtmGetNumSFcnParams
# define rtmGetNumSFcnParams(rtm)      ((rtm)->Sizes.numSFcnPrms)
#endif

#ifndef rtmSetNumSFcnParams
# define rtmSetNumSFcnParams(rtm, val) ((rtm)->Sizes.numSFcnPrms = (val))
#endif

#ifndef rtmGetNumSFunctions
# define rtmGetNumSFunctions(rtm)      ((rtm)->Sizes.numSFcns)
#endif

#ifndef rtmSetNumSFunctions
# define rtmSetNumSFunctions(rtm, val) ((rtm)->Sizes.numSFcns = (val))
#endif

#ifndef rtmGetNumSampleTimes
# define rtmGetNumSampleTimes(rtm)     ((rtm)->Sizes.numSampTimes)
#endif

#ifndef rtmSetNumSampleTimes
# define rtmSetNumSampleTimes(rtm, val) ((rtm)->Sizes.numSampTimes = (val))
#endif

#ifndef rtmGetNumU
# define rtmGetNumU(rtm)               ((rtm)->Sizes.numU)
#endif

#ifndef rtmSetNumU
# define rtmSetNumU(rtm, val)          ((rtm)->Sizes.numU = (val))
#endif

#ifndef rtmGetNumY
# define rtmGetNumY(rtm)               ((rtm)->Sizes.numY)
#endif

#ifndef rtmSetNumY
# define rtmSetNumY(rtm, val)          ((rtm)->Sizes.numY = (val))
#endif

#ifndef rtmGetOdeF
# define rtmGetOdeF(rtm)               ()
#endif

#ifndef rtmSetOdeF
# define rtmSetOdeF(rtm, val)          ()
#endif

#ifndef rtmGetOdeY
# define rtmGetOdeY(rtm)               ()
#endif

#ifndef rtmSetOdeY
# define rtmSetOdeY(rtm, val)          ()
#endif

#ifndef rtmGetOffsetTimeArray
# define rtmGetOffsetTimeArray(rtm)    ((rtm)->Timing.offsetTimesArray)
#endif

#ifndef rtmSetOffsetTimeArray
# define rtmSetOffsetTimeArray(rtm, val) ((rtm)->Timing.offsetTimesArray = (val))
#endif

#ifndef rtmGetOffsetTimePtr
# define rtmGetOffsetTimePtr(rtm)      ((rtm)->Timing.offsetTimes)
#endif

#ifndef rtmSetOffsetTimePtr
# define rtmSetOffsetTimePtr(rtm, val) ((rtm)->Timing.offsetTimes = (val))
#endif

#ifndef rtmGetOptions
# define rtmGetOptions(rtm)            ((rtm)->Sizes.options)
#endif

#ifndef rtmSetOptions
# define rtmSetOptions(rtm, val)       ((rtm)->Sizes.options = (val))
#endif

#ifndef rtmGetParamIsMalloced
# define rtmGetParamIsMalloced(rtm)    ()
#endif

#ifndef rtmSetParamIsMalloced
# define rtmSetParamIsMalloced(rtm, val) ()
#endif

#ifndef rtmGetPath
# define rtmGetPath(rtm)               ((rtm)->path)
#endif

#ifndef rtmSetPath
# define rtmSetPath(rtm, val)          ((rtm)->path = (val))
#endif

#ifndef rtmGetPerTaskSampleHits
# define rtmGetPerTaskSampleHits(rtm)  ()
#endif

#ifndef rtmSetPerTaskSampleHits
# define rtmSetPerTaskSampleHits(rtm, val) ()
#endif

#ifndef rtmGetPerTaskSampleHitsArray
# define rtmGetPerTaskSampleHitsArray(rtm) ((rtm)->Timing.perTaskSampleHitsArray)
#endif

#ifndef rtmSetPerTaskSampleHitsArray
# define rtmSetPerTaskSampleHitsArray(rtm, val) ((rtm)->Timing.perTaskSampleHitsArray = (val))
#endif

#ifndef rtmGetPerTaskSampleHitsPtr
# define rtmGetPerTaskSampleHitsPtr(rtm) ((rtm)->Timing.perTaskSampleHits)
#endif

#ifndef rtmSetPerTaskSampleHitsPtr
# define rtmSetPerTaskSampleHitsPtr(rtm, val) ((rtm)->Timing.perTaskSampleHits = (val))
#endif

#ifndef rtmGetPeriodicContStateIndices
# define rtmGetPeriodicContStateIndices(rtm) ((rtm)->periodicContStateIndices)
#endif

#ifndef rtmSetPeriodicContStateIndices
# define rtmSetPeriodicContStateIndices(rtm, val) ((rtm)->periodicContStateIndices = (val))
#endif

#ifndef rtmGetPeriodicContStateRanges
# define rtmGetPeriodicContStateRanges(rtm) ((rtm)->periodicContStateRanges)
#endif

#ifndef rtmSetPeriodicContStateRanges
# define rtmSetPeriodicContStateRanges(rtm, val) ((rtm)->periodicContStateRanges = (val))
#endif

#ifndef rtmGetPrevZCSigState
# define rtmGetPrevZCSigState(rtm)     ((rtm)->prevZCSigState)
#endif

#ifndef rtmSetPrevZCSigState
# define rtmSetPrevZCSigState(rtm, val) ((rtm)->prevZCSigState = (val))
#endif

#ifndef rtmGetRTWExtModeInfo
# define rtmGetRTWExtModeInfo(rtm)     ((rtm)->extModeInfo)
#endif

#ifndef rtmSetRTWExtModeInfo
# define rtmSetRTWExtModeInfo(rtm, val) ((rtm)->extModeInfo = (val))
#endif

#ifndef rtmGetRTWGeneratedSFcn
# define rtmGetRTWGeneratedSFcn(rtm)   ((rtm)->Sizes.rtwGenSfcn)
#endif

#ifndef rtmSetRTWGeneratedSFcn
# define rtmSetRTWGeneratedSFcn(rtm, val) ((rtm)->Sizes.rtwGenSfcn = (val))
#endif

#ifndef rtmGetRTWLogInfo
# define rtmGetRTWLogInfo(rtm)         ((rtm)->rtwLogInfo)
#endif

#ifndef rtmSetRTWLogInfo
# define rtmSetRTWLogInfo(rtm, val)    ((rtm)->rtwLogInfo = (val))
#endif

#ifndef rtmGetRTWRTModelMethodsInfo
# define rtmGetRTWRTModelMethodsInfo(rtm) ()
#endif

#ifndef rtmSetRTWRTModelMethodsInfo
# define rtmSetRTWRTModelMethodsInfo(rtm, val) ()
#endif

#ifndef rtmGetRTWSfcnInfo
# define rtmGetRTWSfcnInfo(rtm)        ((rtm)->sfcnInfo)
#endif

#ifndef rtmSetRTWSfcnInfo
# define rtmSetRTWSfcnInfo(rtm, val)   ((rtm)->sfcnInfo = (val))
#endif

#ifndef rtmGetRTWSolverInfo
# define rtmGetRTWSolverInfo(rtm)      ((rtm)->solverInfo)
#endif

#ifndef rtmSetRTWSolverInfo
# define rtmSetRTWSolverInfo(rtm, val) ((rtm)->solverInfo = (val))
#endif

#ifndef rtmGetRTWSolverInfoPtr
# define rtmGetRTWSolverInfoPtr(rtm)   ((rtm)->solverInfoPtr)
#endif

#ifndef rtmSetRTWSolverInfoPtr
# define rtmSetRTWSolverInfoPtr(rtm, val) ((rtm)->solverInfoPtr = (val))
#endif

#ifndef rtmGetReservedForXPC
# define rtmGetReservedForXPC(rtm)     ((rtm)->SpecialInfo.xpcData)
#endif

#ifndef rtmSetReservedForXPC
# define rtmSetReservedForXPC(rtm, val) ((rtm)->SpecialInfo.xpcData = (val))
#endif

#ifndef rtmGetRootDWork
# define rtmGetRootDWork(rtm)          ((rtm)->dwork)
#endif

#ifndef rtmSetRootDWork
# define rtmSetRootDWork(rtm, val)     ((rtm)->dwork = (val))
#endif

#ifndef rtmGetSFunctions
# define rtmGetSFunctions(rtm)         ((rtm)->childSfunctions)
#endif

#ifndef rtmSetSFunctions
# define rtmSetSFunctions(rtm, val)    ((rtm)->childSfunctions = (val))
#endif

#ifndef rtmGetSampleHitArray
# define rtmGetSampleHitArray(rtm)     ((rtm)->Timing.sampleHitArray)
#endif

#ifndef rtmSetSampleHitArray
# define rtmSetSampleHitArray(rtm, val) ((rtm)->Timing.sampleHitArray = (val))
#endif

#ifndef rtmGetSampleHitPtr
# define rtmGetSampleHitPtr(rtm)       ((rtm)->Timing.sampleHits)
#endif

#ifndef rtmSetSampleHitPtr
# define rtmSetSampleHitPtr(rtm, val)  ((rtm)->Timing.sampleHits = (val))
#endif

#ifndef rtmGetSampleTimeArray
# define rtmGetSampleTimeArray(rtm)    ((rtm)->Timing.sampleTimesArray)
#endif

#ifndef rtmSetSampleTimeArray
# define rtmSetSampleTimeArray(rtm, val) ((rtm)->Timing.sampleTimesArray = (val))
#endif

#ifndef rtmGetSampleTimePtr
# define rtmGetSampleTimePtr(rtm)      ((rtm)->Timing.sampleTimes)
#endif

#ifndef rtmSetSampleTimePtr
# define rtmSetSampleTimePtr(rtm, val) ((rtm)->Timing.sampleTimes = (val))
#endif

#ifndef rtmGetSampleTimeTaskIDArray
# define rtmGetSampleTimeTaskIDArray(rtm) ((rtm)->Timing.sampleTimeTaskIDArray)
#endif

#ifndef rtmSetSampleTimeTaskIDArray
# define rtmSetSampleTimeTaskIDArray(rtm, val) ((rtm)->Timing.sampleTimeTaskIDArray = (val))
#endif

#ifndef rtmGetSampleTimeTaskIDPtr
# define rtmGetSampleTimeTaskIDPtr(rtm) ((rtm)->Timing.sampleTimeTaskIDPtr)
#endif

#ifndef rtmSetSampleTimeTaskIDPtr
# define rtmSetSampleTimeTaskIDPtr(rtm, val) ((rtm)->Timing.sampleTimeTaskIDPtr = (val))
#endif

#ifndef rtmGetSelf
# define rtmGetSelf(rtm)               ()
#endif

#ifndef rtmSetSelf
# define rtmSetSelf(rtm, val)          ()
#endif

#ifndef rtmGetSimMode
# define rtmGetSimMode(rtm)            ((rtm)->simMode)
#endif

#ifndef rtmSetSimMode
# define rtmSetSimMode(rtm, val)       ((rtm)->simMode = (val))
#endif

#ifndef rtmGetSimTimeStep
# define rtmGetSimTimeStep(rtm)        ((rtm)->Timing.simTimeStep)
#endif

#ifndef rtmSetSimTimeStep
# define rtmSetSimTimeStep(rtm, val)   ((rtm)->Timing.simTimeStep = (val))
#endif

#ifndef rtmGetStartTime
# define rtmGetStartTime(rtm)          ((rtm)->Timing.tStart)
#endif

#ifndef rtmSetStartTime
# define rtmSetStartTime(rtm, val)     ((rtm)->Timing.tStart = (val))
#endif

#ifndef rtmGetStepSize
# define rtmGetStepSize(rtm)           ((rtm)->Timing.stepSize)
#endif

#ifndef rtmSetStepSize
# define rtmSetStepSize(rtm, val)      ((rtm)->Timing.stepSize = (val))
#endif

#ifndef rtmGetStopRequestedFlag
# define rtmGetStopRequestedFlag(rtm)  ((rtm)->Timing.stopRequestedFlag)
#endif

#ifndef rtmSetStopRequestedFlag
# define rtmSetStopRequestedFlag(rtm, val) ((rtm)->Timing.stopRequestedFlag = (val))
#endif

#ifndef rtmGetTaskCounters
# define rtmGetTaskCounters(rtm)       ()
#endif

#ifndef rtmSetTaskCounters
# define rtmSetTaskCounters(rtm, val)  ()
#endif

#ifndef rtmGetTaskTimeArray
# define rtmGetTaskTimeArray(rtm)      ((rtm)->Timing.tArray)
#endif

#ifndef rtmSetTaskTimeArray
# define rtmSetTaskTimeArray(rtm, val) ((rtm)->Timing.tArray = (val))
#endif

#ifndef rtmGetTimePtr
# define rtmGetTimePtr(rtm)            ((rtm)->Timing.t)
#endif

#ifndef rtmSetTimePtr
# define rtmSetTimePtr(rtm, val)       ((rtm)->Timing.t = (val))
#endif

#ifndef rtmGetTimingData
# define rtmGetTimingData(rtm)         ((rtm)->Timing.timingData)
#endif

#ifndef rtmSetTimingData
# define rtmSetTimingData(rtm, val)    ((rtm)->Timing.timingData = (val))
#endif

#ifndef rtmGetU
# define rtmGetU(rtm)                  ((rtm)->inputs)
#endif

#ifndef rtmSetU
# define rtmSetU(rtm, val)             ((rtm)->inputs = (val))
#endif

#ifndef rtmGetVarNextHitTimesListPtr
# define rtmGetVarNextHitTimesListPtr(rtm) ((rtm)->Timing.varNextHitTimesList)
#endif

#ifndef rtmSetVarNextHitTimesListPtr
# define rtmSetVarNextHitTimesListPtr(rtm, val) ((rtm)->Timing.varNextHitTimesList = (val))
#endif

#ifndef rtmGetY
# define rtmGetY(rtm)                  ((rtm)->outputs)
#endif

#ifndef rtmSetY
# define rtmSetY(rtm, val)             ((rtm)->outputs = (val))
#endif

#ifndef rtmGetZCCacheNeedsReset
# define rtmGetZCCacheNeedsReset(rtm)  ((rtm)->zCCacheNeedsReset)
#endif

#ifndef rtmSetZCCacheNeedsReset
# define rtmSetZCCacheNeedsReset(rtm, val) ((rtm)->zCCacheNeedsReset = (val))
#endif

#ifndef rtmGetZCSignalValues
# define rtmGetZCSignalValues(rtm)     ((rtm)->zcSignalValues)
#endif

#ifndef rtmSetZCSignalValues
# define rtmSetZCSignalValues(rtm, val) ((rtm)->zcSignalValues = (val))
#endif

#ifndef rtmGet_TimeOfLastOutput
# define rtmGet_TimeOfLastOutput(rtm)  ((rtm)->Timing.timeOfLastOutput)
#endif

#ifndef rtmSet_TimeOfLastOutput
# define rtmSet_TimeOfLastOutput(rtm, val) ((rtm)->Timing.timeOfLastOutput = (val))
#endif

#ifndef rtmGetdX
# define rtmGetdX(rtm)                 ((rtm)->derivs)
#endif

#ifndef rtmSetdX
# define rtmSetdX(rtm, val)            ((rtm)->derivs = (val))
#endif

#ifndef rtmGettimingBridge
# define rtmGettimingBridge(rtm)       ()
#endif

#ifndef rtmSettimingBridge
# define rtmSettimingBridge(rtm, val)  ()
#endif

#ifndef rtmGetChecksumVal
# define rtmGetChecksumVal(rtm, idx)   ((rtm)->Sizes.checksums[idx])
#endif

#ifndef rtmSetChecksumVal
# define rtmSetChecksumVal(rtm, idx, val) ((rtm)->Sizes.checksums[idx] = (val))
#endif

#ifndef rtmGetDWork
# define rtmGetDWork(rtm, idx)         ((rtm)->dwork[idx])
#endif

#ifndef rtmSetDWork
# define rtmSetDWork(rtm, idx, val)    ((rtm)->dwork[idx] = (val))
#endif

#ifndef rtmGetOffsetTime
# define rtmGetOffsetTime(rtm, idx)    ((rtm)->Timing.offsetTimes[idx])
#endif

#ifndef rtmSetOffsetTime
# define rtmSetOffsetTime(rtm, idx, val) ((rtm)->Timing.offsetTimes[idx] = (val))
#endif

#ifndef rtmGetSFunction
# define rtmGetSFunction(rtm, idx)     ((rtm)->childSfunctions[idx])
#endif

#ifndef rtmSetSFunction
# define rtmSetSFunction(rtm, idx, val) ((rtm)->childSfunctions[idx] = (val))
#endif

#ifndef rtmGetSampleTime
# define rtmGetSampleTime(rtm, idx)    ((rtm)->Timing.sampleTimes[idx])
#endif

#ifndef rtmSetSampleTime
# define rtmSetSampleTime(rtm, idx, val) ((rtm)->Timing.sampleTimes[idx] = (val))
#endif

#ifndef rtmGetSampleTimeTaskID
# define rtmGetSampleTimeTaskID(rtm, idx) ((rtm)->Timing.sampleTimeTaskIDPtr[idx])
#endif

#ifndef rtmSetSampleTimeTaskID
# define rtmSetSampleTimeTaskID(rtm, idx, val) ((rtm)->Timing.sampleTimeTaskIDPtr[idx] = (val))
#endif

#ifndef rtmGetVarNextHitTimeList
# define rtmGetVarNextHitTimeList(rtm, idx) ((rtm)->Timing.varNextHitTimesList[idx])
#endif

#ifndef rtmSetVarNextHitTimeList
# define rtmSetVarNextHitTimeList(rtm, idx, val) ((rtm)->Timing.varNextHitTimesList[idx] = (val))
#endif

#ifndef rtmIsContinuousTask
# define rtmIsContinuousTask(rtm, tid) ((tid) == 0)
#endif

#ifndef rtmGetErrorStatus
# define rtmGetErrorStatus(rtm)        ((rtm)->errorStatus)
#endif

#ifndef rtmSetErrorStatus
# define rtmSetErrorStatus(rtm, val)   ((rtm)->errorStatus = (val))
#endif

#ifndef rtmIsMajorTimeStep
# define rtmIsMajorTimeStep(rtm)       (((rtm)->Timing.simTimeStep) == MAJOR_TIME_STEP)
#endif

#ifndef rtmIsMinorTimeStep
# define rtmIsMinorTimeStep(rtm)       (((rtm)->Timing.simTimeStep) == MINOR_TIME_STEP)
#endif

#ifndef rtmIsSampleHit
# define rtmIsSampleHit(rtm, sti, tid) ((rtmIsMajorTimeStep((rtm)) && (rtm)->Timing.sampleHits[(rtm)->Timing.sampleTimeTaskIDPtr[sti]]))
#endif

#ifndef rtmGetStopRequested
# define rtmGetStopRequested(rtm)      ((rtm)->Timing.stopRequestedFlag)
#endif

#ifndef rtmSetStopRequested
# define rtmSetStopRequested(rtm, val) ((rtm)->Timing.stopRequestedFlag = (val))
#endif

#ifndef rtmGetStopRequestedPtr
# define rtmGetStopRequestedPtr(rtm)   (&((rtm)->Timing.stopRequestedFlag))
#endif

#ifndef rtmGetT
# define rtmGetT(rtm)                  (rtmGetTPtr((rtm))[0])
#endif

#ifndef rtmSetT
# define rtmSetT(rtm, val)                                       /* Do Nothing */
#endif

#ifndef rtmGetTFinal
# define rtmGetTFinal(rtm)             ((rtm)->Timing.tFinal)
#endif

#ifndef rtmSetTFinal
# define rtmSetTFinal(rtm, val)        ((rtm)->Timing.tFinal = (val))
#endif

#ifndef rtmGetTPtr
# define rtmGetTPtr(rtm)               ((rtm)->Timing.t)
#endif

#ifndef rtmSetTPtr
# define rtmSetTPtr(rtm, val)          ((rtm)->Timing.t = (val))
#endif

#ifndef rtmGetTStart
# define rtmGetTStart(rtm)             ((rtm)->Timing.tStart)
#endif

#ifndef rtmSetTStart
# define rtmSetTStart(rtm, val)        ((rtm)->Timing.tStart = (val))
#endif

#ifndef rtmGetTaskTime
# define rtmGetTaskTime(rtm, sti)      (rtmGetTPtr((rtm))[(rtm)->Timing.sampleTimeTaskIDPtr[sti]])
#endif

#ifndef rtmSetTaskTime
# define rtmSetTaskTime(rtm, sti, val) (rtmGetTPtr((rtm))[sti] = (val))
#endif

#ifndef rtmGetTimeOfLastOutput
# define rtmGetTimeOfLastOutput(rtm)   ((rtm)->Timing.timeOfLastOutput)
#endif

#ifdef rtmGetRTWSolverInfo
#undef rtmGetRTWSolverInfo
#endif

#define rtmGetRTWSolverInfo(rtm)       &((rtm)->solverInfo)
#define rtModel_WheelSpd1              RT_MODEL_WheelSpd1_T

/* Definition for use in the target main file */
#define WheelSpd1_rtModel              RT_MODEL_WheelSpd1_T

/* user code (top of export header file) */
#include "can_message.h"
#include "xpcdatatypes.h"

/* Block signals (default storage) */
typedef struct {
  CAN_DATATYPE CANPack;                /* '<S5>/CAN Pack' */
  CAN_DATATYPE CANRead1_o2;            /* '<S1>/CAN Read1' */
  real_T ContMode;                     /* '<S4>/ContM' */
  real_T Ready;                        /* '<S5>/Constant' */
  real_T Gear;                         /* '<S5>/Constant1' */
  real_T BMS;                          /* '<S5>/Constant2' */
  real_T PosTQLim;                     /* '<S5>/Constant3' */
  real_T NegTQLim;                     /* '<S5>/Constant4' */
  real_T Clock1;                       /* '<S6>/Clock1' */
  real_T Product;                      /* '<S6>/Product' */
  real_T Gain;                         /* '<S6>/Gain' */
  real_T FromWs;                       /* '<S10>/FromWs' */
  real_T InputSine;                    /* '<S4>/InputSine' */
  real_T TargetSpd;                    /* '<S4>/Multiport Switch' */
  real_T d1;                           /* '<S9>/d1' */
  real_T Sum3;                         /* '<S9>/Sum3' */
  real_T gain;                         /* '<S9>/gain' */
  real_T gain2;                        /* '<S9>/gain2' */
  real_T Product2;                     /* '<S9>/Product2' */
  real_T gain1;                        /* '<S9>/gain1' */
  real_T Sum1;                         /* '<S9>/Sum1' */
  real_T d;                            /* '<S9>/d' */
  real_T Product11;                    /* '<S9>/Product11' */
  real_T Sum2;                         /* '<S9>/Sum2' */
  real_T Sum4;                         /* '<S9>/Sum4' */
  real_T Product1;                     /* '<S9>/Product1' */
  real_T Product2_c;                   /* '<S17>/Product2' */
  real_T d_a;                          /* '<S22>/d' */
  real_T Sum2_h;                       /* '<S22>/Sum2' */
  real_T gain_m;                       /* '<S22>/gain' */
  real_T d1_d;                         /* '<S22>/d1' */
  real_T Sum1_n;                       /* '<S22>/Sum1' */
  real_T Product1_f;                   /* '<S17>/Product1' */
  real_T d_b;                          /* '<S23>/d' */
  real_T Sum2_g;                       /* '<S23>/Sum2' */
  real_T gain_o;                       /* '<S23>/gain' */
  real_T d1_c;                         /* '<S23>/d1' */
  real_T Sum1_p;                       /* '<S23>/Sum1' */
  real_T Product_n;                    /* '<S17>/Product' */
  real_T d_bp;                         /* '<S24>/d' */
  real_T Sum2_k;                       /* '<S24>/Sum2' */
  real_T gain_d;                       /* '<S24>/gain' */
  real_T d1_f;                         /* '<S24>/d1' */
  real_T Sum1_k;                       /* '<S24>/Sum1' */
  real_T Add5;                         /* '<S17>/Add5' */
  real_T Gain_l;                       /* '<S17>/Gain' */
  real_T Delay1;                       /* '<S26>/Delay1' */
  real_T gain1_g;                      /* '<S26>/gain1' */
  real_T Delay;                        /* '<S26>/Delay' */
  real_T Sum3_d;                       /* '<S26>/Sum3' */
  real_T gain2_h;                      /* '<S26>/gain2' */
  real_T Product2_e;                   /* '<S26>/Product2' */
  real_T xnxn1xn2;                     /* '<S26>/x(n), x(n-1), x(n-2)' */
  real_T gain3;                        /* '<S26>/gain3' */
  real_T Sum4_c;                       /* '<S26>/Sum4' */
  real_T Delay2;                       /* '<S26>/Delay2' */
  real_T yn1;                          /* '<S26>/y(n-1)' */
  real_T Sum1_a;                       /* '<S26>/Sum1' */
  real_T Product3;                     /* '<S26>/Product3' */
  real_T gain4;                        /* '<S26>/gain4' */
  real_T Product4;                     /* '<S26>/Product4' */
  real_T Sum5;                         /* '<S26>/Sum5' */
  real_T Delay3;                       /* '<S26>/Delay3' */
  real_T yn2;                          /* '<S26>/y(n-2)' */
  real_T Sum2_c;                       /* '<S26>/Sum2' */
  real_T Sum6;                         /* '<S26>/Sum6' */
  real_T Product1_n;                   /* '<S26>/Product1' */
  real_T d1_b;                         /* '<S25>/d1' */
  real_T Sum3_c;                       /* '<S25>/Sum3' */
  real_T gain_e;                       /* '<S25>/gain' */
  real_T gain2_k;                      /* '<S25>/gain2' */
  real_T Product2_p;                   /* '<S25>/Product2' */
  real_T gain1_gt;                     /* '<S25>/gain1' */
  real_T Sum1_px;                      /* '<S25>/Sum1' */
  real_T d_i;                          /* '<S25>/d' */
  real_T Product11_e;                  /* '<S25>/Product11' */
  real_T Sum2_kk;                      /* '<S25>/Sum2' */
  real_T Sum4_l;                       /* '<S25>/Sum4' */
  real_T Product1_i;                   /* '<S25>/Product1' */
  real_T FFGain;                       /* '<S17>/FFGain' */
  real_T Error;                        /* '<S4>/Subtract' */
  real_T Gain_a;                       /* '<S18>/Gain' */
  real_T Kp;                           /* '<S18>/Kp' */
  real_T gain_mk;                      /* '<S19>/gain ' */
  real_T Kp_b;                         /* '<S19>/Kp' */
  real_T Ki;                           /* '<S19>/Ki' */
  real_T gain2_n;                      /* '<S20>/gain2' */
  real_T tau;                          /* '<S20>/Product2' */
  real_T utau;                         /* '<S20>/gain3' */
  real_T d1_cf;                        /* '<S21>/d1' */
  real_T Sum1_d;                       /* '<S21>/Sum1' */
  real_T gain_ds;                      /* '<S21>/gain' */
  real_T d_c;                          /* '<S21>/d' */
  real_T Sum2_l;                       /* '<S21>/Sum2' */
  real_T d1_p;                         /* '<S20>/d1' */
  real_T Sum3_g;                       /* '<S20>/Sum3' */
  real_T Product3_e;                   /* '<S20>/Product3' */
  real_T Sum1_i;                       /* '<S20>/Sum1' */
  real_T d_j;                          /* '<S20>/d' */
  real_T Product11_n;                  /* '<S20>/Product11' */
  real_T Sum2_j;                       /* '<S20>/Sum2' */
  real_T Sum4_a;                       /* '<S20>/Sum4' */
  real_T Product1_a;                   /* '<S20>/Product1' */
  real_T MultiportSwitch1;             /* '<S16>/Multiport Switch1' */
  real_T FBOut;                        /* '<S8>/FBGain' */
  real_T Add;                          /* '<S8>/Add' */
  real_T Memory;                       /* '<S4>/Memory' */
  real_T Product4_o;                   /* '<S7>/Product4' */
  real_T d_in;                         /* '<S11>/d' */
  real_T Sum2_hn;                      /* '<S11>/Sum2' */
  real_T gain_j;                       /* '<S11>/gain' */
  real_T d1_e;                         /* '<S11>/d1' */
  real_T Sum1_m;                       /* '<S11>/Sum1' */
  real_T Product3_f;                   /* '<S7>/Product3' */
  real_T d_n;                          /* '<S12>/d' */
  real_T Sum2_kl;                      /* '<S12>/Sum2' */
  real_T gain_g;                       /* '<S12>/gain' */
  real_T d1_bp;                        /* '<S12>/d1' */
  real_T Sum1_f;                       /* '<S12>/Sum1' */
  real_T Product2_l;                   /* '<S7>/Product2' */
  real_T d_cu;                         /* '<S13>/d' */
  real_T Sum2_a;                       /* '<S13>/Sum2' */
  real_T gain_gz;                      /* '<S13>/gain' */
  real_T d1_di;                        /* '<S13>/d1' */
  real_T Sum1_g;                       /* '<S13>/Sum1' */
  real_T Add2;                         /* '<S7>/Add2' */
  real_T Gain_c;                       /* '<S7>/Gain' */
  real_T Add3;                         /* '<S7>/Add3' */
  real_T d1_n;                         /* '<S14>/d1' */
  real_T Sum3_f;                       /* '<S14>/Sum3' */
  real_T gain_o3;                      /* '<S14>/gain' */
  real_T gain2_m;                      /* '<S14>/gain2' */
  real_T Product2_h;                   /* '<S14>/Product2' */
  real_T gain1_k;                      /* '<S14>/gain1' */
  real_T Sum1_e;                       /* '<S14>/Sum1' */
  real_T d_p;                          /* '<S14>/d' */
  real_T Product11_i;                  /* '<S14>/Product11' */
  real_T Sum2_b;                       /* '<S14>/Sum2' */
  real_T Sum4_k;                       /* '<S14>/Sum4' */
  real_T Product1_l;                   /* '<S14>/Product1' */
  real_T Delay1_n;                     /* '<S15>/Delay1' */
  real_T gain1_f;                      /* '<S15>/gain1' */
  real_T Delay_a;                      /* '<S15>/Delay' */
  real_T Sum3_a;                       /* '<S15>/Sum3' */
  real_T gain2_d;                      /* '<S15>/gain2' */
  real_T Product2_m;                   /* '<S15>/Product2' */
  real_T xnxn1xn2_a;                   /* '<S15>/x(n), x(n-1), x(n-2)' */
  real_T gain3_b;                      /* '<S15>/gain3' */
  real_T Sum4_kn;                      /* '<S15>/Sum4' */
  real_T Delay2_n;                     /* '<S15>/Delay2' */
  real_T yn1_m;                        /* '<S15>/y(n-1)' */
  real_T Sum1_ek;                      /* '<S15>/Sum1' */
  real_T Product3_i;                   /* '<S15>/Product3' */
  real_T gain4_g;                      /* '<S15>/gain4' */
  real_T Product4_i;                   /* '<S15>/Product4' */
  real_T Sum5_f;                       /* '<S15>/Sum5' */
  real_T Delay3_i;                     /* '<S15>/Delay3' */
  real_T yn2_g;                        /* '<S15>/y(n-2)' */
  real_T Sum2_m;                       /* '<S15>/Sum2' */
  real_T Sum6_g;                       /* '<S15>/Sum6' */
  real_T Product1_fm;                  /* '<S15>/Product1' */
  real_T Product_d;                    /* '<S4>/Product' */
  real_T Subtract2;                    /* '<S4>/Subtract2' */
  real_T ControlFlag;                  /* '<S4>/ControlFlag' */
  real_T ControlOutput;                /* '<S4>/Saturation' */
  real_T Constant1;                    /* '<S8>/Constant1' */
  real_T Constant16;                   /* '<S8>/Constant16' */
  real_T Constant17;                   /* '<S8>/Constant17' */
  real_T Constant2;                    /* '<S8>/Constant2' */
  real_T Product_k;                    /* '<S18>/Product' */
  real_T Divide2;                      /* '<S19>/Divide2' */
  real_T Divide1;                      /* '<S19>/Divide1' */
  real_T Add_k;                        /* '<S19>/Add' */
  real_T Product1_lf;                  /* '<S6>/Product1' */
  real_T Sum;                          /* '<S6>/Sum' */
  real_T Product2_g;                   /* '<S6>/Product2' */
  real_T Output;                       /* '<S6>/Output' */
  real_T Gain1;                        /* '<S4>/Gain1' */
  real_T Gain_d;                       /* '<S4>/Gain' */
  real_T RPM;                          /* '<S1>/CAN Unpack2' */
  real_T TQ;                           /* '<S1>/CAN Unpack2' */
  boolean_T CANRead1_o1;               /* '<S1>/CAN Read1' */
} B_WheelSpd1_T;

/* Block states (default storage) for system '<Root>' */
typedef struct {
  real_T d1_DSTATE;                    /* '<S9>/d1' */
  real_T d_DSTATE;                     /* '<S9>/d' */
  real_T d_DSTATE_a;                   /* '<S22>/d' */
  real_T d1_DSTATE_l;                  /* '<S22>/d1' */
  real_T d_DSTATE_i;                   /* '<S23>/d' */
  real_T d1_DSTATE_a;                  /* '<S23>/d1' */
  real_T d_DSTATE_ak;                  /* '<S24>/d' */
  real_T d1_DSTATE_f;                  /* '<S24>/d1' */
  real_T Delay1_DSTATE;                /* '<S26>/Delay1' */
  real_T Delay_DSTATE[2];              /* '<S26>/Delay' */
  real_T Delay2_DSTATE;                /* '<S26>/Delay2' */
  real_T Delay3_DSTATE[2];             /* '<S26>/Delay3' */
  real_T d1_DSTATE_b;                  /* '<S25>/d1' */
  real_T d_DSTATE_o;                   /* '<S25>/d' */
  real_T d1_DSTATE_g;                  /* '<S21>/d1' */
  real_T d_DSTATE_ir;                  /* '<S21>/d' */
  real_T d1_DSTATE_lw;                 /* '<S20>/d1' */
  real_T d_DSTATE_b;                   /* '<S20>/d' */
  real_T d_DSTATE_bw;                  /* '<S11>/d' */
  real_T d1_DSTATE_gc;                 /* '<S11>/d1' */
  real_T d_DSTATE_d;                   /* '<S12>/d' */
  real_T d1_DSTATE_l3;                 /* '<S12>/d1' */
  real_T d_DSTATE_g;                   /* '<S13>/d' */
  real_T d1_DSTATE_c;                  /* '<S13>/d1' */
  real_T d1_DSTATE_m;                  /* '<S14>/d1' */
  real_T d_DSTATE_h;                   /* '<S14>/d' */
  real_T Delay1_DSTATE_i;              /* '<S15>/Delay1' */
  real_T Delay_DSTATE_g[2];            /* '<S15>/Delay' */
  real_T Delay2_DSTATE_c;              /* '<S15>/Delay2' */
  real_T Delay3_DSTATE_o[2];           /* '<S15>/Delay3' */
  real_T Memory_PreviousInput;         /* '<S4>/Memory' */
  struct {
    void *TimePtr;
    void *DataPtr;
    void *RSimInfoPtr;
  } FromWs_PWORK;                      /* '<S10>/FromWs' */

  void *CANWrite1_PWORK;               /* '<S5>/CAN Write1' */
  struct {
    void *AQHandles;
    void *SlioLTF;
  } HiddenToAsyncQueue_InsertedFor_;   /* synthesized block */

  struct {
    void *AQHandles;
    void *SlioLTF;
  } HiddenToAsyncQueue_InsertedFo_c;   /* synthesized block */

  struct {
    void *AQHandles;
    void *SlioLTF;
  } HiddenToAsyncQueue_InsertedF_cg;   /* synthesized block */

  struct {
    void *AQHandles;
    void *SlioLTF;
  } HiddenToAsyncQueue_InsertedFo_k;   /* synthesized block */

  struct {
    void *AQHandles;
    void *SlioLTF;
  } HiddenToAsyncQueue_InsertedFo_g;   /* synthesized block */

  struct {
    void *AQHandles;
    void *SlioLTF;
  } HiddenToAsyncQueue_InsertedFo_d;   /* synthesized block */

  struct {
    void *AQHandles;
    void *SlioLTF;
  } HiddenToAsyncQueue_InsertedFo_j;   /* synthesized block */

  struct {
    void *AQHandles;
    void *SlioLTF;
  } HiddenToAsyncQueue_InsertedFo_b;   /* synthesized block */

  struct {
    void *AQHandles;
    void *SlioLTF;
  } HiddenToAsyncQueue_InsertedFo_i;   /* synthesized block */

  struct {
    void *AQHandles;
    void *SlioLTF;
  } HiddenToAsyncQueue_InsertedFo_e;   /* synthesized block */

  struct {
    void *AQHandles;
    void *SlioLTF;
  } HiddenToAsyncQueue_InsertedFo_h;   /* synthesized block */

  struct {
    void *AQHandles;
    void *SlioLTF;
  } HiddenToAsyncQueue_InsertedF_bl;   /* synthesized block */

  struct {
    void *AQHandles;
    void *SlioLTF;
  } HiddenToAsyncQueue_InsertedF_cb;   /* synthesized block */

  struct {
    void *AQHandles;
    void *SlioLTF;
  } HiddenToAsyncQueue_InsertedFo_l;   /* synthesized block */

  struct {
    void *AQHandles;
    void *SlioLTF;
  } HiddenToAsyncQueue_InsertedF_ga;   /* synthesized block */

  struct {
    void *AQHandles;
    void *SlioLTF;
  } HiddenToAsyncQueue_InsertedF_gg;   /* synthesized block */

  struct {
    int_T PrevIndex;
  } FromWs_IWORK;                      /* '<S10>/FromWs' */

  int_T CANPack_ModeSignalID;          /* '<S5>/CAN Pack' */
  int_T CANWrite1_IWORK;               /* '<S5>/CAN Write1' */
  int_T CANSetup_IWORK;                /* '<S1>/CAN Setup' */
  int_T CANRead1_IWORK;                /* '<S1>/CAN Read1' */
  int_T CANUnpack2_ModeSignalID;       /* '<S1>/CAN Unpack2' */
  int_T CANUnpack2_StatusPortID;       /* '<S1>/CAN Unpack2' */
} DW_WheelSpd1_T;

/* Backward compatible GRT Identifiers */
#define rtB                            WheelSpd1_B
#define BlockIO                        B_WheelSpd1_T
#define rtP                            WheelSpd1_P
#define Parameters                     P_WheelSpd1_T
#define rtDWork                        WheelSpd1_DW
#define D_Work                         DW_WheelSpd1_T

/* Parameters (default storage) */
struct P_WheelSpd1_T_ {
  real_T K;                            /* Variable: K
                                        * Referenced by:
                                        *   '<S7>/Gain'
                                        *   '<S8>/Constant2'
                                        *   '<S17>/Gain'
                                        */
  real_T P;                            /* Variable: P
                                        * Referenced by:
                                        *   '<S7>/Constant3'
                                        *   '<S7>/Constant4'
                                        *   '<S7>/Constant5'
                                        *   '<S8>/Constant16'
                                        *   '<S17>/Constant3'
                                        *   '<S17>/Constant4'
                                        *   '<S17>/Constant5'
                                        */
  real_T Ts;                           /* Variable: Ts
                                        * Referenced by:
                                        *   '<S9>/Constant'
                                        *   '<S9>/gain'
                                        *   '<S11>/gain'
                                        *   '<S12>/gain'
                                        *   '<S13>/gain'
                                        *   '<S14>/Constant'
                                        *   '<S14>/gain'
                                        *   '<S15>/Constant'
                                        *   '<S22>/gain'
                                        *   '<S23>/gain'
                                        *   '<S24>/gain'
                                        *   '<S25>/Constant'
                                        *   '<S25>/gain'
                                        *   '<S26>/Constant'
                                        *   '<S20>/Constant'
                                        *   '<S20>/Constant2'
                                        *   '<S21>/gain'
                                        */
  real_T Wn;                           /* Variable: Wn
                                        * Referenced by:
                                        *   '<S7>/Constant3'
                                        *   '<S7>/Constant4'
                                        *   '<S8>/Constant1'
                                        *   '<S17>/Constant3'
                                        *   '<S17>/Constant4'
                                        */
  real_T jeta;                         /* Variable: jeta
                                        * Referenced by:
                                        *   '<S7>/Constant3'
                                        *   '<S7>/Constant4'
                                        *   '<S8>/Constant17'
                                        *   '<S17>/Constant3'
                                        *   '<S17>/Constant4'
                                        */
  real_T ChirpSignal_T;                /* Mask Parameter: ChirpSignal_T
                                        * Referenced by: '<S6>/targetTime'
                                        */
  real_T ChirpSignal_f1;               /* Mask Parameter: ChirpSignal_f1
                                        * Referenced by:
                                        *   '<S6>/deltaFreq'
                                        *   '<S6>/initialFreq'
                                        */
  real_T ChirpSignal_f2;               /* Mask Parameter: ChirpSignal_f2
                                        * Referenced by: '<S6>/deltaFreq'
                                        */
  real_T CANSetup_P1_Size[2];          /* Computed Parameter: CANSetup_P1_Size
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P1;                  /* Expression: id
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P2_Size[2];          /* Computed Parameter: CANSetup_P2_Size
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P2[2];               /* Computed Parameter: CANSetup_P2
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P3_Size[2];          /* Computed Parameter: CANSetup_P3_Size
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P3;                  /* Expression: PCISlot
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P4_Size[2];          /* Computed Parameter: CANSetup_P4_Size
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P4;                  /* Expression: port1
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P5_Size[2];          /* Computed Parameter: CANSetup_P5_Size
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P5;                  /* Expression: port2
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P6_Size[2];          /* Computed Parameter: CANSetup_P6_Size
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P6;                  /* Expression: opModeCAN1
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P7_Size[2];          /* Computed Parameter: CANSetup_P7_Size
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P7[4];               /* Expression: usrBdrCAN1
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P8_Size[2];          /* Computed Parameter: CANSetup_P8_Size
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P8[6];               /* Expression: usrBdrFD1
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P9_Size[2];          /* Computed Parameter: CANSetup_P9_Size
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P9[2];               /* Expression: stdAccMaskCAN1
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P10_Size[2];         /* Computed Parameter: CANSetup_P10_Size
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P10[2];              /* Expression: extAccMaskCAN1
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P11_Size[2];         /* Computed Parameter: CANSetup_P11_Size
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P11;                 /* Expression: opModeCAN2
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P12_Size[2];         /* Computed Parameter: CANSetup_P12_Size
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P12[4];              /* Expression: usrBdrCAN2
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P13_Size[2];         /* Computed Parameter: CANSetup_P13_Size
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P13[6];              /* Expression: usrBdrFD2
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P14_Size[2];         /* Computed Parameter: CANSetup_P14_Size
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P14[2];              /* Expression: stdAccMaskCAN2
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P15_Size[2];         /* Computed Parameter: CANSetup_P15_Size
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P15[2];              /* Expression: extAccMaskCAN2
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P16_Size[2];         /* Computed Parameter: CANSetup_P16_Size
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P16;                 /* Expression: initStruct
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P17_Size[2];         /* Computed Parameter: CANSetup_P17_Size
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P17;                 /* Expression: termStruct
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P18_Size[2];         /* Computed Parameter: CANSetup_P18_Size
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P18[5];              /* Computed Parameter: CANSetup_P18
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P19_Size[2];         /* Computed Parameter: CANSetup_P19_Size
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P19;                 /* Expression: qtyMod
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P20_Size[2];         /* Computed Parameter: CANSetup_P20_Size
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P20[2];              /* Expression: chNo
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P21_Size[2];         /* Computed Parameter: CANSetup_P21_Size
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P21[2];              /* Expression: ptTypes
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P22_Size[2];         /* Computed Parameter: CANSetup_P22_Size
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P22[2];              /* Expression: isProtlFD
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P23_Size[2];         /* Computed Parameter: CANSetup_P23_Size
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P23[2];              /* Expression: protlHelpIdx
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P24_Size[2];         /* Computed Parameter: CANSetup_P24_Size
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANSetup_P24;                 /* Expression: isFDMod
                                        * Referenced by: '<S1>/CAN Setup'
                                        */
  real_T CANRead1_P1_Size[2];          /* Computed Parameter: CANRead1_P1_Size
                                        * Referenced by: '<S1>/CAN Read1'
                                        */
  real_T CANRead1_P1;                  /* Expression: id
                                        * Referenced by: '<S1>/CAN Read1'
                                        */
  real_T CANRead1_P2_Size[2];          /* Computed Parameter: CANRead1_P2_Size
                                        * Referenced by: '<S1>/CAN Read1'
                                        */
  real_T CANRead1_P2;                  /* Expression: sampleTime
                                        * Referenced by: '<S1>/CAN Read1'
                                        */
  real_T CANRead1_P3_Size[2];          /* Computed Parameter: CANRead1_P3_Size
                                        * Referenced by: '<S1>/CAN Read1'
                                        */
  real_T CANRead1_P3;                  /* Expression: messageType
                                        * Referenced by: '<S1>/CAN Read1'
                                        */
  real_T CANRead1_P4_Size[2];          /* Computed Parameter: CANRead1_P4_Size
                                        * Referenced by: '<S1>/CAN Read1'
                                        */
  real_T CANRead1_P4[5];               /* Computed Parameter: CANRead1_P4
                                        * Referenced by: '<S1>/CAN Read1'
                                        */
  real_T CANRead1_P5_Size[2];          /* Computed Parameter: CANRead1_P5_Size
                                        * Referenced by: '<S1>/CAN Read1'
                                        */
  real_T CANRead1_P5;                  /* Expression: ptIdx
                                        * Referenced by: '<S1>/CAN Read1'
                                        */
  real_T CANRead1_P6_Size[2];          /* Computed Parameter: CANRead1_P6_Size
                                        * Referenced by: '<S1>/CAN Read1'
                                        */
  real_T CANRead1_P6;                  /* Expression: isFDMod
                                        * Referenced by: '<S1>/CAN Read1'
                                        */
  real_T Gain_Gain;                    /* Expression: 60
                                        * Referenced by: '<S4>/Gain'
                                        */
  real_T Gain1_Gain;                   /* Expression: 30
                                        * Referenced by: '<S4>/Gain1'
                                        */
  real_T ContMode_Value;               /* Expression: 1
                                        * Referenced by: '<S4>/ContMode'
                                        */
  real_T ContM_Gain;                   /* Expression: 0
                                        * Referenced by: '<S4>/ContM'
                                        */
  real_T Constant_Value;               /* Expression: 1
                                        * Referenced by: '<S5>/Constant'
                                        */
  real_T Constant1_Value;              /* Expression: 4
                                        * Referenced by: '<S5>/Constant1'
                                        */
  real_T Constant2_Value;              /* Expression: 0
                                        * Referenced by: '<S5>/Constant2'
                                        */
  real_T Constant3_Value;              /* Expression: 10
                                        * Referenced by: '<S5>/Constant3'
                                        */
  real_T Constant4_Value;              /* Expression: -10
                                        * Referenced by: '<S5>/Constant4'
                                        */
  real_T InputSelector_Value;          /* Expression: 3
                                        * Referenced by: '<S4>/InputSelector'
                                        */
  real_T Gain_Gain_a;                  /* Expression: 0.5
                                        * Referenced by: '<S6>/Gain'
                                        */
  real_T InputSine_Amp;                /* Expression: 1000
                                        * Referenced by: '<S4>/InputSine'
                                        */
  real_T InputSine_Bias;               /* Expression: 0
                                        * Referenced by: '<S4>/InputSine'
                                        */
  real_T InputSine_Freq;               /* Expression: 0.1*2*pi
                                        * Referenced by: '<S4>/InputSine'
                                        */
  real_T InputSine_Phase;              /* Expression: 0
                                        * Referenced by: '<S4>/InputSine'
                                        */
  real_T d1_InitialCondition;          /* Expression: 0
                                        * Referenced by: '<S9>/d1'
                                        */
  real_T Constant1_Value_n;            /* Expression: 1
                                        * Referenced by: '<S9>/Constant1'
                                        */
  real_T Constant1_Value_a;            /* Expression: 3
                                        * Referenced by: '<S4>/Constant1'
                                        */
  real_T gain2_Gain;                   /* Expression: 2*pi
                                        * Referenced by: '<S9>/gain2'
                                        */
  real_T gain1_Gain;                   /* Expression: 2
                                        * Referenced by: '<S9>/gain1'
                                        */
  real_T d_InitialCondition;           /* Expression: 0
                                        * Referenced by: '<S9>/d'
                                        */
  real_T d_InitialCondition_j;         /* Expression: 0
                                        * Referenced by: '<S22>/d'
                                        */
  real_T d1_InitialCondition_p;        /* Expression: 0
                                        * Referenced by: '<S22>/d1'
                                        */
  real_T d_InitialCondition_b;         /* Expression: 0
                                        * Referenced by: '<S23>/d'
                                        */
  real_T d1_InitialCondition_j;        /* Expression: 0
                                        * Referenced by: '<S23>/d1'
                                        */
  real_T d_InitialCondition_f;         /* Expression: 0
                                        * Referenced by: '<S24>/d'
                                        */
  real_T d1_InitialCondition_l;        /* Expression: 0
                                        * Referenced by: '<S24>/d1'
                                        */
  real_T Delay1_InitialCondition;      /* Expression: 0
                                        * Referenced by: '<S26>/Delay1'
                                        */
  real_T gain1_Gain_b;                 /* Expression: 2
                                        * Referenced by: '<S26>/gain1'
                                        */
  real_T Delay_InitialCondition;       /* Expression: 0
                                        * Referenced by: '<S26>/Delay'
                                        */
  real_T FF_CutoffFreq_Value;          /* Expression: 30
                                        * Referenced by: '<S8>/FF_CutoffFreq'
                                        */
  real_T gain2_Gain_p;                 /* Expression: 2*pi
                                        * Referenced by: '<S26>/gain2'
                                        */
  real_T gain3_Gain;                   /* Expression: 2
                                        * Referenced by: '<S26>/gain3'
                                        */
  real_T Constant1_Value_p;            /* Expression: 8
                                        * Referenced by: '<S26>/Constant1'
                                        */
  real_T Delay2_InitialCondition;      /* Expression: 0
                                        * Referenced by: '<S26>/Delay2'
                                        */
  real_T gain4_Gain;                   /* Expression: 4
                                        * Referenced by: '<S26>/gain4'
                                        */
  real_T zeta_Value;                   /* Expression: 0.707
                                        * Referenced by: '<S17>/zeta'
                                        */
  real_T Constant2_Value_f;            /* Expression: 4
                                        * Referenced by: '<S26>/Constant2'
                                        */
  real_T Delay3_InitialCondition;      /* Expression: 0
                                        * Referenced by: '<S26>/Delay3'
                                        */
  real_T d1_InitialCondition_e;        /* Expression: 0
                                        * Referenced by: '<S25>/d1'
                                        */
  real_T Constant1_Value_h;            /* Expression: 1
                                        * Referenced by: '<S25>/Constant1'
                                        */
  real_T Constant1_Value_i;            /* Expression: 30
                                        * Referenced by: '<S17>/Constant1'
                                        */
  real_T gain2_Gain_po;                /* Expression: 2*pi
                                        * Referenced by: '<S25>/gain2'
                                        */
  real_T gain1_Gain_f;                 /* Expression: 2
                                        * Referenced by: '<S25>/gain1'
                                        */
  real_T d_InitialCondition_o;         /* Expression: 0
                                        * Referenced by: '<S25>/d'
                                        */
  real_T FFGain_Gain;                  /* Expression: 1
                                        * Referenced by: '<S17>/FFGain'
                                        */
  real_T Selector_Value;               /* Expression: 1
                                        * Referenced by: '<S8>/Selector'
                                        */
  real_T BW_P_Value;                   /* Expression: 2.3
                                        * Referenced by: '<S8>/BW_P'
                                        */
  real_T Gain_Gain_n;                  /* Expression: 2*pi
                                        * Referenced by: '<S18>/Gain'
                                        */
  real_T BW_PI_Value;                  /* Expression: 15
                                        * Referenced by: '<S8>/BW_PI'
                                        */
  real_T gain_Gain;                    /* Expression: 2*pi
                                        * Referenced by: '<S19>/gain '
                                        */
  real_T Constant1_Value_l;            /* Expression: 1
                                        * Referenced by: '<S20>/Constant1'
                                        */
  real_T Constant_Value_d;             /* Expression: 0.05
                                        * Referenced by: '<S19>/Constant'
                                        */
  real_T gain2_Gain_c;                 /* Expression: 2*pi
                                        * Referenced by: '<S20>/gain2'
                                        */
  real_T gain3_Gain_o;                 /* Expression: 2
                                        * Referenced by: '<S20>/gain3'
                                        */
  real_T d1_InitialCondition_a;        /* Expression: 0
                                        * Referenced by: '<S21>/d1'
                                        */
  real_T d_InitialCondition_g;         /* Expression: 0
                                        * Referenced by: '<S21>/d'
                                        */
  real_T d1_InitialCondition_g;        /* Expression: 0
                                        * Referenced by: '<S20>/d1'
                                        */
  real_T d_InitialCondition_l;         /* Expression: 0
                                        * Referenced by: '<S20>/d'
                                        */
  real_T FBGain_Gain;                  /* Expression: 1
                                        * Referenced by: '<S8>/FBGain'
                                        */
  real_T Memory_InitialCondition;      /* Expression: 0
                                        * Referenced by: '<S4>/Memory'
                                        */
  real_T d_InitialCondition_k;         /* Expression: 0
                                        * Referenced by: '<S11>/d'
                                        */
  real_T d1_InitialCondition_e1;       /* Expression: 0
                                        * Referenced by: '<S11>/d1'
                                        */
  real_T d_InitialCondition_be;        /* Expression: 0
                                        * Referenced by: '<S12>/d'
                                        */
  real_T d1_InitialCondition_h;        /* Expression: 0
                                        * Referenced by: '<S12>/d1'
                                        */
  real_T d_InitialCondition_k0;        /* Expression: 0
                                        * Referenced by: '<S13>/d'
                                        */
  real_T d1_InitialCondition_d;        /* Expression: 0
                                        * Referenced by: '<S13>/d1'
                                        */
  real_T d1_InitialCondition_c;        /* Expression: 0
                                        * Referenced by: '<S14>/d1'
                                        */
  real_T Constant1_Value_id;           /* Expression: 1
                                        * Referenced by: '<S14>/Constant1'
                                        */
  real_T Pole_Value;                   /* Expression: 5
                                        * Referenced by: '<S4>/Pole'
                                        */
  real_T gain2_Gain_a;                 /* Expression: 2*pi
                                        * Referenced by: '<S14>/gain2'
                                        */
  real_T gain1_Gain_f2;                /* Expression: 2
                                        * Referenced by: '<S14>/gain1'
                                        */
  real_T d_InitialCondition_kh;        /* Expression: 0
                                        * Referenced by: '<S14>/d'
                                        */
  real_T Delay1_InitialCondition_c;    /* Expression: 0
                                        * Referenced by: '<S15>/Delay1'
                                        */
  real_T gain1_Gain_n;                 /* Expression: 2
                                        * Referenced by: '<S15>/gain1'
                                        */
  real_T Delay_InitialCondition_c;     /* Expression: 0
                                        * Referenced by: '<S15>/Delay'
                                        */
  real_T Qfilter2_Value;               /* Expression: 0.4
                                        * Referenced by: '<S4>/Qfilter2'
                                        */
  real_T gain2_Gain_f;                 /* Expression: 2*pi
                                        * Referenced by: '<S15>/gain2'
                                        */
  real_T gain3_Gain_d;                 /* Expression: 2
                                        * Referenced by: '<S15>/gain3'
                                        */
  real_T Constant1_Value_e;            /* Expression: 8
                                        * Referenced by: '<S15>/Constant1'
                                        */
  real_T Delay2_InitialCondition_c;    /* Expression: 0
                                        * Referenced by: '<S15>/Delay2'
                                        */
  real_T gain4_Gain_i;                 /* Expression: 4
                                        * Referenced by: '<S15>/gain4'
                                        */
  real_T zeta1_Value;                  /* Expression: 0.707
                                        * Referenced by: '<S7>/zeta1'
                                        */
  real_T Constant2_Value_h;            /* Expression: 4
                                        * Referenced by: '<S15>/Constant2'
                                        */
  real_T Delay3_InitialCondition_f;    /* Expression: 0
                                        * Referenced by: '<S15>/Delay3'
                                        */
  real_T DOBFlag_Value;                /* Expression: 1
                                        * Referenced by: '<S4>/DOBFlag'
                                        */
  real_T ControlFlag_Gain;             /* Expression: 1
                                        * Referenced by: '<S4>/ControlFlag'
                                        */
  real_T Saturation_UpperSat;          /* Expression: 20
                                        * Referenced by: '<S4>/Saturation'
                                        */
  real_T Saturation_LowerSat;          /* Expression: -20
                                        * Referenced by: '<S4>/Saturation'
                                        */
  real_T CANWrite1_P1_Size[2];         /* Computed Parameter: CANWrite1_P1_Size
                                        * Referenced by: '<S5>/CAN Write1'
                                        */
  real_T CANWrite1_P1;                 /* Expression: id
                                        * Referenced by: '<S5>/CAN Write1'
                                        */
  real_T CANWrite1_P2_Size[2];         /* Computed Parameter: CANWrite1_P2_Size
                                        * Referenced by: '<S5>/CAN Write1'
                                        */
  real_T CANWrite1_P2;                 /* Expression: sampleTime
                                        * Referenced by: '<S5>/CAN Write1'
                                        */
  real_T CANWrite1_P3_Size[2];         /* Computed Parameter: CANWrite1_P3_Size
                                        * Referenced by: '<S5>/CAN Write1'
                                        */
  real_T CANWrite1_P3;                 /* Expression: messageType
                                        * Referenced by: '<S5>/CAN Write1'
                                        */
  real_T CANWrite1_P4_Size[2];         /* Computed Parameter: CANWrite1_P4_Size
                                        * Referenced by: '<S5>/CAN Write1'
                                        */
  real_T CANWrite1_P4;                 /* Expression: enaStatusPort
                                        * Referenced by: '<S5>/CAN Write1'
                                        */
  real_T CANWrite1_P5_Size[2];         /* Computed Parameter: CANWrite1_P5_Size
                                        * Referenced by: '<S5>/CAN Write1'
                                        */
  real_T CANWrite1_P5[5];              /* Computed Parameter: CANWrite1_P5
                                        * Referenced by: '<S5>/CAN Write1'
                                        */
  real_T CANWrite1_P6_Size[2];         /* Computed Parameter: CANWrite1_P6_Size
                                        * Referenced by: '<S5>/CAN Write1'
                                        */
  real_T CANWrite1_P6;                 /* Expression: ptIdx
                                        * Referenced by: '<S5>/CAN Write1'
                                        */
  real_T CANWrite1_P7_Size[2];         /* Computed Parameter: CANWrite1_P7_Size
                                        * Referenced by: '<S5>/CAN Write1'
                                        */
  real_T CANWrite1_P7;                 /* Expression: isFDMod
                                        * Referenced by: '<S5>/CAN Write1'
                                        */
  uint32_T Delay1_DelayLength;         /* Computed Parameter: Delay1_DelayLength
                                        * Referenced by: '<S26>/Delay1'
                                        */
  uint32_T Delay_DelayLength;          /* Computed Parameter: Delay_DelayLength
                                        * Referenced by: '<S26>/Delay'
                                        */
  uint32_T Delay2_DelayLength;         /* Computed Parameter: Delay2_DelayLength
                                        * Referenced by: '<S26>/Delay2'
                                        */
  uint32_T Delay3_DelayLength;         /* Computed Parameter: Delay3_DelayLength
                                        * Referenced by: '<S26>/Delay3'
                                        */
  uint32_T Delay1_DelayLength_g;       /* Computed Parameter: Delay1_DelayLength_g
                                        * Referenced by: '<S15>/Delay1'
                                        */
  uint32_T Delay_DelayLength_f;        /* Computed Parameter: Delay_DelayLength_f
                                        * Referenced by: '<S15>/Delay'
                                        */
  uint32_T Delay2_DelayLength_c;       /* Computed Parameter: Delay2_DelayLength_c
                                        * Referenced by: '<S15>/Delay2'
                                        */
  uint32_T Delay3_DelayLength_g;       /* Computed Parameter: Delay3_DelayLength_g
                                        * Referenced by: '<S15>/Delay3'
                                        */
};

/* Real-time Model Data Structure */
struct tag_RTM_WheelSpd1_T {
  const char_T *path;
  const char_T *modelName;
  struct SimStruct_tag * *childSfunctions;
  const char_T *errorStatus;
  SS_SimMode simMode;
  RTWLogInfo *rtwLogInfo;
  RTWExtModeInfo *extModeInfo;
  RTWSolverInfo solverInfo;
  RTWSolverInfo *solverInfoPtr;
  void *sfcnInfo;

  /*
   * NonInlinedSFcns:
   * The following substructure contains information regarding
   * non-inlined s-functions used in the model.
   */
  struct {
    RTWSfcnInfo sfcnInfo;
    time_T *taskTimePtrs[2];
    SimStruct childSFunctions[3];
    SimStruct *childSFunctionPtrs[3];
    struct _ssBlkInfo2 blkInfo2[3];
    struct _ssSFcnModelMethods2 methods2[3];
    struct _ssSFcnModelMethods3 methods3[3];
    struct _ssSFcnModelMethods4 methods4[3];
    struct _ssStatesInfo2 statesInfo2[3];
    ssPeriodicStatesInfo periodicStatesInfo[3];
    struct _ssPortInfo2 inputOutputPortInfo2[3];
    struct {
      time_T sfcnPeriod[1];
      time_T sfcnOffset[1];
      int_T sfcnTsMap[1];
      uint_T attribs[24];
      mxArray *params[24];
      struct _ssDWorkRecord dWork[1];
      struct _ssDWorkAuxRecord dWorkAux[1];
    } Sfcn0;

    struct {
      time_T sfcnPeriod[1];
      time_T sfcnOffset[1];
      int_T sfcnTsMap[1];
      struct _ssPortOutputs outputPortInfo[2];
      struct _ssOutPortUnit outputPortUnits[2];
      struct _ssOutPortCoSimAttribute outputPortCoSimAttribute[2];
      uint_T attribs[6];
      mxArray *params[6];
      struct _ssDWorkRecord dWork[1];
      struct _ssDWorkAuxRecord dWorkAux[1];
    } Sfcn1;

    struct {
      time_T sfcnPeriod[1];
      time_T sfcnOffset[1];
      int_T sfcnTsMap[1];
      struct _ssPortInputs inputPortInfo[1];
      struct _ssInPortUnit inputPortUnits[1];
      struct _ssInPortCoSimAttribute inputPortCoSimAttribute[1];
      uint_T attribs[7];
      mxArray *params[7];
      struct _ssDWorkRecord dWork[2];
      struct _ssDWorkAuxRecord dWorkAux[2];
    } Sfcn2;
  } NonInlinedSFcns;

  void *blockIO;
  const void *constBlockIO;
  void *defaultParam;
  ZCSigState *prevZCSigState;
  real_T *contStates;
  int_T *periodicContStateIndices;
  real_T *periodicContStateRanges;
  real_T *derivs;
  void *zcSignalValues;
  void *inputs;
  void *outputs;
  boolean_T *contStateDisabled;
  boolean_T zCCacheNeedsReset;
  boolean_T derivCacheNeedsReset;
  boolean_T CTOutputIncnstWithState;
  void *dwork;

  /*
   * DataMapInfo:
   * The following substructure contains information regarding
   * structures generated in the model's C API.
   */
  struct {
    rtwCAPI_ModelMappingInfo mmi;
  } DataMapInfo;

  /*
   * Sizes:
   * The following substructure contains sizes information
   * for many of the model attributes such as inputs, outputs,
   * dwork, sample times, etc.
   */
  struct {
    uint32_T checksums[4];
    uint32_T options;
    int_T numContStates;
    int_T numPeriodicContStates;
    int_T numU;
    int_T numY;
    int_T numSampTimes;
    int_T numBlocks;
    int_T numBlockIO;
    int_T numBlockPrms;
    int_T numDwork;
    int_T numSFcnPrms;
    int_T numSFcns;
    int_T numIports;
    int_T numOports;
    int_T numNonSampZCs;
    int_T sysDirFeedThru;
    int_T rtwGenSfcn;
  } Sizes;

  /*
   * SpecialInfo:
   * The following substructure contains special information
   * related to other components that are dependent on RTW.
   */
  struct {
    const void *mappingInfo;
    void *xpcData;
  } SpecialInfo;

  /*
   * Timing:
   * The following substructure contains information regarding
   * the timing information for the model.
   */
  struct {
    time_T stepSize;
    uint32_T clockTick0;
    uint32_T clockTickH0;
    time_T stepSize0;
    uint32_T clockTick1;
    uint32_T clockTickH1;
    time_T stepSize1;
    time_T tStart;
    time_T tFinal;
    time_T timeOfLastOutput;
    void *timingData;
    real_T *varNextHitTimesList;
    SimTimeStep simTimeStep;
    boolean_T stopRequestedFlag;
    time_T *sampleTimes;
    time_T *offsetTimes;
    int_T *sampleTimeTaskIDPtr;
    int_T *sampleHits;
    int_T *perTaskSampleHits;
    time_T *t;
    time_T sampleTimesArray[2];
    time_T offsetTimesArray[2];
    int_T sampleTimeTaskIDArray[2];
    int_T sampleHitArray[2];
    int_T perTaskSampleHitsArray[4];
    time_T tArray[2];
  } Timing;
};

/* Block parameters (default storage) */
extern P_WheelSpd1_T WheelSpd1_P;

/* Block signals (default storage) */
extern B_WheelSpd1_T WheelSpd1_B;

/* Block states (default storage) */
extern DW_WheelSpd1_T WheelSpd1_DW;

/*====================*
 * External functions *
 *====================*/
extern WheelSpd1_rtModel *WheelSpd1(void);
extern void MdlInitializeSizes(void);
extern void MdlInitializeSampleTimes(void);
extern void MdlInitialize(void);
extern void MdlStart(void);
extern void MdlOutputs(int_T tid);
extern void MdlUpdate(int_T tid);
extern void MdlTerminate(void);

/* Function to get C API Model Mapping Static Info */
extern const rtwCAPI_ModelMappingStaticInfo*
  WheelSpd1_GetCAPIStaticMap(void);

/* Real-time Model object */
extern RT_MODEL_WheelSpd1_T *const WheelSpd1_M;

/*-
 * The generated code includes comments that allow you to trace directly
 * back to the appropriate location in the model.  The basic format
 * is <system>/block_name, where system is the system number (uniquely
 * assigned by Simulink) and block_name is the name of the block.
 *
 * Use the MATLAB hilite_system command to trace the generated code back
 * to the model.  For example,
 *
 * hilite_system('<S3>')    - opens system 3
 * hilite_system('<S3>/Kp') - opens and selects block Kp which resides in S3
 *
 * Here is the system hierarchy for this model
 *
 * '<Root>' : 'WheelSpd1'
 * '<S1>'   : 'WheelSpd1/DAQ_In'
 * '<S2>'   : 'WheelSpd1/DAQ_Out'
 * '<S3>'   : 'WheelSpd1/Input Signal Conditioning'
 * '<S4>'   : 'WheelSpd1/Mon_Cont'
 * '<S5>'   : 'WheelSpd1/DAQ_Out/CANBoard'
 * '<S6>'   : 'WheelSpd1/Mon_Cont/Chirp Signal'
 * '<S7>'   : 'WheelSpd1/Mon_Cont/DOB'
 * '<S8>'   : 'WheelSpd1/Mon_Cont/FF+PID Controller'
 * '<S9>'   : 'WheelSpd1/Mon_Cont/LPFM'
 * '<S10>'  : 'WheelSpd1/Mon_Cont/Signal Builder'
 * '<S11>'  : 'WheelSpd1/Mon_Cont/DOB/Dot3'
 * '<S12>'  : 'WheelSpd1/Mon_Cont/DOB/Dot4'
 * '<S13>'  : 'WheelSpd1/Mon_Cont/DOB/Dot5'
 * '<S14>'  : 'WheelSpd1/Mon_Cont/DOB/LPFM'
 * '<S15>'  : 'WheelSpd1/Mon_Cont/DOB/Second order LPF'
 * '<S16>'  : 'WheelSpd1/Mon_Cont/FF+PID Controller/FB'
 * '<S17>'  : 'WheelSpd1/Mon_Cont/FF+PID Controller/FF'
 * '<S18>'  : 'WheelSpd1/Mon_Cont/FF+PID Controller/FB/P'
 * '<S19>'  : 'WheelSpd1/Mon_Cont/FF+PID Controller/FB/PI'
 * '<S20>'  : 'WheelSpd1/Mon_Cont/FF+PID Controller/FB/PI/HPF'
 * '<S21>'  : 'WheelSpd1/Mon_Cont/FF+PID Controller/FB/PI/Integrator1'
 * '<S22>'  : 'WheelSpd1/Mon_Cont/FF+PID Controller/FF/Dot'
 * '<S23>'  : 'WheelSpd1/Mon_Cont/FF+PID Controller/FF/Dot2'
 * '<S24>'  : 'WheelSpd1/Mon_Cont/FF+PID Controller/FF/Dot3'
 * '<S25>'  : 'WheelSpd1/Mon_Cont/FF+PID Controller/FF/LPFM'
 * '<S26>'  : 'WheelSpd1/Mon_Cont/FF+PID Controller/FF/Second order LPF'
 */
#endif                                 /* RTW_HEADER_WheelSpd1_h_ */
