/*
 * double_new_moment.h
 *
 * Code generation for model "double_new_moment".
 *
 * Model version              : 1.298
 * Simulink Coder version : 8.9 (R2015b) 13-Aug-2015
 * C source code generated on : Tue May 22 08:51:57 2018
 *
 * Target selection: sldrt.tlc
 * Note: GRT includes extra infrastructure and instrumentation for prototyping
 * Embedded hardware selection: Intel->x86-64
 * Code generation objectives: Unspecified
 * Validation result: Not run
 */

#ifndef RTW_HEADER_double_new_moment_h_
#define RTW_HEADER_double_new_moment_h_
#include <math.h>
#include <string.h>
#ifndef double_new_moment_COMMON_INCLUDES_
# define double_new_moment_COMMON_INCLUDES_
#include "rtwtypes.h"
#include "zero_crossing_types.h"
#include "simstruc.h"
#include "fixedpoint.h"
#include "dt_info.h"
#include "ext_work.h"
#include "sldrtdef.h"
#endif                                 /* double_new_moment_COMMON_INCLUDES_ */

#include "double_new_moment_types.h"

/* Shared type includes */
#include "multiword_types.h"
#include "rt_zcfcn.h"
#include "rtGetInf.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)           ()
#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)    ()
#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 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)->ModelData.periodicContStateIndices)
#endif

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

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

#ifndef rtmSetPeriodicContStateRanges
# define rtmSetPeriodicContStateRanges(rtm, val) ((rtm)->ModelData.periodicContStateRanges = (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)       ()
#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)->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) == 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)

/* Definition for use in the target main file */
#define double_new_moment_rtModel      RT_MODEL_double_new_moment_T

/* Block signals for system '<Root>/MATLAB Function' */
typedef struct {
  real_T y;                            /* '<Root>/MATLAB Function' */
} B_MATLABFunction_double_new_moment_T;

/* Block signals for system '<Root>/MATLAB Function2' */
typedef struct {
  real_T y;                            /* '<Root>/MATLAB Function2' */
} B_MATLABFunction2_double_new_moment_T;

/* Block signals (auto storage) */
typedef struct {
  real_T Poloha;                       /* '<Root>/Poloha' */
  real_T Constant9;                    /* '<Root>/Constant9' */
  real_T Constant8;                    /* '<Root>/Constant8' */
  real_T Constant1;                    /* '<Root>/Constant1' */
  real_T helvychlenkyvadla;            /* '<Root>/Úhel vychýlení kyvadla' */
  real_T helvychlenkyvadla1;           /* '<Root>/Úhel vychýlení kyvadla1' */
  real_T ManualSwitch3[4];             /* '<Root>/Manual Switch3' */
  real_T Stabilizaceon1;               /* '<Root>/Stabilizace on1' */
  real_T Gain;                         /* '<Root>/Gain' */
  real_T Fcn1;                         /* '<Root>/Fcn1' */
  real_T ManualSwitch6;                /* '<Root>/Manual Switch6' */
  real_T TSamp;                        /* '<S7>/TSamp' */
  real_T Gain1;                        /* '<Root>/Gain1' */
  real_T Gain2;                        /* '<Root>/Gain2' */
  real_T Gain3;                        /* '<Root>/Gain3' */
  real_T Reshapexhat[7];               /* '<S12>/Reshapexhat' */
  real_T ManualSwitch7;                /* '<Root>/Manual Switch7' */
  real_T Gain31;                       /* '<Root>/Gain31' */
  real_T Gain32;                       /* '<Root>/Gain32' */
  real_T Gain33;                       /* '<Root>/Gain33' */
  real_T Gain34;                       /* '<Root>/Gain34' */
  real_T Gain35;                       /* '<Root>/Gain35' */
  real_T Gain36;                       /* '<Root>/Gain36' */
  real_T Saturation3;                  /* '<Root>/Saturation3' */
  real_T Clock1;                       /* '<Root>/Clock1' */
  real_T RateTransition1;              /* '<Root>/Rate Transition1' */
  real_T Constant11;                   /* '<Root>/Constant11' */
  real_T Constant3;                    /* '<Root>/Constant3' */
  real_T NOut;                         /* '<S18>/NOut' */
  real_T Clock;                        /* '<Root>/Clock' */
  real_T Gain7;                        /* '<Root>/Gain7' */
  real_T Reshapexhat_i[3];             /* '<S13>/Reshapexhat' */
  real_T ManualSwitch5;                /* '<Root>/Manual Switch5' */
  real_T FilterCoefficient;            /* '<S19>/Filter Coefficient' */
  real_T ManualSwitch1;                /* '<Root>/Manual Switch1' */
  real_T Fcn2;                         /* '<Root>/Fcn2' */
  real_T Gain16;                       /* '<Root>/Gain16' */
  real_T Saturation1;                  /* '<Root>/Saturation1' */
  real_T Product;                      /* '<Root>/Product' */
  real_T TSamp_g;                      /* '<S6>/TSamp' */
  real_T Diff;                         /* '<S6>/Diff' */
  real_T TSamp_k;                      /* '<S8>/TSamp' */
  real_T Diff_l;                       /* '<S8>/Diff' */
  real_T xk1;                          /* '<S23>/A*x(k) + B*u(k)' */
  real_T xk1_d;                        /* '<S24>/A*x(k) + B*u(k)' */
  real_T FromWorkspace;                /* '<Root>/From Workspace' */
  real_T Add[7];                       /* '<S42>/Add' */
  real_T Add_f[3];                     /* '<S86>/Add' */
  real_T IOut;                         /* '<S18>/IOut' */
  real_T IntegralGain;                 /* '<S19>/Integral Gain' */
  real_T signal;                       /* '<Root>/Zabezpe&#x10D;ení proti vyjetí' */
  real_T bound_flag;                   /* '<Root>/Zabezpe&#x10D;ení proti vyjetí' */
  real_T stab_flag;                    /* '<Root>/Spusteni stabilizace' */
  real_T su_flag;                      /* '<Root>/Spusteni stabilizace' */
  real_T Product2[3];                  /* '<S111>/Product2' */
  real_T Product3[3];                  /* '<S108>/Product3' */
  real_T PNew[9];                      /* '<S69>/Discrete-Time KF - Calculate PLMZ' */
  real_T Product2_d[7];                /* '<S68>/Product2' */
  real_T Product3_i[7];                /* '<S64>/Product3' */
  real_T PNew_o[49];                   /* '<S25>/Discrete-Time KF - Calculate PLMZ' */
  real_T stabFlag2;                    /* '<Root>/Chart' */
  boolean_T Compare;                   /* '<S4>/Compare' */
  boolean_T Compare_a;                 /* '<S5>/Compare' */
  B_MATLABFunction2_double_new_moment_T sf_MATLABFunction3;/* '<Root>/MATLAB Function3' */
  B_MATLABFunction2_double_new_moment_T sf_MATLABFunction2;/* '<Root>/MATLAB Function2' */
  B_MATLABFunction_double_new_moment_T sf_MATLABFunction1;/* '<Root>/MATLAB Function1' */
  B_MATLABFunction_double_new_moment_T sf_MATLABFunction;/* '<Root>/MATLAB Function' */
} B_double_new_moment_T;

