text: /*
   * part4_prob2_estimator.h
   *
   * Code generation for model "part4_prob2_estimator".
   *
   * Model version              : 1.91
   * Simulink Coder version : 8.6 (R2014a) 27-Dec-2013
   * C source code generated on : Tue Oct 09 17:40:16 2018
   *
   * Target selection: quarc_win64.tlc
   * Note: GRT includes extra infrastructure and instrumentation for prototyping
   * Embedded hardware selection: 32-bit Generic
   * Code generation objectives: Unspecified
   * Validation result: Not run
   */
  #ifndef RTW_HEADER_part4_prob2_estimator_h_
  #define RTW_HEADER_part4_prob2_estimator_h_
  #include <string.h>
  #ifndef part4_prob2_estimator_COMMON_INCLUDES_
  # define part4_prob2_estimator_COMMON_INCLUDES_
  #include "rtwtypes.h"
  #include "simstruc.h"
  #include "fixedpoint.h"
  #include "dt_info.h"
  #include "ext_work.h"
  #include "hil.h"
  #include "quanser_messages.h"
  #include "quanser_hid.h"
  #include "quanser_memory.h"
  #include "quanser_extern.h"
  #endif                                 /* part4_prob2_estimator_COMMON_INCLUDES_ */
  
  #include "part4_prob2_estimator_types.h"
  
  /* Shared type includes */
  #include "multiword_types.h"
  #include "rt_defines.h"
  #include "rt_nonfinite.h"
  
  /* Macros for accessing real-time model data structure */
  #ifndef rtmGetBlkStateChangeFlag
  # define rtmGetBlkStateChangeFlag(rtm) ((rtm)->ModelData.blkStateChange)
  #endif
  
  #ifndef rtmSetBlkStateChangeFlag
  # define rtmSetBlkStateChangeFlag(rtm, val) ((rtm)->ModelData.blkStateChange = (val))
  #endif
  
  #ifndef rtmGetBlockIO
  # define rtmGetBlockIO(rtm)            ((rtm)->ModelData.blockIO)
  #endif
  
  #ifndef rtmSetBlockIO
  # define rtmSetBlockIO(rtm, val)       ((rtm)->ModelData.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)->ModelData.constBlockIO)
  #endif
  
  #ifndef rtmSetConstBlockIO
  # define rtmSetConstBlockIO(rtm, val)  ((rtm)->ModelData.constBlockIO = (val))
  #endif
  
  #ifndef rtmGetContStateDisabled
  # define rtmGetContStateDisabled(rtm)  ((rtm)->ModelData.contStateDisabled)
  #endif
  
  #ifndef rtmSetContStateDisabled
  # define rtmSetContStateDisabled(rtm, val) ((rtm)->ModelData.contStateDisabled = (val))
  #endif
  
  #ifndef rtmGetContStates
  # define rtmGetContStates(rtm)         ((rtm)->ModelData.contStates)
  #endif
  
  #ifndef rtmSetContStates
  # define rtmSetContStates(rtm, val)    ((rtm)->ModelData.contStates = (val))
  #endif
  
  #ifndef rtmGetDataMapInfo
  # define rtmGetDataMapInfo(rtm)        ()
  #endif
  
  #ifndef rtmSetDataMapInfo
  # define rtmSetDataMapInfo(rtm, val)   ()
  #endif
  
  #ifndef rtmGetDefaultParam
  # define rtmGetDefaultParam(rtm)       ((rtm)->ModelData.defaultParam)
  #endif
  
  #ifndef rtmSetDefaultParam
  # define rtmSetDefaultParam(rtm, val)  ((rtm)->ModelData.defaultParam = (val))
  #endif
  
  #ifndef rtmGetDerivCacheNeedsReset
  # define rtmGetDerivCacheNeedsReset(rtm) ((rtm)->ModelData.derivCacheNeedsReset)
  #endif
  
  #ifndef rtmSetDerivCacheNeedsReset
  # define rtmSetDerivCacheNeedsReset(rtm, val) ((rtm)->ModelData.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)           ((rtm)->ModelData.intgData)
  #endif
  
  #ifndef rtmSetIntgData
  # define rtmSetIntgData(rtm, val)      ((rtm)->ModelData.intgData = (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)    ()
  #endif
  
  #ifndef rtmSetNonInlinedSFcns
  # define rtmSetNonInlinedSFcns(rtm, 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 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)               ((rtm)->ModelData.odeF)
  #endif
  
  #ifndef rtmSetOdeF
  # define rtmSetOdeF(rtm, val)          ((rtm)->ModelData.odeF = (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)  ((rtm)->Timing.RateInteraction)
  #endif
  
  #ifndef rtmSetPerTaskSampleHits
  # define rtmSetPerTaskSampleHits(rtm, val) ((rtm)->Timing.RateInteraction = (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 rtmGetPrevZCSigState
  # define rtmGetPrevZCSigState(rtm)     ((rtm)->ModelData.prevZCSigState)
  #endif
  
  #ifndef rtmSetPrevZCSigState
  # define rtmSetPrevZCSigState(rtm, val) ((rtm)->ModelData.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)         ()
  #endif
  
  #ifndef rtmSetRTWLogInfo
  # define rtmSetRTWLogInfo(rtm, 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)->ModelData.dwork)
  #endif
  
  #ifndef rtmSetRootDWork
  # define rtmSetRootDWork(rtm, val)     ((rtm)->ModelData.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 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)       ((rtm)->Timing.TaskCounters)
  #endif
  
  #ifndef rtmSetTaskCounters
  # define rtmSetTaskCounters(rtm, val)  ((rtm)->Timing.TaskCounters = (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)->ModelData.inputs)
  #endif
  
  #ifndef rtmSetU
  # define rtmSetU(rtm, val)             ((rtm)->ModelData.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)->ModelData.outputs)
  #endif
  
  #ifndef rtmSetY
  # define rtmSetY(rtm, val)             ((rtm)->ModelData.outputs = (val))
  #endif
  
  #ifndef rtmGetZCCacheNeedsReset
  # define rtmGetZCCacheNeedsReset(rtm)  ((rtm)->ModelData.zCCacheNeedsReset)
  #endif
  
  #ifndef rtmSetZCCacheNeedsReset
  # define rtmSetZCCacheNeedsReset(rtm, val) ((rtm)->ModelData.zCCacheNeedsReset = (val))
  #endif
  
  #ifndef rtmGetZCSignalValues
  # define rtmGetZCSignalValues(rtm)     ((rtm)->ModelData.zcSignalValues)
  #endif
  
  #ifndef rtmSetZCSignalValues
  # define rtmSetZCSignalValues(rtm, val) ((rtm)->ModelData.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)->ModelData.derivs)
  #endif
  
  #ifndef rtmSetdX
  # define rtmSetdX(rtm, val)            ((rtm)->ModelData.derivs = (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)->ModelData.dwork[idx])
  #endif
  
  #ifndef rtmSetDWork
  # define rtmSetDWork(rtm, idx, val)    ((rtm)->ModelData.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) <= 1)
  #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) (((rtm)->Timing.sampleTimeTaskIDPtr[sti] == (tid)))
  #endif
  
  #ifndef rtmStepTask
  # define rtmStepTask(rtm, idx)         ((rtm)->Timing.TaskCounters.TID[(idx)] == 0)
  #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 rtmTaskCounter
  # define rtmTaskCounter(rtm, idx)      ((rtm)->Timing.TaskCounters.TID[(idx)])
  #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)
  
  /* Definition for use in the target main file */
  #define part4_prob2_estimator_rtModel  RT_MODEL_part4_prob2_estimato_T
  
  /* Block signals (auto storage) */
  typedef struct {
    real_T Integrator[6];                /* '<S5>/Integrator' */
    real_T degrad1;                      /* '<Root>/deg->rad1' */
    real_T RateTransitionx;              /* '<S3>/Rate Transition: x' */
    real_T Joystick_gain_x;              /* '<S3>/Joystick_gain_x' */
    real_T invertsteering2;              /* '<Root>/invert steering 2' */
    real_T RateTransitiony;              /* '<S3>/Rate Transition: y' */
    real_T Joystick_gain_y;              /* '<S3>/Joystick_gain_y' */
    real_T invertsteering1;              /* '<Root>/invert steering 1' */
    real_T P_LQR[2];                     /* '<S4>/P_LQR' */
    real_T ElevationCounttorad;          /* '<S2>/Elevation: Count to rad' */
    real_T Gain;                         /* '<S7>/Gain' */
    real_T Gain_g;                       /* '<S6>/Gain' */
    real_T PitchCounttorad;              /* '<S2>/Pitch: Count to rad' */
    real_T Gain_j;                       /* '<S8>/Gain' */
    real_T Gain_p;                       /* '<S9>/Gain' */
    real_T TravelCounttorad;             /* '<S2>/Travel: Count to rad' */
    real_T Gain_pd;                      /* '<S11>/Gain' */
    real_T Gain_h;                       /* '<S10>/Gain' */
    real_T FrontmotorSaturation;         /* '<S2>/Front motor: Saturation' */
    real_T BackmotorSaturation;          /* '<S2>/Back motor: Saturation' */
    real_T GameController_o4;            /* '<S3>/Game Controller' */
    real_T GameController_o5;            /* '<S3>/Game Controller' */
    real_T Sum2;                         /* '<S4>/Sum2' */
    real_T Sum3;                         /* '<S4>/Sum3' */
    real_T degrad[3];                    /* '<Root>/deg->rad' */
    real_T Sum2_i[6];                    /* '<S5>/Sum2' */
  } B_part4_prob2_estimator_T;
  
  /* Block states (auto storage) for system '<Root>' */
  typedef struct {
    real_T HILInitialize_AIMinimums[8];  /* '<Root>/HIL Initialize' */
    real_T HILInitialize_AIMaximums[8];  /* '<Root>/HIL Initialize' */
    real_T HILInitialize_AOMinimums[8];  /* '<Root>/HIL Initialize' */
    real_T HILInitialize_AOMaximums[8];  /* '<Root>/HIL Initialize' */
    real_T HILInitialize_AOVoltages[8];  /* '<Root>/HIL Initialize' */
    real_T HILInitialize_FilterFrequency[8];/* '<Root>/HIL Initialize' */
    real_T HILInitialize_POSortedFreqs[8];/* '<Root>/HIL Initialize' */
    real_T HILInitialize_POValues[8];    /* '<Root>/HIL Initialize' */
    real_T RateTransitionx_Buffer0;      /* '<S3>/Rate Transition: x' */
    real_T RateTransitiony_Buffer0;      /* '<S3>/Rate Transition: y' */
    real_T HILWriteAnalog_Buffer[2];     /* '<S2>/HIL Write Analog' */
    t_game_controller GameController_Controller;/* '<S3>/Game Controller' */
    t_card HILInitialize_Card;           /* '<Root>/HIL Initialize' */
    t_task HILReadEncoderTimebase_Task;  /* '<S2>/HIL Read Encoder Timebase' */
    struct {
      void *LoggedData;
    } Elevation_est_PWORK;               /* '<Root>/Elevation_est' */
  
    struct {
      void *LoggedData;
    } Elevationrate_est_PWORK;           /* '<Root>/Elevationrate_est' */
  
    struct {
      void *LoggedData;
    } pitch_est_PWORK;                   /* '<Root>/pitch_est' */
  
    struct {
      void *LoggedData;
    } pitchrate_est_PWORK;               /* '<Root>/pitchrate_est' */
  
    struct {
      void *LoggedData;
    } travel_est_PWORK;                  /* '<Root>/travel_est' */
  
    struct {
      void *LoggedData;
    } travelrate_est_PWORK;              /* '<Root>/travelrate_est' */
  
    struct {
      void *LoggedData;
    } ElevationScopedegs_PWORK;          /* '<S2>/Elevation: Scope [deg//s]' */
  
    struct {
      void *LoggedData;
    } ElevationScopedeg_PWORK;           /* '<S2>/Elevation: Scope [deg]' */
  
    struct {
      void *LoggedData;
    } PitchScopedeg_PWORK;               /* '<S2>/Pitch: Scope [deg]' */
  
    struct {
      void *LoggedData;
    } PtichrateScopedegs_PWORK;          /* '<S2>/Ptich rate: Scope [deg//s]' */
  
    struct {
      void *LoggedData;
    } TravelrateScopedegs_PWORK;         /* '<S2>/Travel rate: Scope [deg//s]' */
  
    struct {
      void *LoggedData;
    } TravelScopedeg_PWORK;              /* '<S2>/Travel: Scope [deg]' */
  
    void *HILWriteAnalog_PWORK;          /* '<S2>/HIL Write Analog' */
    struct {
      void *LoggedData;
    } XScope_PWORK;                      /* '<S3>/X: Scope' */
  
    struct {
      void *LoggedData;
    } YScope_PWORK;                      /* '<S3>/Y: Scope' */
  
    int32_T HILInitialize_ClockModes[3]; /* '<Root>/HIL Initialize' */
    int32_T HILInitialize_QuadratureModes[8];/* '<Root>/HIL Initialize' */
    int32_T HILInitialize_InitialEICounts[8];/* '<Root>/HIL Initialize' */
    int32_T HILInitialize_POModeValues[8];/* '<Root>/HIL Initialize' */
    int32_T HILInitialize_POAlignValues[8];/* '<Root>/HIL Initialize' */
    int32_T HILInitialize_POPolarityVals[8];/* '<Root>/HIL Initialize' */
    int32_T HILReadEncoderTimebase_Buffer[3];/* '<S2>/HIL Read Encoder Timebase' */
    uint32_T HILInitialize_POSortedChans[8];/* '<Root>/HIL Initialize' */
  } DW_part4_prob2_estimator_T;
  
  /* Continuous states (auto storage) */
  typedef struct {
    real_T Integrator_CSTATE[6];         /* '<S5>/Integrator' */
    real_T Integrator1_CSTATE;           /* '<S4>/Integrator1' */
    real_T Integrator_CSTATE_f;          /* '<S4>/Integrator' */
    real_T ElevationTransferFcn_CSTATE;  /* '<S2>/Elevation: Transfer Fcn' */
    real_T PitchTransferFcn_CSTATE;      /* '<S2>/Pitch: Transfer Fcn' */
    real_T TravelTransferFcn_CSTATE;     /* '<S2>/Travel: Transfer Fcn' */
  } X_part4_prob2_estimator_T;
  
  /* State derivatives (auto storage) */
  typedef struct {
    real_T Integrator_CSTATE[6];         /* '<S5>/Integrator' */
    real_T Integrator1_CSTATE;           /* '<S4>/Integrator1' */
    real_T Integrator_CSTATE_f;          /* '<S4>/Integrator' */
    real_T ElevationTransferFcn_CSTATE;  /* '<S2>/Elevation: Transfer Fcn' */
    real_T PitchTransferFcn_CSTATE;      /* '<S2>/Pitch: Transfer Fcn' */
    real_T TravelTransferFcn_CSTATE;     /* '<S2>/Travel: Transfer Fcn' */
  } XDot_part4_prob2_estimator_T;
  
  /* State disabled  */
  typedef struct {
    boolean_T Integrator_CSTATE[6];      /* '<S5>/Integrator' */
    boolean_T Integrator1_CSTATE;        /* '<S4>/Integrator1' */
    boolean_T Integrator_CSTATE_f;       /* '<S4>/Integrator' */
    boolean_T ElevationTransferFcn_CSTATE;/* '<S2>/Elevation: Transfer Fcn' */
    boolean_T PitchTransferFcn_CSTATE;   /* '<S2>/Pitch: Transfer Fcn' */
    boolean_T TravelTransferFcn_CSTATE;  /* '<S2>/Travel: Transfer Fcn' */
  } XDis_part4_prob2_estimator_T;
  
  #ifndef ODE1_INTG
  #define ODE1_INTG
  
  /* ODE1 Integration Data */
  typedef struct {
    real_T *f[1];                        /* derivatives */
  } ODE1_IntgData;
  
  #endif
  
  /* Backward compatible GRT Identifiers */
  #define rtB                            part4_prob2_estimator_B
  #define BlockIO                        B_part4_prob2_estimator_T
  #define rtX                            part4_prob2_estimator_X
  #define ContinuousStates               X_part4_prob2_estimator_T
  #define rtXdot                         part4_prob2_estimator_XDot
  #define StateDerivatives               XDot_part4_prob2_estimator_T
  #define tXdis                          part4_prob2_estimator_XDis
  #define StateDisabled                  XDis_part4_prob2_estimator_T
  #define rtP                            part4_prob2_estimator_P
  #define Parameters                     P_part4_prob2_estimator_T
  #define rtDWork                        part4_prob2_estimator_DW
  #define D_Work                         DW_part4_prob2_estimator_T
  
  /* Parameters (auto storage) */
  struct P_part4_prob2_estimator_T_ {
    real_T A_est[36];                    /* Variable: A_est
                                          * Referenced by: '<S5>/A_est1'
                                          */
    real_T B_est[12];                    /* Variable: B_est
                                          * Referenced by: '<S5>/B_est'
                                          */
    real_T C_est[18];                    /* Variable: C_est
                                          * Referenced by: '<S5>/C_est'
                                          */
    real_T Joystick_gain_x;              /* Variable: Joystick_gain_x
                                          * Referenced by: '<S3>/Joystick_gain_x'
                                          */
    real_T Joystick_gain_y;              /* Variable: Joystick_gain_y
                                          * Referenced by: '<S3>/Joystick_gain_y'
                                          */
    real_T K_LQR[10];                    /* Variable: K_LQR
                                          * Referenced by: '<S4>/K_LQR'
                                          */
    real_T L_est[18];                    /* Variable: L_est
                                          * Referenced by: '<S5>/L_est'
                                          */
    real_T P_LQR[4];                     /* Variable: P_LQR
                                          * Referenced by: '<S4>/P_LQR'
                                          */
    real_T HILInitialize_analog_input_maxi;/* Mask Parameter: HILInitialize_analog_input_maxi
                                            * Referenced by: '<Root>/HIL Initialize'
                                            */
    real_T HILInitialize_analog_input_mini;/* Mask Parameter: HILInitialize_analog_input_mini
                                            * Referenced by: '<Root>/HIL Initialize'
                                            */
    real_T HILInitialize_analog_output_max;/* Mask Parameter: HILInitialize_analog_output_max
                                            * Referenced by: '<Root>/HIL Initialize'
                                            */
    real_T HILInitialize_analog_output_min;/* Mask Parameter: HILInitialize_analog_output_min
                                            * Referenced by: '<Root>/HIL Initialize'
                                            */
    real_T HILInitialize_final_analog_outp;/* Mask Parameter: HILInitialize_final_analog_outp
                                            * Referenced by: '<Root>/HIL Initialize'
                                            */
    real_T HILInitialize_final_pwm_outputs;/* Mask Parameter: HILInitialize_final_pwm_outputs
                                            * Referenced by: '<Root>/HIL Initialize'
                                            */
    real_T HILInitialize_initial_analog_ou;/* Mask Parameter: HILInitialize_initial_analog_ou
                                            * Referenced by: '<Root>/HIL Initialize'
                                            */
    real_T HILInitialize_initial_pwm_outpu;/* Mask Parameter: HILInitialize_initial_pwm_outpu
                                            * Referenced by: '<Root>/HIL Initialize'
                                            */
    real_T HILInitialize_pwm_frequency;  /* Mask Parameter: HILInitialize_pwm_frequency
                                          * Referenced by: '<Root>/HIL Initialize'
                                          */
    real_T HILInitialize_pwm_leading_deadb;/* Mask Parameter: HILInitialize_pwm_leading_deadb
                                            * Referenced by: '<Root>/HIL Initialize'
                                            */
    real_T HILInitialize_pwm_trailing_dead;/* Mask Parameter: HILInitialize_pwm_trailing_dead
                                            * Referenced by: '<Root>/HIL Initialize'
                                            */
    real_T HILInitialize_set_other_outputs;/* Mask Parameter: HILInitialize_set_other_outputs
                                            * Referenced by: '<Root>/HIL Initialize'
                                            */
    real_T HILInitialize_set_other_outpu_m;/* Mask Parameter: HILInitialize_set_other_outpu_m
                                            * Referenced by: '<Root>/HIL Initialize'
                                            */
    real_T HILInitialize_set_other_outpu_k;/* Mask Parameter: HILInitialize_set_other_outpu_k
                                            * Referenced by: '<Root>/HIL Initialize'
                                            */
    real_T HILInitialize_set_other_outpu_j;/* Mask Parameter: HILInitialize_set_other_outpu_j
                                            * Referenced by: '<Root>/HIL Initialize'
                                            */
    real_T HILInitialize_watchdog_analog_o;/* Mask Parameter: HILInitialize_watchdog_analog_o
                                            * Referenced by: '<Root>/HIL Initialize'
                                            */
    real_T HILInitialize_watchdog_pwm_outp;/* Mask Parameter: HILInitialize_watchdog_pwm_outp
                                            * Referenced by: '<Root>/HIL Initialize'
                                            */
    int32_T HILReadEncoderTimebase_clock;/* Mask Parameter: HILReadEncoderTimebase_clock
                                          * Referenced by: '<S2>/HIL Read Encoder Timebase'
                                          */
    int32_T HILInitialize_hardware_clocks[3];/* Mask Parameter: HILInitialize_hardware_clocks
                                              * Referenced by: '<Root>/HIL Initialize'
                                              */
    int32_T HILInitialize_initial_encoder_c;/* Mask Parameter: HILInitialize_initial_encoder_c
                                             * Referenced by: '<Root>/HIL Initialize'
                                             */
    int32_T HILInitialize_pwm_alignment; /* Mask Parameter: HILInitialize_pwm_alignment
                                          * Referenced by: '<Root>/HIL Initialize'
                                          */
    int32_T HILInitialize_pwm_configuration;/* Mask Parameter: HILInitialize_pwm_configuration
                                             * Referenced by: '<Root>/HIL Initialize'
                                             */
    int32_T HILInitialize_pwm_modes;     /* Mask Parameter: HILInitialize_pwm_modes
                                          * Referenced by: '<Root>/HIL Initialize'
                                          */
    int32_T HILInitialize_pwm_polarity;  /* Mask Parameter: HILInitialize_pwm_polarity
                                          * Referenced by: '<Root>/HIL Initialize'
                                          */
    int32_T HILInitialize_watchdog_digital_;/* Mask Parameter: HILInitialize_watchdog_digital_
                                             * Referenced by: '<Root>/HIL Initialize'
                                             */
    uint32_T HILInitialize_analog_input_chan[8];/* Mask Parameter: HILInitialize_analog_input_chan
                                                 * Referenced by: '<Root>/HIL Initialize'
                                                 */
    uint32_T HILInitialize_analog_output_cha[8];/* Mask Parameter: HILInitialize_analog_output_cha
                                                 * Referenced by: '<Root>/HIL Initialize'
                                                 */
    uint32_T HILReadEncoderTimebase_channels[3];/* Mask Parameter: HILReadEncoderTimebase_channels
                                                 * Referenced by: '<S2>/HIL Read Encoder Timebase'
                                                 */
    uint32_T HILWriteAnalog_channels[2]; /* Mask Parameter: HILWriteAnalog_channels
                                          * Referenced by: '<S2>/HIL Write Analog'
                                          */
    uint32_T HILInitialize_encoder_channels[8];/* Mask Parameter: HILInitialize_encoder_channels
                                                * Referenced by: '<Root>/HIL Initialize'
                                                */
    uint32_T HILInitialize_pwm_channels[8];/* Mask Parameter: HILInitialize_pwm_channels
                                            * Referenced by: '<Root>/HIL Initialize'
                                            */
    uint32_T HILInitialize_quadrature;   /* Mask Parameter: HILInitialize_quadrature
                                          * Referenced by: '<Root>/HIL Initialize'
                                          */
    uint32_T HILReadEncoderTimebase_samples_;/* Mask Parameter: HILReadEncoderTimebase_samples_
                                              * Referenced by: '<S2>/HIL Read Encoder Timebase'
                                              */
    boolean_T HILInitialize_active;      /* Mask Parameter: HILInitialize_active
                                          * Referenced by: '<Root>/HIL Initialize'
                                          */
    boolean_T HILInitialize_final_digital_out;/* Mask Parameter: HILInitialize_final_digital_out
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_initial_digital_o;/* Mask Parameter: HILInitialize_initial_digital_o
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_analog_input_;/* Mask Parameter: HILInitialize_set_analog_input_
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_analog_inpu_m;/* Mask Parameter: HILInitialize_set_analog_inpu_m
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_analog_output;/* Mask Parameter: HILInitialize_set_analog_output
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_analog_outp_b;/* Mask Parameter: HILInitialize_set_analog_outp_b
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_analog_outp_e;/* Mask Parameter: HILInitialize_set_analog_outp_e
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_analog_outp_j;/* Mask Parameter: HILInitialize_set_analog_outp_j
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_analog_outp_c;/* Mask Parameter: HILInitialize_set_analog_outp_c
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_analog_out_ex;/* Mask Parameter: HILInitialize_set_analog_out_ex
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_analog_outp_p;/* Mask Parameter: HILInitialize_set_analog_outp_p
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_clock_frequen;/* Mask Parameter: HILInitialize_set_clock_frequen
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_clock_frequ_e;/* Mask Parameter: HILInitialize_set_clock_frequ_e
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_clock_params_;/* Mask Parameter: HILInitialize_set_clock_params_
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_clock_param_c;/* Mask Parameter: HILInitialize_set_clock_param_c
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_digital_outpu;/* Mask Parameter: HILInitialize_set_digital_outpu
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_digital_out_b;/* Mask Parameter: HILInitialize_set_digital_out_b
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_digital_out_c;/* Mask Parameter: HILInitialize_set_digital_out_c
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_digital_ou_c1;/* Mask Parameter: HILInitialize_set_digital_ou_c1
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_digital_out_a;/* Mask Parameter: HILInitialize_set_digital_out_a
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_digital_out_j;/* Mask Parameter: HILInitialize_set_digital_out_j
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_digital_out_m;/* Mask Parameter: HILInitialize_set_digital_out_m
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_encoder_count;/* Mask Parameter: HILInitialize_set_encoder_count
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_encoder_cou_k;/* Mask Parameter: HILInitialize_set_encoder_cou_k
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_encoder_param;/* Mask Parameter: HILInitialize_set_encoder_param
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_encoder_par_m;/* Mask Parameter: HILInitialize_set_encoder_par_m
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_other_outpu_l;/* Mask Parameter: HILInitialize_set_other_outpu_l
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_pwm_outputs_a;/* Mask Parameter: HILInitialize_set_pwm_outputs_a
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_pwm_outputs_g;/* Mask Parameter: HILInitialize_set_pwm_outputs_g
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_pwm_outputs_p;/* Mask Parameter: HILInitialize_set_pwm_outputs_p
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_pwm_output_ap;/* Mask Parameter: HILInitialize_set_pwm_output_ap
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_pwm_outputs_o;/* Mask Parameter: HILInitialize_set_pwm_outputs_o
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_pwm_params_at;/* Mask Parameter: HILInitialize_set_pwm_params_at
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    boolean_T HILInitialize_set_pwm_params__f;/* Mask Parameter: HILInitialize_set_pwm_params__f
                                               * Referenced by: '<Root>/HIL Initialize'
                                               */
    real_T Integrator_IC;                /* Expression: 0
                                          * Referenced by: '<S5>/Integrator'
                                          */
    real_T degrad1_Gain;                 /* Expression: 360/2*pi
                                          * Referenced by: '<Root>/deg->rad1'
                                          */
    real_T Integrator1_IC;               /* Expression: 0
                                          * Referenced by: '<S4>/Integrator1'
                                          */
    real_T Integrator_IC_k;              /* Expression: 0
                                          * Referenced by: '<S4>/Integrator'
                                          */
    real_T RateTransitionx_X0;           /* Expression: 0
                                          * Referenced by: '<S3>/Rate Transition: x'
                                          */
    real_T DeadZonex_Start;              /* Expression: -0.1
                                          * Referenced by: '<S3>/Dead Zone: x'
                                          */
    real_T DeadZonex_End;                /* Expression: 0.1
                                          * Referenced by: '<S3>/Dead Zone: x'
                                          */
    real_T Gainx_Gain;                   /* Expression: 10/9
                                          * Referenced by: '<S3>/Gain: x'
                                          */
    real_T invertsteering2_Gain;         /* Expression: -1
                                          * Referenced by: '<Root>/invert steering 2'
                                          */
    real_T RateTransitiony_X0;           /* Expression: 0
                                          * Referenced by: '<S3>/Rate Transition: y'
                                          */
    real_T DeadZoney_Start;              /* Expression: -0.1
                                          * Referenced by: '<S3>/Dead Zone: y'
                                          */
    real_T DeadZoney_End;                /* Expression: 0.1
                                          * Referenced by: '<S3>/Dead Zone: y'
                                          */
    real_T Gainy_Gain;                   /* Expression: 10/9
                                          * Referenced by: '<S3>/Gain: y'
                                          */
    real_T invertsteering1_Gain;         /* Expression: -1
                                          * Referenced by: '<Root>/invert steering 1'
                                          */
    real_T Backgain_Gain;                /* Expression: 0.5
                                          * Referenced by: '<S1>/Back gain'
                                          */
    real_T Frontgain_Gain;               /* Expression: 0.5
                                          * Referenced by: '<S1>/Front gain'
                                          */
    real_T ElevationCounttorad_Gain;     /* Expression: -2 * pi /4096
                                          * Referenced by: '<S2>/Elevation: Count to rad'
                                          */
    real_T ElevationTransferFcn_A;       /* Computed Parameter: ElevationTransferFcn_A
                                          * Referenced by: '<S2>/Elevation: Transfer Fcn'
                                          */
    real_T ElevationTransferFcn_C;       /* Computed Parameter: ElevationTransferFcn_C
                                          * Referenced by: '<S2>/Elevation: Transfer Fcn'
                                          */
    real_T ElevationTransferFcn_D;       /* Computed Parameter: ElevationTransferFcn_D
                                          * Referenced by: '<S2>/Elevation: Transfer Fcn'
                                          */
    real_T Gain_Gain;                    /* Expression: 180/pi
                                          * Referenced by: '<S7>/Gain'
                                          */
    real_T Gain_Gain_e;                  /* Expression: 180/pi
                                          * Referenced by: '<S6>/Gain'
                                          */
    real_T PitchCounttorad_Gain;         /* Expression: 2*pi /4096
                                          * Referenced by: '<S2>/Pitch: Count to rad'
                                          */
    real_T Gain_Gain_ey;                 /* Expression: 180/pi
                                          * Referenced by: '<S8>/Gain'
                                          */
    real_T PitchTransferFcn_A;           /* Computed Parameter: PitchTransferFcn_A
                                          * Referenced by: '<S2>/Pitch: Transfer Fcn'
                                          */
    real_T PitchTransferFcn_C;           /* Computed Parameter: PitchTransferFcn_C
                                          * Referenced by: '<S2>/Pitch: Transfer Fcn'
                                          */
    real_T PitchTransferFcn_D;           /* Computed Parameter: PitchTransferFcn_D
                                          * Referenced by: '<S2>/Pitch: Transfer Fcn'
                                          */
    real_T Gain_Gain_f;                  /* Expression: 180/pi
                                          * Referenced by: '<S9>/Gain'
                                          */
    real_T TravelCounttorad_Gain;        /* Expression: 2*pi/8192
                                          * Referenced by: '<S2>/Travel: Count to rad'
                                          */
    real_T TravelTransferFcn_A;          /* Computed Parameter: TravelTransferFcn_A
                                          * Referenced by: '<S2>/Travel: Transfer Fcn'
                                          */
    real_T TravelTransferFcn_C;          /* Computed Parameter: TravelTransferFcn_C
                                          * Referenced by: '<S2>/Travel: Transfer Fcn'
                                          */
    real_T TravelTransferFcn_D;          /* Computed Parameter: TravelTransferFcn_D
                                          * Referenced by: '<S2>/Travel: Transfer Fcn'
                                          */
    real_T Gain_Gain_p;                  /* Expression: 180/pi
                                          * Referenced by: '<S11>/Gain'
                                          */
    real_T Gain_Gain_n;                  /* Expression: 180/pi
                                          * Referenced by: '<S10>/Gain'
                                          */
    real_T FrontmotorSaturation_UpperSat;/* Expression: 5
                                          * Referenced by: '<S2>/Front motor: Saturation'
                                          */
    real_T FrontmotorSaturation_LowerSat;/* Expression: -5
                                          * Referenced by: '<S2>/Front motor: Saturation'
                                          */
    real_T BackmotorSaturation_UpperSat; /* Expression: 5
                                          * Referenced by: '<S2>/Back motor: Saturation'
                                          */
    real_T BackmotorSaturation_LowerSat; /* Expression: -5
                                          * Referenced by: '<S2>/Back motor: Saturation'
                                          */
    real_T pitchoffset_Value;            /* Expression: -3
                                          * Referenced by: '<Root>/pitch  offset'
                                          */
    real_T elevationoffset1_Value;       /* Expression: 0
                                          * Referenced by: '<Root>/elevation  offset1'
                                          */
    real_T degrad_Gain;                  /* Expression: 2*pi/360
                                          * Referenced by: '<Root>/deg->rad'
                                          */
    uint16_T GameController_BufferSize;  /* Computed Parameter: GameController_BufferSize
                                          * Referenced by: '<S3>/Game Controller'
                                          */
    uint8_T GameController_ControllerNumber;/* Computed Parameter: GameController_ControllerNumber
                                             * Referenced by: '<S3>/Game Controller'
                                             */
    boolean_T HILReadEncoderTimebase_Active;/* Computed Parameter: HILReadEncoderTimebase_Active
                                             * Referenced by: '<S2>/HIL Read Encoder Timebase'
                                             */
    boolean_T HILWriteAnalog_Active;     /* Computed Parameter: HILWriteAnalog_Active
                                          * Referenced by: '<S2>/HIL Write Analog'
                                          */
    boolean_T GameController_AutoCenter; /* Computed Parameter: GameController_AutoCenter
                                          * Referenced by: '<S3>/Game Controller'
                                          */
    boolean_T GameController_Enabled;    /* Computed Parameter: GameController_Enabled
                                          * Referenced by: '<S3>/Game Controller'
                                          */
  };
  
  /* Real-time Model Data Structure */
  struct tag_RTM_part4_prob2_estimator_T {
    const char_T *path;
    const char_T *modelName;
    struct SimStruct_tag * *childSfunctions;
    const char_T *errorStatus;
    SS_SimMode simMode;
    RTWExtModeInfo *extModeInfo;
    RTWSolverInfo solverInfo;
    RTWSolverInfo *solverInfoPtr;
    void *sfcnInfo;
  
    /*
     * ModelData:
     * The following substructure contains information regarding
     * the data used in the model.
     */
    struct {
      void *blockIO;
      const void *constBlockIO;
      void *defaultParam;
      ZCSigState *prevZCSigState;
      real_T *contStates;
      real_T *derivs;
      void *zcSignalValues;
      void *inputs;
      void *outputs;
      boolean_T *contStateDisabled;
      boolean_T zCCacheNeedsReset;
      boolean_T derivCacheNeedsReset;
      boolean_T blkStateChange;
      real_T odeF[1][11];
      ODE1_IntgData intgData;
      void *dwork;
    } ModelData;
  
    /*
     * 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 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;
      uint32_T clockTick2;
      uint32_T clockTickH2;
      time_T stepSize2;
      struct {
        uint8_T TID[3];
      } TaskCounters;
  
      struct {
        boolean_T TID1_2;
      } RateInteraction;
  
      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[3];
      time_T offsetTimesArray[3];
      int_T sampleTimeTaskIDArray[3];
      int_T sampleHitArray[3];
      int_T perTaskSampleHitsArray[9];
      time_T tArray[3];
    } Timing;
  };
  
  /* Block parameters (auto storage) */
  extern P_part4_prob2_estimator_T part4_prob2_estimator_P;
  
  /* Block signals (auto storage) */
  extern B_part4_prob2_estimator_T part4_prob2_estimator_B;
  
  /* Continuous states (auto storage) */
  extern X_part4_prob2_estimator_T part4_prob2_estimator_X;
  
  /* Block states (auto storage) */
  extern DW_part4_prob2_estimator_T part4_prob2_estimator_DW;
  
  /* External function called from main */
  extern time_T rt_SimUpdateDiscreteEvents(
    int_T rtmNumSampTimes, void *rtmTimingData, int_T *rtmSampleHitPtr, int_T
    *rtmPerTaskSampleHits )
    ;
  
  /* Model entry point functions */
  extern void part4_prob2_estimator_initialize(void);
  extern void part4_prob2_estimator_output0(void);
  extern void part4_prob2_estimator_update0(void);
  extern void part4_prob2_estimator_output(int_T tid);
  extern void part4_prob2_estimator_update(int_T tid);
  extern void part4_prob2_estimator_terminate(void);
  
  /* Real-time Model object */
  extern RT_MODEL_part4_prob2_estimato_T *const part4_prob2_estimator_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>' : 'part4_prob2_estimator'
   * '<S1>'   : 'part4_prob2_estimator/Conversion1'
   * '<S2>'   : 'part4_prob2_estimator/Heli 3D1'
   * '<S3>'   : 'part4_prob2_estimator/Joystick1'
   * '<S4>'   : 'part4_prob2_estimator/LQR'
   * '<S5>'   : 'part4_prob2_estimator/Observer'
   * '<S6>'   : 'part4_prob2_estimator/Heli 3D1/Elevation rad to deg'
   * '<S7>'   : 'part4_prob2_estimator/Heli 3D1/Elevation rate rad to deg'
   * '<S8>'   : 'part4_prob2_estimator/Heli 3D1/Pitch rad to deg'
   * '<S9>'   : 'part4_prob2_estimator/Heli 3D1/Pitch rate rad to deg'
   * '<S10>'  : 'part4_prob2_estimator/Heli 3D1/Travel rad to deg'
   * '<S11>'  : 'part4_prob2_estimator/Heli 3D1/Travel rate  rad to deg'
   */
  #endif                                 /* RTW_HEADER_part4_prob2_estimator_h_ */
  