/* Block states (auto storage) for system '<Root>' */
typedef struct {
  real_T MemoryP_DSTATE[49];           /* '<S12>/MemoryP' */
  real_T Delay_x_DSTATE;               /* '<S24>/Delay_x' */
  real_T UD_DSTATE;                    /* '<S7>/UD' */
  real_T Delay_x_DSTATE_e;             /* '<S23>/Delay_x' */
  real_T filtr1_states;                /* '<Root>/filtr1' */
  real_T filtr3_states;                /* '<Root>/filtr3' */
  real_T MemoryX_DSTATE[7];            /* '<S12>/MemoryX' */
  real_T Integrator_DSTATE;            /* '<S18>/Integrator' */
  real_T Filter_DSTATE;                /* '<S18>/Filter' */
  real_T DiscreteTimeIntegrator_DSTATE;/* '<Root>/Discrete-Time Integrator' */
  real_T MemoryP_DSTATE_e[9];          /* '<S13>/MemoryP' */
  real_T MemoryX_DSTATE_b[3];          /* '<S13>/MemoryX' */
  real_T Integrator_DSTATE_p;          /* '<S19>/Integrator' */
  real_T Filter_DSTATE_g;              /* '<S19>/Filter' */
  real_T UD_DSTATE_p;                  /* '<S6>/UD' */
  real_T UD_DSTATE_i;                  /* '<S8>/UD' */
  real_T leveKC;                       /* '<Root>/Zabezpe&#x10D;ení proti vyjetí' */
  real_T praveKC;                      /* '<Root>/Zabezpe&#x10D;ení proti vyjetí' */
  real_T time;                         /* '<Root>/Chart' */
  real_T timeStab;                     /* '<Root>/Chart' */
  void *Motor_PWORK;                   /* '<Root>/Motor' */
  void *DigitalInput_PWORK;            /* '<Root>/Digital Input' */
  void *DigitalInput1_PWORK;           /* '<Root>/Digital Input1' */
  void *Kyvadlo1_PWORK;                /* '<Root>/Kyvadlo1' */
  void *Kyvadlo2_PWORK;                /* '<Root>/Kyvadlo2' */
  void *AnalogInput1_PWORK;            /* '<Root>/Analog Input1' */
  void *AnalogInput_PWORK;             /* '<Root>/Analog Input' */
  void *BRAKE_PWORK;                   /* '<Root>/BRAKE' */
  void *DIR_PWORK;                     /* '<Root>/DIR' */
  void *PWM_PWORK;                     /* '<Root>/PWM' */
  struct {
    void *LoggedData;
  } Arm2scope3_PWORK;                  /* '<Root>/Arm2 - scope3' */

  struct {
    void *LoggedData;
  } Arm2scope4_PWORK;                  /* '<Root>/Arm2 - scope4' */

  struct {
    void *LoggedData[3];
  } Cartscope1_PWORK;                  /* '<Root>/Cart - scope1' */

  struct {
    void *LoggedData[2];
  } Cartscope2_PWORK;                  /* '<Root>/Cart - scope2' */

  struct {
    void *LoggedData[3];
  } Cartscope6_PWORK;                  /* '<Root>/Cart - scope6' */

  struct {
    void *LoggedData[3];
  } Cartscope7_PWORK;                  /* '<Root>/Cart - scope7' */

  struct {
    void *LoggedData[7];
  } Kalman_PWORK;                      /* '<Root>/Kalman' */

  struct {
    void *LoggedData;
  } Scope_PWORK;                       /* '<Root>/Scope' */

  struct {
    void *LoggedData[2];
  } Scope1_PWORK;                      /* '<Root>/Scope1' */

  struct {
    void *LoggedData;
  } Scope2_PWORK;                      /* '<Root>/Scope2' */

  struct {
    void *LoggedData[2];
  } Scope3_PWORK;                      /* '<Root>/Scope3' */

  struct {
    void *LoggedData;
  } Scope4_PWORK;                      /* '<Root>/Scope4' */

  struct {
    void *LoggedData[2];
  } Scope5_PWORK;                      /* '<Root>/Scope5' */

  struct {
    void *TimePtr;
    void *DataPtr;
    void *RSimInfoPtr;
  } FromWorkspace_PWORK;               /* '<Root>/From Workspace' */

  int32_T sfEvent;                     /* '<Root>/Zabezpe&#x10D;ení proti vyjetí' */
  int32_T sfEvent_j;                   /* '<Root>/Spusteni stabilizace' */
  int32_T sfEvent_e;                   /* '<Root>/Chart' */
  struct {
    int_T PrevIndex;
  } FromWorkspace_IWORK;               /* '<Root>/From Workspace' */

  int8_T Integrator_PrevResetState;    /* '<S18>/Integrator' */
  int8_T Filter_PrevResetState;        /* '<S18>/Filter' */
  int8_T MeasurementUpdate_SubsysRanBC;/* '<S42>/MeasurementUpdate' */
  int8_T MeasurementUpdate_SubsysRanBC_n;/* '<S86>/MeasurementUpdate' */
  int8_T EnabledSubsystem_SubsysRanBC; /* '<S91>/Enabled Subsystem' */
  int8_T EnabledSubsystem_SubsysRanBC_d;/* '<S47>/Enabled Subsystem' */
  uint8_T icLoad;                      /* '<S12>/MemoryP' */
  uint8_T icLoad_e;                    /* '<S12>/MemoryX' */
  uint8_T Integrator_IC_LOADING;       /* '<S18>/Integrator' */
  uint8_T Filter_IC_LOADING;           /* '<S18>/Filter' */
  uint8_T icLoad_d;                    /* '<S13>/MemoryP' */
  uint8_T icLoad_ey;                   /* '<S13>/MemoryX' */
  uint8_T is_active_c3_double_new_moment;/* '<Root>/Zabezpe&#x10D;ení proti vyjetí' */
  uint8_T is_c3_double_new_moment;     /* '<Root>/Zabezpe&#x10D;ení proti vyjetí' */
  uint8_T is_active_c2_double_new_moment;/* '<Root>/Spusteni stabilizace' */
  uint8_T is_c2_double_new_moment;     /* '<Root>/Spusteni stabilizace' */
  uint8_T is_active_c4_double_new_moment;/* '<Root>/Chart' */
  uint8_T is_c4_double_new_moment;     /* '<Root>/Chart' */
  boolean_T isStable;                  /* '<Root>/Zabezpe&#x10D;ení proti vyjetí' */
  boolean_T isStable_o;                /* '<Root>/Spusteni stabilizace' */
  boolean_T isStable_n;                /* '<Root>/Chart' */
} DW_double_new_moment_T;

/* Zero-crossing (trigger) state */
typedef struct {
  ZCSigState MemoryP_Reset_ZCE;        /* '<S12>/MemoryP' */
  ZCSigState MemoryX_Reset_ZCE;        /* '<S12>/MemoryX' */
} PrevZCX_double_new_moment_T;

/* Backward compatible GRT Identifiers */
#define rtB                            double_new_moment_B
#define BlockIO                        B_double_new_moment_T
#define rtP                            double_new_moment_P
#define Parameters                     P_double_new_moment_T
#define rtDWork                        double_new_moment_DW
#define D_Work                         DW_double_new_moment_T
#define rtPrevZCSigState               double_new_moment_PrevZCX
#define PrevZCSigStates                PrevZCX_double_new_moment_T

/* Parameters (auto storage) */
struct P_double_new_moment_T_ {
  real_T ckfi;                         /* Variable: ckfi
                                        * Referenced by:
                                        *   '<Root>/Gain11'
                                        *   '<Root>/Gain16'
                                        */
  real_T dd;                           /* Variable: dd
                                        * Referenced by:
                                        *   '<Root>/Gain11'
                                        *   '<Root>/Gain16'
                                        */
  real_T dth0i;                        /* Variable: dth0i
                                        * Referenced by: '<Root>/Discrete-Time Integrator'
                                        */
  real_T k[6];                         /* Variable: k
                                        * Referenced by: '<Root>/Gain15'
                                        */
  real_T tf;                           /* Variable: tf
                                        * Referenced by: '<Root>/Switch2'
                                        */
  real_T PIDController1_D;             /* Mask Parameter: PIDController1_D
                                        * Referenced by: '<S19>/Derivative Gain'
                                        */
  real_T PWM_Duty;                     /* Mask Parameter: PWM_Duty
                                        * Referenced by: '<Root>/PWM'
                                        */
  real_T PWM_DutyFinalValue;           /* Mask Parameter: PWM_DutyFinalValue
                                        * Referenced by: '<Root>/PWM'
                                        */
  real_T BRAKE_FinalValue;             /* Mask Parameter: BRAKE_FinalValue
                                        * Referenced by: '<Root>/BRAKE'
                                        */
  real_T DIR_FinalValue;               /* Mask Parameter: DIR_FinalValue
                                        * Referenced by: '<Root>/DIR'
                                        */
  real_T PWM_Frequency;                /* Mask Parameter: PWM_Frequency
                                        * Referenced by: '<Root>/PWM'
                                        */
  real_T PIDController1_I;             /* Mask Parameter: PIDController1_I
                                        * Referenced by: '<S19>/Integral Gain'
                                        */
  real_T DiscreteDerivative2_ICPrevScaledInput;/* Mask Parameter: DiscreteDerivative2_ICPrevScaledInput
                                                * Referenced by: '<S7>/UD'
                                                */
  real_T DiscreteDerivative1_ICPrevScaledInput;/* Mask Parameter: DiscreteDerivative1_ICPrevScaledInput
                                                * Referenced by: '<S6>/UD'
                                                */
  real_T DiscreteDerivative3_ICPrevScaledInput;/* Mask Parameter: DiscreteDerivative3_ICPrevScaledInput
                                                * Referenced by: '<S8>/UD'
                                                */
  real_T BRAKE_InitialValue;           /* Mask Parameter: BRAKE_InitialValue
                                        * Referenced by: '<Root>/BRAKE'
                                        */
  real_T DIR_InitialValue;             /* Mask Parameter: DIR_InitialValue
                                        * Referenced by: '<Root>/DIR'
                                        */
  real_T Motor_InputFilter;            /* Mask Parameter: Motor_InputFilter
                                        * Referenced by: '<Root>/Motor'
                                        */
  real_T Kyvadlo1_InputFilter;         /* Mask Parameter: Kyvadlo1_InputFilter
                                        * Referenced by: '<Root>/Kyvadlo1'
                                        */
  real_T Kyvadlo2_InputFilter;         /* Mask Parameter: Kyvadlo2_InputFilter
                                        * Referenced by: '<Root>/Kyvadlo2'
                                        */
  real_T Motor_MaxMissedTicks;         /* Mask Parameter: Motor_MaxMissedTicks
                                        * Referenced by: '<Root>/Motor'
                                        */
  real_T DigitalInput_MaxMissedTicks;  /* Mask Parameter: DigitalInput_MaxMissedTicks
                                        * Referenced by: '<Root>/Digital Input'
                                        */
  real_T DigitalInput1_MaxMissedTicks; /* Mask Parameter: DigitalInput1_MaxMissedTicks
                                        * Referenced by: '<Root>/Digital Input1'
                                        */
  real_T Kyvadlo1_MaxMissedTicks;      /* Mask Parameter: Kyvadlo1_MaxMissedTicks
                                        * Referenced by: '<Root>/Kyvadlo1'
                                        */
  real_T Kyvadlo2_MaxMissedTicks;      /* Mask Parameter: Kyvadlo2_MaxMissedTicks
                                        * Referenced by: '<Root>/Kyvadlo2'
                                        */
  real_T AnalogInput1_MaxMissedTicks;  /* Mask Parameter: AnalogInput1_MaxMissedTicks
                                        * Referenced by: '<Root>/Analog Input1'
                                        */
  real_T AnalogInput_MaxMissedTicks;   /* Mask Parameter: AnalogInput_MaxMissedTicks
                                        * Referenced by: '<Root>/Analog Input'
                                        */
  real_T BRAKE_MaxMissedTicks;         /* Mask Parameter: BRAKE_MaxMissedTicks
                                        * Referenced by: '<Root>/BRAKE'
                                        */
  real_T DIR_MaxMissedTicks;           /* Mask Parameter: DIR_MaxMissedTicks
                                        * Referenced by: '<Root>/DIR'
                                        */
  real_T PWM_MaxMissedTicks;           /* Mask Parameter: PWM_MaxMissedTicks
                                        * Referenced by: '<Root>/PWM'
                                        */
  real_T PIDController1_N;             /* Mask Parameter: PIDController1_N
                                        * Referenced by: '<S19>/Filter Coefficient'
                                        */
  real_T PIDController1_P;             /* Mask Parameter: PIDController1_P
                                        * Referenced by: '<S19>/Proportional Gain'
                                        */
  real_T Motor_YieldWhenWaiting;       /* Mask Parameter: Motor_YieldWhenWaiting
                                        * Referenced by: '<Root>/Motor'
                                        */
  real_T DigitalInput_YieldWhenWaiting;/* Mask Parameter: DigitalInput_YieldWhenWaiting
                                        * Referenced by: '<Root>/Digital Input'
                                        */
  real_T DigitalInput1_YieldWhenWaiting;/* Mask Parameter: DigitalInput1_YieldWhenWaiting
                                         * Referenced by: '<Root>/Digital Input1'
                                         */
  real_T Kyvadlo1_YieldWhenWaiting;    /* Mask Parameter: Kyvadlo1_YieldWhenWaiting
                                        * Referenced by: '<Root>/Kyvadlo1'
                                        */
  real_T Kyvadlo2_YieldWhenWaiting;    /* Mask Parameter: Kyvadlo2_YieldWhenWaiting
                                        * Referenced by: '<Root>/Kyvadlo2'
                                        */
  real_T AnalogInput1_YieldWhenWaiting;/* Mask Parameter: AnalogInput1_YieldWhenWaiting
                                        * Referenced by: '<Root>/Analog Input1'
                                        */
  real_T AnalogInput_YieldWhenWaiting; /* Mask Parameter: AnalogInput_YieldWhenWaiting
                                        * Referenced by: '<Root>/Analog Input'
                                        */
  real_T BRAKE_YieldWhenWaiting;       /* Mask Parameter: BRAKE_YieldWhenWaiting
                                        * Referenced by: '<Root>/BRAKE'
                                        */
  real_T DIR_YieldWhenWaiting;         /* Mask Parameter: DIR_YieldWhenWaiting
                                        * Referenced by: '<Root>/DIR'
                                        */
  real_T PWM_YieldWhenWaiting;         /* Mask Parameter: PWM_YieldWhenWaiting
                                        * Referenced by: '<Root>/PWM'
                                        */
  int32_T DigitalInput_BitMode;        /* Mask Parameter: DigitalInput_BitMode
                                        * Referenced by: '<Root>/Digital Input'
                                        */
  int32_T DigitalInput1_BitMode;       /* Mask Parameter: DigitalInput1_BitMode
                                        * Referenced by: '<Root>/Digital Input1'
                                        */
  int32_T BRAKE_BitMode;               /* Mask Parameter: BRAKE_BitMode
                                        * Referenced by: '<Root>/BRAKE'
                                        */
  int32_T DIR_BitMode;                 /* Mask Parameter: DIR_BitMode
                                        * Referenced by: '<Root>/DIR'
                                        */
  int32_T Motor_Channels;              /* Mask Parameter: Motor_Channels
                                        * Referenced by: '<Root>/Motor'
                                        */
  int32_T DigitalInput_Channels;       /* Mask Parameter: DigitalInput_Channels
                                        * Referenced by: '<Root>/Digital Input'
                                        */
  int32_T DigitalInput1_Channels;      /* Mask Parameter: DigitalInput1_Channels
                                        * Referenced by: '<Root>/Digital Input1'
                                        */
  int32_T Kyvadlo1_Channels;           /* Mask Parameter: Kyvadlo1_Channels
                                        * Referenced by: '<Root>/Kyvadlo1'
                                        */
  int32_T Kyvadlo2_Channels;           /* Mask Parameter: Kyvadlo2_Channels
                                        * Referenced by: '<Root>/Kyvadlo2'
                                        */
  int32_T AnalogInput1_Channels;       /* Mask Parameter: AnalogInput1_Channels
                                        * Referenced by: '<Root>/Analog Input1'
                                        */
  int32_T AnalogInput_Channels;        /* Mask Parameter: AnalogInput_Channels
                                        * Referenced by: '<Root>/Analog Input'
                                        */
  int32_T BRAKE_Channels;              /* Mask Parameter: BRAKE_Channels
                                        * Referenced by: '<Root>/BRAKE'
                                        */
  int32_T DIR_Channels;                /* Mask Parameter: DIR_Channels
                                        * Referenced by: '<Root>/DIR'
                                        */
  int32_T PWM_Channels;                /* Mask Parameter: PWM_Channels
                                        * Referenced by: '<Root>/PWM'
                                        */
  int32_T AnalogInput1_RangeMode;      /* Mask Parameter: AnalogInput1_RangeMode
                                        * Referenced by: '<Root>/Analog Input1'
                                        */
  int32_T AnalogInput_RangeMode;       /* Mask Parameter: AnalogInput_RangeMode
                                        * Referenced by: '<Root>/Analog Input'
                                        */
  int32_T AnalogInput1_VoltRange;      /* Mask Parameter: AnalogInput1_VoltRange
                                        * Referenced by: '<Root>/Analog Input1'
                                        */
  int32_T AnalogInput_VoltRange;       /* Mask Parameter: AnalogInput_VoltRange
                                        * Referenced by: '<Root>/Analog Input'
                                        */
  real_T Constant13_Value[2];          /* Expression: [0.015 0.25]
                                        * Referenced by: '<Root>/Constant13'
                                        */
  real_T Constant14_Value[2];          /* Expression: [0.02 0.3]
                                        * Referenced by: '<Root>/Constant14'
                                        */
  real_T Constant12_Value[2];          /* Expression: [0.03 0.3]
                                        * Referenced by: '<Root>/Constant12'
                                        */
  real_T C_Gain;                       /* Expression: sps.C
                                        * Referenced by: '<S24>/C'
                                        */
  real_T D_Gain;                       /* Expression: sps.D
                                        * Referenced by: '<S24>/D'
                                        */
  real_T Saturation2_UpperSat;         /* Expression: 0.9
                                        * Referenced by: '<Root>/Saturation2'
                                        */
  real_T Saturation2_LowerSat;         /* Expression: -0.9
                                        * Referenced by: '<Root>/Saturation2'
                                        */
  real_T Constant5_Value[4];           /* Expression: [2 2 25 15]
                                        * Referenced by: '<Root>/Constant5'
                                        */
  real_T Constant4_Value[4];           /* Expression: [35 25 55 30]
                                        * Referenced by: '<Root>/Constant4'
                                        */
  real_T Constant6_Value;              /* Expression: 1
                                        * Referenced by: '<Root>/Constant6'
                                        */
  real_T Constant7_Value;              /* Expression: 0
                                        * Referenced by: '<Root>/Constant7'
                                        */
  real_T Swingupon_Gain;               /* Expression: 0
                                        * Referenced by: '<Root>/Swingup on'
                                        */
  real_T Switch4_Threshold;            /* Expression: 0
                                        * Referenced by: '<Root>/Switch4'
                                        */
  real_T Saturation5_UpperSat;         /* Expression: 0.9
                                        * Referenced by: '<Root>/Saturation5'
                                        */
  real_T Saturation5_LowerSat;         /* Expression: -0.9
                                        * Referenced by: '<Root>/Saturation5'
                                        */
  real_T Switch1_Threshold;            /* Expression: 0
                                        * Referenced by: '<Root>/Switch1'
                                        */
  real_T Switch_Threshold;             /* Expression: 0
                                        * Referenced by: '<Root>/Switch'
                                        */
  real_T Saturation_UpperSat;          /* Expression: 1
                                        * Referenced by: '<Root>/Saturation'
                                        */
  real_T Saturation_LowerSat;          /* Expression: -1
                                        * Referenced by: '<Root>/Saturation'
                                        */
  real_T Poloha_Gain;                  /* Expression: -0.3615
                                        * Referenced by: '<Root>/Poloha'
                                        */
  real_T Constant9_Value;              /* Expression: 50
                                        * Referenced by: '<Root>/Constant9'
                                        */
  real_T Constant8_Value;              /* Expression: 350
                                        * Referenced by: '<Root>/Constant8'
                                        */
  real_T Constant1_Value;              /* Expression: 0.2
                                        * Referenced by: '<Root>/Constant1'
                                        */
  real_T A_Value[49];                  /* Expression: pInitialization.A
                                        * Referenced by: '<S12>/A'
                                        */
  real_T C_Value[28];                  /* Expression: pInitialization.C
                                        * Referenced by: '<S12>/C'
                                        */
  real_T G_Value[49];                  /* Expression: pInitialization.G
                                        * Referenced by: '<S12>/G'
                                        */
  real_T H_Value[28];                  /* Expression: pInitialization.H
                                        * Referenced by: '<S12>/H'
                                        */
  real_T Q_Value[49];                  /* Expression: diag([0.01 0.01 0.01 100 100 100 1])
                                        * Referenced by: '<Root>/Q'
                                        */
  real_T R_Value[16];                  /* Expression: diag([1 10 10 100])
                                        * Referenced by: '<Root>/R'
                                        */
  real_T N_Value[28];                  /* Expression: pInitialization.N
                                        * Referenced by: '<S12>/N'
                                        */
  real_T helvychlenkyvadla_Gain;       /* Expression: 360/(2048)
                                        * Referenced by: '<Root>/Úhel vychýlení kyvadla'
                                        */
  real_T helvychlenkyvadla1_Gain;      /* Expression: 360/(2000)
                                        * Referenced by: '<Root>/Úhel vychýlení kyvadla1'
                                        */
  real_T Constant2_Value;              /* Expression: 1
                                        * Referenced by: '<Root>/Constant2'
                                        */
  real_T Stabilizaceon1_Gain;          /* Expression: 1
                                        * Referenced by: '<Root>/Stabilizace on1'
                                        */
  real_T Q1_Value;                     /* Expression: 1000
                                        * Referenced by: '<Root>/Q1'
                                        */
  real_T u_Value;                      /* Expression: 0
                                        * Referenced by: '<S12>/u'
                                        */
  real_T Gain_Gain;                    /* Expression: 1e-3
                                        * Referenced by: '<Root>/Gain'
                                        */
  real_T Delay_x_InitialCondition;     /* Expression: sps.x0
                                        * Referenced by: '<S24>/Delay_x'
                                        */
  real_T D_Value[4];                   /* Expression: pInitialization.D
                                        * Referenced by: '<S12>/D'
                                        */
  real_T TSamp_WtEt;                   /* Computed Parameter: TSamp_WtEt
                                        * Referenced by: '<S7>/TSamp'
                                        */
  real_T D_Gain_o;                     /* Expression: sps.D
                                        * Referenced by: '<S23>/D'
                                        */
  real_T Delay_x_InitialCondition_i;   /* Expression: sps.x0
                                        * Referenced by: '<S23>/Delay_x'
                                        */
  real_T C_Gain_a;                     /* Expression: sps.C
                                        * Referenced by: '<S23>/C'
                                        */
  real_T Gain1_Gain;                   /* Expression: 1e-3
                                        * Referenced by: '<Root>/Gain1'
                                        */
  real_T filtr1_NumCoef;               /* Expression: [0.0198]
                                        * Referenced by: '<Root>/filtr1'
                                        */
  real_T filtr1_DenCoef[2];            /* Expression: [1 -0.9802]
                                        * Referenced by: '<Root>/filtr1'
                                        */
  real_T filtr1_InitialStates;         /* Expression: 0
                                        * Referenced by: '<Root>/filtr1'
                                        */
  real_T Gain2_Gain;                   /* Expression: pi/180
                                        * Referenced by: '<Root>/Gain2'
                                        */
  real_T filtr3_NumCoef;               /* Expression: [0.0198]
                                        * Referenced by: '<Root>/filtr3'
                                        */
  real_T filtr3_DenCoef[2];            /* Expression: [1 -0.9802]
                                        * Referenced by: '<Root>/filtr3'
                                        */
  real_T filtr3_InitialStates;         /* Expression: 0
                                        * Referenced by: '<Root>/filtr3'
                                        */
  real_T Gain3_Gain;                   /* Expression: pi/180
                                        * Referenced by: '<Root>/Gain3'
                                        */
  real_T Pojezd_Value;                 /* Expression: 0.1290909090909092
                                        * Referenced by: '<Root>/Pojezd'
                                        */
  real_T Gain31_Gain;                  /* Expression: 1
                                        * Referenced by: '<Root>/Gain31'
                                        */
  real_T Gain32_Gain;                  /* Expression: 1
                                        * Referenced by: '<Root>/Gain32'
                                        */
  real_T Gain33_Gain;                  /* Expression: 1
                                        * Referenced by: '<Root>/Gain33'
                                        */
  real_T Gain34_Gain;                  /* Expression: 1
                                        * Referenced by: '<Root>/Gain34'
                                        */
  real_T Gain35_Gain;                  /* Expression: 1
                                        * Referenced by: '<Root>/Gain35'
                                        */
  real_T Gain36_Gain;                  /* Expression: 1
                                        * Referenced by: '<Root>/Gain36'
                                        */
  real_T Gain10_Gain;                  /* Expression: -1
                                        * Referenced by: '<Root>/Gain10'
                                        */
  real_T Gain4_Gain;                   /* Expression: 0.1
                                        * Referenced by: '<Root>/Gain4'
                                        */
  real_T Saturation3_UpperSat;         /* Expression: 2
                                        * Referenced by: '<Root>/Saturation3'
                                        */
  real_T Saturation3_LowerSat;         /* Expression: -2
                                        * Referenced by: '<Root>/Saturation3'
                                        */
  real_T Saturation4_UpperSat;         /* Expression: 20
                                        * Referenced by: '<Root>/Saturation4'
                                        */
  real_T Saturation4_LowerSat;         /* Expression: -20
                                        * Referenced by: '<Root>/Saturation4'
                                        */
  real_T Constant11_Value;             /* Expression: 0.6
                                        * Referenced by: '<Root>/Constant11'
                                        */
  real_T Constant3_Value;              /* Expression: 1.3
                                        * Referenced by: '<Root>/Constant3'
                                        */
  real_T Integrator_gainval;           /* Computed Parameter: Integrator_gainval
                                        * Referenced by: '<S18>/Integrator'
                                        */
  real_T Constant15_Value;             /* Expression: 0.01*0
                                        * Referenced by: '<Root>/Constant15'
                                        */
  real_T Filter_gainval;               /* Computed Parameter: Filter_gainval
                                        * Referenced by: '<S18>/Filter'
                                        */
  real_T Constant16_Value;             /* Expression: 1
                                        * Referenced by: '<Root>/Constant16'
                                        */
  real_T DiscreteTimeIntegrator_gainval;/* Computed Parameter: DiscreteTimeIntegrator_gainval
                                         * Referenced by: '<Root>/Discrete-Time Integrator'
                                         */
  real_T Gain5_Gain;                   /* Expression: -1
                                        * Referenced by: '<Root>/Gain5'
                                        */
  real_T Gain7_Gain;                   /* Expression: 1
                                        * Referenced by: '<Root>/Gain7'
                                        */
  real_T A_Value_j[9];                 /* Expression: pInitialization.A
                                        * Referenced by: '<S13>/A'
                                        */
  real_T C_Value_i[6];                 /* Expression: pInitialization.C
                                        * Referenced by: '<S13>/C'
                                        */
  real_T G_Value_a[9];                 /* Expression: pInitialization.G
                                        * Referenced by: '<S13>/G'
                                        */
  real_T H_Value_p[6];                 /* Expression: pInitialization.H
                                        * Referenced by: '<S13>/H'
                                        */
  real_T Q2_Value[9];                  /* Expression: diag([0.01 100 1])
                                        * Referenced by: '<Root>/Q2'
                                        */
  real_T R1_Value[4];                  /* Expression: diag([1 100])
                                        * Referenced by: '<Root>/R1'
                                        */
  real_T N_Value_l[6];                 /* Expression: pInitialization.N
                                        * Referenced by: '<S13>/N'
                                        */
  real_T P0_Value[9];                  /* Expression: pInitialization.P0
                                        * Referenced by: '<S13>/P0'
                                        */
  real_T u_Value_a;                    /* Expression: 0
                                        * Referenced by: '<S13>/u'
                                        */
  real_T D_Value_i[2];                 /* Expression: pInitialization.D
                                        * Referenced by: '<S13>/D'
                                        */
  real_T X0_Value[3];                  /* Expression: pInitialization.X0
                                        * Referenced by: '<S13>/X0'
                                        */
  real_T Integrator_gainval_i;         /* Computed Parameter: Integrator_gainval_i
                                        * Referenced by: '<S19>/Integrator'
                                        */
  real_T Integrator_IC;                /* Expression: InitialConditionForIntegrator
                                        * Referenced by: '<S19>/Integrator'
                                        */
  real_T Filter_gainval_p;             /* Computed Parameter: Filter_gainval_p
                                        * Referenced by: '<S19>/Filter'
                                        */
  real_T Filter_IC;                    /* Expression: InitialConditionForFilter
                                        * Referenced by: '<S19>/Filter'
                                        */
  real_T Constant_Value;               /* Expression: 0
                                        * Referenced by: '<S3>/Constant'
                                        */
  real_T Constant_Value_o;             /* Expression: 0
                                        * Referenced by: '<S2>/Constant'
                                        */
  real_T Saturation1_UpperSat;         /* Expression: 0.8
                                        * Referenced by: '<Root>/Saturation1'
                                        */
  real_T Saturation1_LowerSat;         /* Expression: -0.8
                                        * Referenced by: '<Root>/Saturation1'
                                        */
  real_T TSamp_WtEt_o;                 /* Computed Parameter: TSamp_WtEt_o
                                        * Referenced by: '<S6>/TSamp'
                                        */
  real_T TSamp_WtEt_i;                 /* Computed Parameter: TSamp_WtEt_i
                                        * Referenced by: '<S8>/TSamp'
                                        */
  real_T A_Gain;                       /* Expression: sps.A
                                        * Referenced by: '<S23>/A'
                                        */
  real_T B_Gain;                       /* Expression: sps.B
                                        * Referenced by: '<S23>/B'
                                        */
  real_T A_Gain_h;                     /* Expression: sps.A
                                        * Referenced by: '<S24>/A'
                                        */
  real_T B_Gain_p;                     /* Expression: sps.B
                                        * Referenced by: '<S24>/B'
                                        */
  real_T B_Value[7];                   /* Expression: pInitialization.B
                                        * Referenced by: '<S12>/B'
                                        */
  real_T B_Value_n[3];                 /* Expression: pInitialization.B
                                        * Referenced by: '<S13>/B'
                                        */
  uint32_T MemoryP_DelayLength;        /* Computed Parameter: MemoryP_DelayLength
                                        * Referenced by: '<S12>/MemoryP'
                                        */
  uint32_T MemoryX_DelayLength;        /* Computed Parameter: MemoryX_DelayLength
                                        * Referenced by: '<S12>/MemoryX'
                                        */
  uint32_T MemoryP_DelayLength_l;      /* Computed Parameter: MemoryP_DelayLength_l
                                        * Referenced by: '<S13>/MemoryP'
                                        */
  uint32_T MemoryX_DelayLength_k;      /* Computed Parameter: MemoryX_DelayLength_k
                                        * Referenced by: '<S13>/MemoryX'
                                        */
  uint8_T ManualSwitch3_CurrentSetting;/* Computed Parameter: ManualSwitch3_CurrentSetting
                                        * Referenced by: '<Root>/Manual Switch3'
                                        */
  uint8_T ManualSwitch6_CurrentSetting;/* Computed Parameter: ManualSwitch6_CurrentSetting
                                        * Referenced by: '<Root>/Manual Switch6'
                                        */
  uint8_T ManualSwitch7_CurrentSetting;/* Computed Parameter: ManualSwitch7_CurrentSetting
                                        * Referenced by: '<Root>/Manual Switch7'
                                        */
  uint8_T ManualSwitch_CurrentSetting; /* Computed Parameter: ManualSwitch_CurrentSetting
                                        * Referenced by: '<Root>/Manual Switch'
                                        */
  uint8_T ManualSwitch2_CurrentSetting;/* Computed Parameter: ManualSwitch2_CurrentSetting
                                        * Referenced by: '<Root>/Manual Switch2'
                                        */
  uint8_T ManualSwitch5_CurrentSetting;/* Computed Parameter: ManualSwitch5_CurrentSetting
                                        * Referenced by: '<Root>/Manual Switch5'
                                        */
  uint8_T ManualSwitch1_CurrentSetting;/* Computed Parameter: ManualSwitch1_CurrentSetting
                                        * Referenced by: '<Root>/Manual Switch1'
                                        */
  uint8_T ManualSwitch4_CurrentSetting;/* Computed Parameter: ManualSwitch4_CurrentSetting
                                        * Referenced by: '<Root>/Manual Switch4'
                                        */
  boolean_T Constant_Value_e;          /* Computed Parameter: Constant_Value_e
                                        * Referenced by: '<S4>/Constant'
                                        */
  boolean_T Constant_Value_c;          /* Computed Parameter: Constant_Value_c
                                        * Referenced by: '<S5>/Constant'
                                        */
  boolean_T Enable_Value;              /* Computed Parameter: Enable_Value
                                        * Referenced by: '<S12>/Enable'
                                        */
  boolean_T Enable_Value_f;            /* Computed Parameter: Enable_Value_f
                                        * Referenced by: '<S13>/Enable'
                                        */
};

/* Real-time Model Data Structure */
struct tag_RTM_double_new_moment_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;
    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 blkStateChange;
    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 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 (auto storage) */
extern P_double_new_moment_T double_new_moment_P;

/* Block signals (auto storage) */
extern B_double_new_moment_T double_new_moment_B;

/* Block states (auto storage) */
extern DW_double_new_moment_T double_new_moment_DW;

/* External data declarations for dependent source files */

/* Zero-crossing (trigger) state */
extern PrevZCX_double_new_moment_T double_new_moment_PrevZCX;

/* Model entry point functions */
extern void double_new_moment_initialize(void);
extern void double_new_moment_output(void);
extern void double_new_moment_update(void);
extern void double_new_moment_terminate(void);

/*====================*
 * External functions *
 *====================*/
extern double_new_moment_rtModel *double_new_moment(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);

/* Real-time Model object */
extern RT_MODEL_double_new_moment_T *const double_new_moment_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>' : 'double_new_moment'
 * '<S1>'   : 'double_new_moment/Chart'
 * '<S2>'   : 'double_new_moment/Compare To Zero'
 * '<S3>'   : 'double_new_moment/Compare To Zero1'
 * '<S4>'   : 'double_new_moment/Compare To Zero2'
 * '<S5>'   : 'double_new_moment/Compare To Zero3'
 * '<S6>'   : 'double_new_moment/Discrete Derivative1'
 * '<S7>'   : 'double_new_moment/Discrete Derivative2'
 * '<S8>'   : 'double_new_moment/Discrete Derivative3'
 * '<S9>'   : 'double_new_moment/First-Order Filter'
 * '<S10>'  : 'double_new_moment/First-Order Filter1'
 * '<S11>'  : 'double_new_moment/First-Order Filter2'
 * '<S12>'  : 'double_new_moment/Kalman Filter'
 * '<S13>'  : 'double_new_moment/Kalman Filter1'
 * '<S14>'  : 'double_new_moment/MATLAB Function'
 * '<S15>'  : 'double_new_moment/MATLAB Function1'
 * '<S16>'  : 'double_new_moment/MATLAB Function2'
 * '<S17>'  : 'double_new_moment/MATLAB Function3'
 * '<S18>'  : 'double_new_moment/PID Controller'
 * '<S19>'  : 'double_new_moment/PID Controller1'
 * '<S20>'  : 'double_new_moment/Spusteni stabilizace'
 * '<S21>'  : 'double_new_moment/Zabezpe&#x10D;ení proti vyjetí'
 * '<S22>'  : 'double_new_moment/First-Order Filter/Model'
 * '<S23>'  : 'double_new_moment/First-Order Filter1/Model'
 * '<S24>'  : 'double_new_moment/First-Order Filter2/Model'
 * '<S25>'  : 'double_new_moment/Kalman Filter/CalculatePL'
 * '<S26>'  : 'double_new_moment/Kalman Filter/CalculateYhat'
 * '<S27>'  : 'double_new_moment/Kalman Filter/DataTypeConversionA'
 * '<S28>'  : 'double_new_moment/Kalman Filter/DataTypeConversionB'
 * '<S29>'  : 'double_new_moment/Kalman Filter/DataTypeConversionC'
 * '<S30>'  : 'double_new_moment/Kalman Filter/DataTypeConversionD'
 * '<S31>'  : 'double_new_moment/Kalman Filter/DataTypeConversionG'
 * '<S32>'  : 'double_new_moment/Kalman Filter/DataTypeConversionH'
 * '<S33>'  : 'double_new_moment/Kalman Filter/DataTypeConversionN'
 * '<S34>'  : 'double_new_moment/Kalman Filter/DataTypeConversionP'
 * '<S35>'  : 'double_new_moment/Kalman Filter/DataTypeConversionP0'
 * '<S36>'  : 'double_new_moment/Kalman Filter/DataTypeConversionQ'
 * '<S37>'  : 'double_new_moment/Kalman Filter/DataTypeConversionR'
 * '<S38>'  : 'double_new_moment/Kalman Filter/DataTypeConversionReset'
 * '<S39>'  : 'double_new_moment/Kalman Filter/DataTypeConversionX'
 * '<S40>'  : 'double_new_moment/Kalman Filter/DataTypeConversionX0'
 * '<S41>'  : 'double_new_moment/Kalman Filter/DataTypeConversionu'
 * '<S42>'  : 'double_new_moment/Kalman Filter/Observer'
 * '<S43>'  : 'double_new_moment/Kalman Filter/ReducedQRN'
 * '<S44>'  : 'double_new_moment/Kalman Filter/ScalarExpansionP0'
 * '<S45>'  : 'double_new_moment/Kalman Filter/ScalarExpansionQ'
 * '<S46>'  : 'double_new_moment/Kalman Filter/ScalarExpansionR'
 * '<S47>'  : 'double_new_moment/Kalman Filter/UseCurrentEstimator'
 * '<S48>'  : 'double_new_moment/Kalman Filter/checkA'
 * '<S49>'  : 'double_new_moment/Kalman Filter/checkB'
 * '<S50>'  : 'double_new_moment/Kalman Filter/checkC'
 * '<S51>'  : 'double_new_moment/Kalman Filter/checkD'
 * '<S52>'  : 'double_new_moment/Kalman Filter/checkEnable'
 * '<S53>'  : 'double_new_moment/Kalman Filter/checkG'
 * '<S54>'  : 'double_new_moment/Kalman Filter/checkH'
 * '<S55>'  : 'double_new_moment/Kalman Filter/checkN'
 * '<S56>'  : 'double_new_moment/Kalman Filter/checkP0'
 * '<S57>'  : 'double_new_moment/Kalman Filter/checkQ'
 * '<S58>'  : 'double_new_moment/Kalman Filter/checkR'
 * '<S59>'  : 'double_new_moment/Kalman Filter/checkReset'
 * '<S60>'  : 'double_new_moment/Kalman Filter/checkX0'
 * '<S61>'  : 'double_new_moment/Kalman Filter/checku'
 * '<S62>'  : 'double_new_moment/Kalman Filter/checky'
 * '<S63>'  : 'double_new_moment/Kalman Filter/CalculatePL/Discrete-Time KF - Calculate PLMZ'
 * '<S64>'  : 'double_new_moment/Kalman Filter/Observer/MeasurementUpdate'
 * '<S65>'  : 'double_new_moment/Kalman Filter/ScalarExpansionP0/ScalarExpansion'
 * '<S66>'  : 'double_new_moment/Kalman Filter/ScalarExpansionQ/ScalarExpansion'
 * '<S67>'  : 'double_new_moment/Kalman Filter/ScalarExpansionR/ScalarExpansion'
 * '<S68>'  : 'double_new_moment/Kalman Filter/UseCurrentEstimator/Enabled Subsystem'
 * '<S69>'  : 'double_new_moment/Kalman Filter1/CalculatePL'
 * '<S70>'  : 'double_new_moment/Kalman Filter1/CalculateYhat'
 * '<S71>'  : 'double_new_moment/Kalman Filter1/DataTypeConversionA'
 * '<S72>'  : 'double_new_moment/Kalman Filter1/DataTypeConversionB'
 * '<S73>'  : 'double_new_moment/Kalman Filter1/DataTypeConversionC'
 * '<S74>'  : 'double_new_moment/Kalman Filter1/DataTypeConversionD'
 * '<S75>'  : 'double_new_moment/Kalman Filter1/DataTypeConversionG'
 * '<S76>'  : 'double_new_moment/Kalman Filter1/DataTypeConversionH'
 * '<S77>'  : 'double_new_moment/Kalman Filter1/DataTypeConversionN'
 * '<S78>'  : 'double_new_moment/Kalman Filter1/DataTypeConversionP'
 * '<S79>'  : 'double_new_moment/Kalman Filter1/DataTypeConversionP0'
 * '<S80>'  : 'double_new_moment/Kalman Filter1/DataTypeConversionQ'
 * '<S81>'  : 'double_new_moment/Kalman Filter1/DataTypeConversionR'
 * '<S82>'  : 'double_new_moment/Kalman Filter1/DataTypeConversionReset'
 * '<S83>'  : 'double_new_moment/Kalman Filter1/DataTypeConversionX'
 * '<S84>'  : 'double_new_moment/Kalman Filter1/DataTypeConversionX0'
 * '<S85>'  : 'double_new_moment/Kalman Filter1/DataTypeConversionu'
 * '<S86>'  : 'double_new_moment/Kalman Filter1/Observer'
 * '<S87>'  : 'double_new_moment/Kalman Filter1/ReducedQRN'
 * '<S88>'  : 'double_new_moment/Kalman Filter1/ScalarExpansionP0'
 * '<S89>'  : 'double_new_moment/Kalman Filter1/ScalarExpansionQ'
 * '<S90>'  : 'double_new_moment/Kalman Filter1/ScalarExpansionR'
 * '<S91>'  : 'double_new_moment/Kalman Filter1/UseCurrentEstimator'
 * '<S92>'  : 'double_new_moment/Kalman Filter1/checkA'
 * '<S93>'  : 'double_new_moment/Kalman Filter1/checkB'
 * '<S94>'  : 'double_new_moment/Kalman Filter1/checkC'
 * '<S95>'  : 'double_new_moment/Kalman Filter1/checkD'
 * '<S96>'  : 'double_new_moment/Kalman Filter1/checkEnable'
 * '<S97>'  : 'double_new_moment/Kalman Filter1/checkG'
 * '<S98>'  : 'double_new_moment/Kalman Filter1/checkH'
 * '<S99>'  : 'double_new_moment/Kalman Filter1/checkN'
 * '<S100>' : 'double_new_moment/Kalman Filter1/checkP0'
 * '<S101>' : 'double_new_moment/Kalman Filter1/checkQ'
 * '<S102>' : 'double_new_moment/Kalman Filter1/checkR'
 * '<S103>' : 'double_new_moment/Kalman Filter1/checkReset'
 * '<S104>' : 'double_new_moment/Kalman Filter1/checkX0'
 * '<S105>' : 'double_new_moment/Kalman Filter1/checku'
 * '<S106>' : 'double_new_moment/Kalman Filter1/checky'
 * '<S107>' : 'double_new_moment/Kalman Filter1/CalculatePL/Discrete-Time KF - Calculate PLMZ'
 * '<S108>' : 'double_new_moment/Kalman Filter1/Observer/MeasurementUpdate'
 * '<S109>' : 'double_new_moment/Kalman Filter1/ScalarExpansionQ/ScalarExpansion'
 * '<S110>' : 'double_new_moment/Kalman Filter1/ScalarExpansionR/ScalarExpansion'
 * '<S111>' : 'double_new_moment/Kalman Filter1/UseCurrentEstimator/Enabled Subsystem'
 */
#endif                                 /* RTW_HEADER_double_new_moment_h_ */
