mirror of
https://github.com/Dev-KATECH/ADM.git
synced 2026-05-17 01:43:59 +09:00
2004 lines
78 KiB
C
2004 lines
78 KiB
C
/*
|
|
* WheelSpd1.h
|
|
*
|
|
* Academic License - for use in teaching, academic research, and meeting
|
|
* course requirements at degree granting institutions only. Not for
|
|
* government, commercial, or other organizational use.
|
|
*
|
|
* Code generation for model "WheelSpd1".
|
|
*
|
|
* Model version : 1.397
|
|
* Simulink Coder version : 8.14 (R2018a) 06-Feb-2018
|
|
* C source code generated on : Tue Jul 11 16:56:29 2023
|
|
*
|
|
* Target selection: slrt.tlc
|
|
* Note: GRT includes extra infrastructure and instrumentation for prototyping
|
|
* Embedded hardware selection: Generic->32-bit x86 compatible
|
|
* Code generation objectives: Unspecified
|
|
* Validation result: Not run
|
|
*/
|
|
|
|
#ifndef RTW_HEADER_WheelSpd1_h_
|
|
#define RTW_HEADER_WheelSpd1_h_
|
|
#include <math.h>
|
|
#include <stddef.h>
|
|
#include <string.h>
|
|
#include "rtw_modelmap.h"
|
|
#ifndef WheelSpd1_COMMON_INCLUDES_
|
|
# define WheelSpd1_COMMON_INCLUDES_
|
|
#include <string.h>
|
|
#include <xpcimports.h>
|
|
#include <xpcdatatypes.h>
|
|
#include "rtwtypes.h"
|
|
#include "zero_crossing_types.h"
|
|
#include "simstruc.h"
|
|
#include "fixedpoint.h"
|
|
#include "rt_logging.h"
|
|
#include "can_message.h"
|
|
#endif /* WheelSpd1_COMMON_INCLUDES_ */
|
|
|
|
#include "WheelSpd1_types.h"
|
|
|
|
/* Shared type includes */
|
|
#include "multiword_types.h"
|
|
#include "rt_nonfinite.h"
|
|
#include "rt_defines.h"
|
|
|
|
/* Macros for accessing real-time model data structure */
|
|
#ifndef rtmGetBlockIO
|
|
# define rtmGetBlockIO(rtm) ((rtm)->blockIO)
|
|
#endif
|
|
|
|
#ifndef rtmSetBlockIO
|
|
# define rtmSetBlockIO(rtm, val) ((rtm)->blockIO = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetChecksums
|
|
# define rtmGetChecksums(rtm) ((rtm)->Sizes.checksums)
|
|
#endif
|
|
|
|
#ifndef rtmSetChecksums
|
|
# define rtmSetChecksums(rtm, val) ((rtm)->Sizes.checksums = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetConstBlockIO
|
|
# define rtmGetConstBlockIO(rtm) ((rtm)->constBlockIO)
|
|
#endif
|
|
|
|
#ifndef rtmSetConstBlockIO
|
|
# define rtmSetConstBlockIO(rtm, val) ((rtm)->constBlockIO = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetContStateDisabled
|
|
# define rtmGetContStateDisabled(rtm) ((rtm)->contStateDisabled)
|
|
#endif
|
|
|
|
#ifndef rtmSetContStateDisabled
|
|
# define rtmSetContStateDisabled(rtm, val) ((rtm)->contStateDisabled = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetContStates
|
|
# define rtmGetContStates(rtm) ((rtm)->contStates)
|
|
#endif
|
|
|
|
#ifndef rtmSetContStates
|
|
# define rtmSetContStates(rtm, val) ((rtm)->contStates = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetContTimeOutputInconsistentWithStateAtMajorStepFlag
|
|
# define rtmGetContTimeOutputInconsistentWithStateAtMajorStepFlag(rtm) ((rtm)->CTOutputIncnstWithState)
|
|
#endif
|
|
|
|
#ifndef rtmSetContTimeOutputInconsistentWithStateAtMajorStepFlag
|
|
# define rtmSetContTimeOutputInconsistentWithStateAtMajorStepFlag(rtm, val) ((rtm)->CTOutputIncnstWithState = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetCtrlRateMdlRefTiming
|
|
# define rtmGetCtrlRateMdlRefTiming(rtm) ()
|
|
#endif
|
|
|
|
#ifndef rtmSetCtrlRateMdlRefTiming
|
|
# define rtmSetCtrlRateMdlRefTiming(rtm, val) ()
|
|
#endif
|
|
|
|
#ifndef rtmGetCtrlRateMdlRefTimingPtr
|
|
# define rtmGetCtrlRateMdlRefTimingPtr(rtm) ()
|
|
#endif
|
|
|
|
#ifndef rtmSetCtrlRateMdlRefTimingPtr
|
|
# define rtmSetCtrlRateMdlRefTimingPtr(rtm, val) ()
|
|
#endif
|
|
|
|
#ifndef rtmGetCtrlRateNumTicksToNextHit
|
|
# define rtmGetCtrlRateNumTicksToNextHit(rtm) ()
|
|
#endif
|
|
|
|
#ifndef rtmSetCtrlRateNumTicksToNextHit
|
|
# define rtmSetCtrlRateNumTicksToNextHit(rtm, val) ()
|
|
#endif
|
|
|
|
#ifndef rtmGetDataMapInfo
|
|
# define rtmGetDataMapInfo(rtm) ((rtm)->DataMapInfo)
|
|
#endif
|
|
|
|
#ifndef rtmSetDataMapInfo
|
|
# define rtmSetDataMapInfo(rtm, val) ((rtm)->DataMapInfo = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetDefaultParam
|
|
# define rtmGetDefaultParam(rtm) ((rtm)->defaultParam)
|
|
#endif
|
|
|
|
#ifndef rtmSetDefaultParam
|
|
# define rtmSetDefaultParam(rtm, val) ((rtm)->defaultParam = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetDerivCacheNeedsReset
|
|
# define rtmGetDerivCacheNeedsReset(rtm) ((rtm)->derivCacheNeedsReset)
|
|
#endif
|
|
|
|
#ifndef rtmSetDerivCacheNeedsReset
|
|
# define rtmSetDerivCacheNeedsReset(rtm, val) ((rtm)->derivCacheNeedsReset = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetDirectFeedThrough
|
|
# define rtmGetDirectFeedThrough(rtm) ((rtm)->Sizes.sysDirFeedThru)
|
|
#endif
|
|
|
|
#ifndef rtmSetDirectFeedThrough
|
|
# define rtmSetDirectFeedThrough(rtm, val) ((rtm)->Sizes.sysDirFeedThru = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetErrorStatusFlag
|
|
# define rtmGetErrorStatusFlag(rtm) ((rtm)->errorStatus)
|
|
#endif
|
|
|
|
#ifndef rtmSetErrorStatusFlag
|
|
# define rtmSetErrorStatusFlag(rtm, val) ((rtm)->errorStatus = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetFinalTime
|
|
# define rtmGetFinalTime(rtm) ((rtm)->Timing.tFinal)
|
|
#endif
|
|
|
|
#ifndef rtmSetFinalTime
|
|
# define rtmSetFinalTime(rtm, val) ((rtm)->Timing.tFinal = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetFirstInitCondFlag
|
|
# define rtmGetFirstInitCondFlag(rtm) ()
|
|
#endif
|
|
|
|
#ifndef rtmSetFirstInitCondFlag
|
|
# define rtmSetFirstInitCondFlag(rtm, val) ()
|
|
#endif
|
|
|
|
#ifndef rtmGetIntgData
|
|
# define rtmGetIntgData(rtm) ()
|
|
#endif
|
|
|
|
#ifndef rtmSetIntgData
|
|
# define rtmSetIntgData(rtm, val) ()
|
|
#endif
|
|
|
|
#ifndef rtmGetMdlRefGlobalTID
|
|
# define rtmGetMdlRefGlobalTID(rtm) ()
|
|
#endif
|
|
|
|
#ifndef rtmSetMdlRefGlobalTID
|
|
# define rtmSetMdlRefGlobalTID(rtm, val) ()
|
|
#endif
|
|
|
|
#ifndef rtmGetMdlRefTriggerTID
|
|
# define rtmGetMdlRefTriggerTID(rtm) ()
|
|
#endif
|
|
|
|
#ifndef rtmSetMdlRefTriggerTID
|
|
# define rtmSetMdlRefTriggerTID(rtm, val) ()
|
|
#endif
|
|
|
|
#ifndef rtmGetModelMappingInfo
|
|
# define rtmGetModelMappingInfo(rtm) ((rtm)->SpecialInfo.mappingInfo)
|
|
#endif
|
|
|
|
#ifndef rtmSetModelMappingInfo
|
|
# define rtmSetModelMappingInfo(rtm, val) ((rtm)->SpecialInfo.mappingInfo = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetModelName
|
|
# define rtmGetModelName(rtm) ((rtm)->modelName)
|
|
#endif
|
|
|
|
#ifndef rtmSetModelName
|
|
# define rtmSetModelName(rtm, val) ((rtm)->modelName = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetNonInlinedSFcns
|
|
# define rtmGetNonInlinedSFcns(rtm) ((rtm)->NonInlinedSFcns)
|
|
#endif
|
|
|
|
#ifndef rtmSetNonInlinedSFcns
|
|
# define rtmSetNonInlinedSFcns(rtm, val) ((rtm)->NonInlinedSFcns = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetNumBlockIO
|
|
# define rtmGetNumBlockIO(rtm) ((rtm)->Sizes.numBlockIO)
|
|
#endif
|
|
|
|
#ifndef rtmSetNumBlockIO
|
|
# define rtmSetNumBlockIO(rtm, val) ((rtm)->Sizes.numBlockIO = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetNumBlockParams
|
|
# define rtmGetNumBlockParams(rtm) ((rtm)->Sizes.numBlockPrms)
|
|
#endif
|
|
|
|
#ifndef rtmSetNumBlockParams
|
|
# define rtmSetNumBlockParams(rtm, val) ((rtm)->Sizes.numBlockPrms = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetNumBlocks
|
|
# define rtmGetNumBlocks(rtm) ((rtm)->Sizes.numBlocks)
|
|
#endif
|
|
|
|
#ifndef rtmSetNumBlocks
|
|
# define rtmSetNumBlocks(rtm, val) ((rtm)->Sizes.numBlocks = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetNumContStates
|
|
# define rtmGetNumContStates(rtm) ((rtm)->Sizes.numContStates)
|
|
#endif
|
|
|
|
#ifndef rtmSetNumContStates
|
|
# define rtmSetNumContStates(rtm, val) ((rtm)->Sizes.numContStates = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetNumDWork
|
|
# define rtmGetNumDWork(rtm) ((rtm)->Sizes.numDwork)
|
|
#endif
|
|
|
|
#ifndef rtmSetNumDWork
|
|
# define rtmSetNumDWork(rtm, val) ((rtm)->Sizes.numDwork = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetNumInputPorts
|
|
# define rtmGetNumInputPorts(rtm) ((rtm)->Sizes.numIports)
|
|
#endif
|
|
|
|
#ifndef rtmSetNumInputPorts
|
|
# define rtmSetNumInputPorts(rtm, val) ((rtm)->Sizes.numIports = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetNumNonSampledZCs
|
|
# define rtmGetNumNonSampledZCs(rtm) ((rtm)->Sizes.numNonSampZCs)
|
|
#endif
|
|
|
|
#ifndef rtmSetNumNonSampledZCs
|
|
# define rtmSetNumNonSampledZCs(rtm, val) ((rtm)->Sizes.numNonSampZCs = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetNumOutputPorts
|
|
# define rtmGetNumOutputPorts(rtm) ((rtm)->Sizes.numOports)
|
|
#endif
|
|
|
|
#ifndef rtmSetNumOutputPorts
|
|
# define rtmSetNumOutputPorts(rtm, val) ((rtm)->Sizes.numOports = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetNumPeriodicContStates
|
|
# define rtmGetNumPeriodicContStates(rtm) ((rtm)->Sizes.numPeriodicContStates)
|
|
#endif
|
|
|
|
#ifndef rtmSetNumPeriodicContStates
|
|
# define rtmSetNumPeriodicContStates(rtm, val) ((rtm)->Sizes.numPeriodicContStates = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetNumSFcnParams
|
|
# define rtmGetNumSFcnParams(rtm) ((rtm)->Sizes.numSFcnPrms)
|
|
#endif
|
|
|
|
#ifndef rtmSetNumSFcnParams
|
|
# define rtmSetNumSFcnParams(rtm, val) ((rtm)->Sizes.numSFcnPrms = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetNumSFunctions
|
|
# define rtmGetNumSFunctions(rtm) ((rtm)->Sizes.numSFcns)
|
|
#endif
|
|
|
|
#ifndef rtmSetNumSFunctions
|
|
# define rtmSetNumSFunctions(rtm, val) ((rtm)->Sizes.numSFcns = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetNumSampleTimes
|
|
# define rtmGetNumSampleTimes(rtm) ((rtm)->Sizes.numSampTimes)
|
|
#endif
|
|
|
|
#ifndef rtmSetNumSampleTimes
|
|
# define rtmSetNumSampleTimes(rtm, val) ((rtm)->Sizes.numSampTimes = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetNumU
|
|
# define rtmGetNumU(rtm) ((rtm)->Sizes.numU)
|
|
#endif
|
|
|
|
#ifndef rtmSetNumU
|
|
# define rtmSetNumU(rtm, val) ((rtm)->Sizes.numU = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetNumY
|
|
# define rtmGetNumY(rtm) ((rtm)->Sizes.numY)
|
|
#endif
|
|
|
|
#ifndef rtmSetNumY
|
|
# define rtmSetNumY(rtm, val) ((rtm)->Sizes.numY = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetOdeF
|
|
# define rtmGetOdeF(rtm) ()
|
|
#endif
|
|
|
|
#ifndef rtmSetOdeF
|
|
# define rtmSetOdeF(rtm, val) ()
|
|
#endif
|
|
|
|
#ifndef rtmGetOdeY
|
|
# define rtmGetOdeY(rtm) ()
|
|
#endif
|
|
|
|
#ifndef rtmSetOdeY
|
|
# define rtmSetOdeY(rtm, val) ()
|
|
#endif
|
|
|
|
#ifndef rtmGetOffsetTimeArray
|
|
# define rtmGetOffsetTimeArray(rtm) ((rtm)->Timing.offsetTimesArray)
|
|
#endif
|
|
|
|
#ifndef rtmSetOffsetTimeArray
|
|
# define rtmSetOffsetTimeArray(rtm, val) ((rtm)->Timing.offsetTimesArray = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetOffsetTimePtr
|
|
# define rtmGetOffsetTimePtr(rtm) ((rtm)->Timing.offsetTimes)
|
|
#endif
|
|
|
|
#ifndef rtmSetOffsetTimePtr
|
|
# define rtmSetOffsetTimePtr(rtm, val) ((rtm)->Timing.offsetTimes = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetOptions
|
|
# define rtmGetOptions(rtm) ((rtm)->Sizes.options)
|
|
#endif
|
|
|
|
#ifndef rtmSetOptions
|
|
# define rtmSetOptions(rtm, val) ((rtm)->Sizes.options = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetParamIsMalloced
|
|
# define rtmGetParamIsMalloced(rtm) ()
|
|
#endif
|
|
|
|
#ifndef rtmSetParamIsMalloced
|
|
# define rtmSetParamIsMalloced(rtm, val) ()
|
|
#endif
|
|
|
|
#ifndef rtmGetPath
|
|
# define rtmGetPath(rtm) ((rtm)->path)
|
|
#endif
|
|
|
|
#ifndef rtmSetPath
|
|
# define rtmSetPath(rtm, val) ((rtm)->path = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetPerTaskSampleHits
|
|
# define rtmGetPerTaskSampleHits(rtm) ()
|
|
#endif
|
|
|
|
#ifndef rtmSetPerTaskSampleHits
|
|
# define rtmSetPerTaskSampleHits(rtm, val) ()
|
|
#endif
|
|
|
|
#ifndef rtmGetPerTaskSampleHitsArray
|
|
# define rtmGetPerTaskSampleHitsArray(rtm) ((rtm)->Timing.perTaskSampleHitsArray)
|
|
#endif
|
|
|
|
#ifndef rtmSetPerTaskSampleHitsArray
|
|
# define rtmSetPerTaskSampleHitsArray(rtm, val) ((rtm)->Timing.perTaskSampleHitsArray = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetPerTaskSampleHitsPtr
|
|
# define rtmGetPerTaskSampleHitsPtr(rtm) ((rtm)->Timing.perTaskSampleHits)
|
|
#endif
|
|
|
|
#ifndef rtmSetPerTaskSampleHitsPtr
|
|
# define rtmSetPerTaskSampleHitsPtr(rtm, val) ((rtm)->Timing.perTaskSampleHits = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetPeriodicContStateIndices
|
|
# define rtmGetPeriodicContStateIndices(rtm) ((rtm)->periodicContStateIndices)
|
|
#endif
|
|
|
|
#ifndef rtmSetPeriodicContStateIndices
|
|
# define rtmSetPeriodicContStateIndices(rtm, val) ((rtm)->periodicContStateIndices = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetPeriodicContStateRanges
|
|
# define rtmGetPeriodicContStateRanges(rtm) ((rtm)->periodicContStateRanges)
|
|
#endif
|
|
|
|
#ifndef rtmSetPeriodicContStateRanges
|
|
# define rtmSetPeriodicContStateRanges(rtm, val) ((rtm)->periodicContStateRanges = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetPrevZCSigState
|
|
# define rtmGetPrevZCSigState(rtm) ((rtm)->prevZCSigState)
|
|
#endif
|
|
|
|
#ifndef rtmSetPrevZCSigState
|
|
# define rtmSetPrevZCSigState(rtm, val) ((rtm)->prevZCSigState = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetRTWExtModeInfo
|
|
# define rtmGetRTWExtModeInfo(rtm) ((rtm)->extModeInfo)
|
|
#endif
|
|
|
|
#ifndef rtmSetRTWExtModeInfo
|
|
# define rtmSetRTWExtModeInfo(rtm, val) ((rtm)->extModeInfo = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetRTWGeneratedSFcn
|
|
# define rtmGetRTWGeneratedSFcn(rtm) ((rtm)->Sizes.rtwGenSfcn)
|
|
#endif
|
|
|
|
#ifndef rtmSetRTWGeneratedSFcn
|
|
# define rtmSetRTWGeneratedSFcn(rtm, val) ((rtm)->Sizes.rtwGenSfcn = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetRTWLogInfo
|
|
# define rtmGetRTWLogInfo(rtm) ((rtm)->rtwLogInfo)
|
|
#endif
|
|
|
|
#ifndef rtmSetRTWLogInfo
|
|
# define rtmSetRTWLogInfo(rtm, val) ((rtm)->rtwLogInfo = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetRTWRTModelMethodsInfo
|
|
# define rtmGetRTWRTModelMethodsInfo(rtm) ()
|
|
#endif
|
|
|
|
#ifndef rtmSetRTWRTModelMethodsInfo
|
|
# define rtmSetRTWRTModelMethodsInfo(rtm, val) ()
|
|
#endif
|
|
|
|
#ifndef rtmGetRTWSfcnInfo
|
|
# define rtmGetRTWSfcnInfo(rtm) ((rtm)->sfcnInfo)
|
|
#endif
|
|
|
|
#ifndef rtmSetRTWSfcnInfo
|
|
# define rtmSetRTWSfcnInfo(rtm, val) ((rtm)->sfcnInfo = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetRTWSolverInfo
|
|
# define rtmGetRTWSolverInfo(rtm) ((rtm)->solverInfo)
|
|
#endif
|
|
|
|
#ifndef rtmSetRTWSolverInfo
|
|
# define rtmSetRTWSolverInfo(rtm, val) ((rtm)->solverInfo = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetRTWSolverInfoPtr
|
|
# define rtmGetRTWSolverInfoPtr(rtm) ((rtm)->solverInfoPtr)
|
|
#endif
|
|
|
|
#ifndef rtmSetRTWSolverInfoPtr
|
|
# define rtmSetRTWSolverInfoPtr(rtm, val) ((rtm)->solverInfoPtr = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetReservedForXPC
|
|
# define rtmGetReservedForXPC(rtm) ((rtm)->SpecialInfo.xpcData)
|
|
#endif
|
|
|
|
#ifndef rtmSetReservedForXPC
|
|
# define rtmSetReservedForXPC(rtm, val) ((rtm)->SpecialInfo.xpcData = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetRootDWork
|
|
# define rtmGetRootDWork(rtm) ((rtm)->dwork)
|
|
#endif
|
|
|
|
#ifndef rtmSetRootDWork
|
|
# define rtmSetRootDWork(rtm, val) ((rtm)->dwork = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetSFunctions
|
|
# define rtmGetSFunctions(rtm) ((rtm)->childSfunctions)
|
|
#endif
|
|
|
|
#ifndef rtmSetSFunctions
|
|
# define rtmSetSFunctions(rtm, val) ((rtm)->childSfunctions = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetSampleHitArray
|
|
# define rtmGetSampleHitArray(rtm) ((rtm)->Timing.sampleHitArray)
|
|
#endif
|
|
|
|
#ifndef rtmSetSampleHitArray
|
|
# define rtmSetSampleHitArray(rtm, val) ((rtm)->Timing.sampleHitArray = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetSampleHitPtr
|
|
# define rtmGetSampleHitPtr(rtm) ((rtm)->Timing.sampleHits)
|
|
#endif
|
|
|
|
#ifndef rtmSetSampleHitPtr
|
|
# define rtmSetSampleHitPtr(rtm, val) ((rtm)->Timing.sampleHits = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetSampleTimeArray
|
|
# define rtmGetSampleTimeArray(rtm) ((rtm)->Timing.sampleTimesArray)
|
|
#endif
|
|
|
|
#ifndef rtmSetSampleTimeArray
|
|
# define rtmSetSampleTimeArray(rtm, val) ((rtm)->Timing.sampleTimesArray = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetSampleTimePtr
|
|
# define rtmGetSampleTimePtr(rtm) ((rtm)->Timing.sampleTimes)
|
|
#endif
|
|
|
|
#ifndef rtmSetSampleTimePtr
|
|
# define rtmSetSampleTimePtr(rtm, val) ((rtm)->Timing.sampleTimes = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetSampleTimeTaskIDArray
|
|
# define rtmGetSampleTimeTaskIDArray(rtm) ((rtm)->Timing.sampleTimeTaskIDArray)
|
|
#endif
|
|
|
|
#ifndef rtmSetSampleTimeTaskIDArray
|
|
# define rtmSetSampleTimeTaskIDArray(rtm, val) ((rtm)->Timing.sampleTimeTaskIDArray = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetSampleTimeTaskIDPtr
|
|
# define rtmGetSampleTimeTaskIDPtr(rtm) ((rtm)->Timing.sampleTimeTaskIDPtr)
|
|
#endif
|
|
|
|
#ifndef rtmSetSampleTimeTaskIDPtr
|
|
# define rtmSetSampleTimeTaskIDPtr(rtm, val) ((rtm)->Timing.sampleTimeTaskIDPtr = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetSelf
|
|
# define rtmGetSelf(rtm) ()
|
|
#endif
|
|
|
|
#ifndef rtmSetSelf
|
|
# define rtmSetSelf(rtm, val) ()
|
|
#endif
|
|
|
|
#ifndef rtmGetSimMode
|
|
# define rtmGetSimMode(rtm) ((rtm)->simMode)
|
|
#endif
|
|
|
|
#ifndef rtmSetSimMode
|
|
# define rtmSetSimMode(rtm, val) ((rtm)->simMode = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetSimTimeStep
|
|
# define rtmGetSimTimeStep(rtm) ((rtm)->Timing.simTimeStep)
|
|
#endif
|
|
|
|
#ifndef rtmSetSimTimeStep
|
|
# define rtmSetSimTimeStep(rtm, val) ((rtm)->Timing.simTimeStep = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetStartTime
|
|
# define rtmGetStartTime(rtm) ((rtm)->Timing.tStart)
|
|
#endif
|
|
|
|
#ifndef rtmSetStartTime
|
|
# define rtmSetStartTime(rtm, val) ((rtm)->Timing.tStart = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetStepSize
|
|
# define rtmGetStepSize(rtm) ((rtm)->Timing.stepSize)
|
|
#endif
|
|
|
|
#ifndef rtmSetStepSize
|
|
# define rtmSetStepSize(rtm, val) ((rtm)->Timing.stepSize = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetStopRequestedFlag
|
|
# define rtmGetStopRequestedFlag(rtm) ((rtm)->Timing.stopRequestedFlag)
|
|
#endif
|
|
|
|
#ifndef rtmSetStopRequestedFlag
|
|
# define rtmSetStopRequestedFlag(rtm, val) ((rtm)->Timing.stopRequestedFlag = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetTaskCounters
|
|
# define rtmGetTaskCounters(rtm) ()
|
|
#endif
|
|
|
|
#ifndef rtmSetTaskCounters
|
|
# define rtmSetTaskCounters(rtm, val) ()
|
|
#endif
|
|
|
|
#ifndef rtmGetTaskTimeArray
|
|
# define rtmGetTaskTimeArray(rtm) ((rtm)->Timing.tArray)
|
|
#endif
|
|
|
|
#ifndef rtmSetTaskTimeArray
|
|
# define rtmSetTaskTimeArray(rtm, val) ((rtm)->Timing.tArray = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetTimePtr
|
|
# define rtmGetTimePtr(rtm) ((rtm)->Timing.t)
|
|
#endif
|
|
|
|
#ifndef rtmSetTimePtr
|
|
# define rtmSetTimePtr(rtm, val) ((rtm)->Timing.t = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetTimingData
|
|
# define rtmGetTimingData(rtm) ((rtm)->Timing.timingData)
|
|
#endif
|
|
|
|
#ifndef rtmSetTimingData
|
|
# define rtmSetTimingData(rtm, val) ((rtm)->Timing.timingData = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetU
|
|
# define rtmGetU(rtm) ((rtm)->inputs)
|
|
#endif
|
|
|
|
#ifndef rtmSetU
|
|
# define rtmSetU(rtm, val) ((rtm)->inputs = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetVarNextHitTimesListPtr
|
|
# define rtmGetVarNextHitTimesListPtr(rtm) ((rtm)->Timing.varNextHitTimesList)
|
|
#endif
|
|
|
|
#ifndef rtmSetVarNextHitTimesListPtr
|
|
# define rtmSetVarNextHitTimesListPtr(rtm, val) ((rtm)->Timing.varNextHitTimesList = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetY
|
|
# define rtmGetY(rtm) ((rtm)->outputs)
|
|
#endif
|
|
|
|
#ifndef rtmSetY
|
|
# define rtmSetY(rtm, val) ((rtm)->outputs = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetZCCacheNeedsReset
|
|
# define rtmGetZCCacheNeedsReset(rtm) ((rtm)->zCCacheNeedsReset)
|
|
#endif
|
|
|
|
#ifndef rtmSetZCCacheNeedsReset
|
|
# define rtmSetZCCacheNeedsReset(rtm, val) ((rtm)->zCCacheNeedsReset = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetZCSignalValues
|
|
# define rtmGetZCSignalValues(rtm) ((rtm)->zcSignalValues)
|
|
#endif
|
|
|
|
#ifndef rtmSetZCSignalValues
|
|
# define rtmSetZCSignalValues(rtm, val) ((rtm)->zcSignalValues = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGet_TimeOfLastOutput
|
|
# define rtmGet_TimeOfLastOutput(rtm) ((rtm)->Timing.timeOfLastOutput)
|
|
#endif
|
|
|
|
#ifndef rtmSet_TimeOfLastOutput
|
|
# define rtmSet_TimeOfLastOutput(rtm, val) ((rtm)->Timing.timeOfLastOutput = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetdX
|
|
# define rtmGetdX(rtm) ((rtm)->derivs)
|
|
#endif
|
|
|
|
#ifndef rtmSetdX
|
|
# define rtmSetdX(rtm, val) ((rtm)->derivs = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGettimingBridge
|
|
# define rtmGettimingBridge(rtm) ()
|
|
#endif
|
|
|
|
#ifndef rtmSettimingBridge
|
|
# define rtmSettimingBridge(rtm, val) ()
|
|
#endif
|
|
|
|
#ifndef rtmGetChecksumVal
|
|
# define rtmGetChecksumVal(rtm, idx) ((rtm)->Sizes.checksums[idx])
|
|
#endif
|
|
|
|
#ifndef rtmSetChecksumVal
|
|
# define rtmSetChecksumVal(rtm, idx, val) ((rtm)->Sizes.checksums[idx] = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetDWork
|
|
# define rtmGetDWork(rtm, idx) ((rtm)->dwork[idx])
|
|
#endif
|
|
|
|
#ifndef rtmSetDWork
|
|
# define rtmSetDWork(rtm, idx, val) ((rtm)->dwork[idx] = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetOffsetTime
|
|
# define rtmGetOffsetTime(rtm, idx) ((rtm)->Timing.offsetTimes[idx])
|
|
#endif
|
|
|
|
#ifndef rtmSetOffsetTime
|
|
# define rtmSetOffsetTime(rtm, idx, val) ((rtm)->Timing.offsetTimes[idx] = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetSFunction
|
|
# define rtmGetSFunction(rtm, idx) ((rtm)->childSfunctions[idx])
|
|
#endif
|
|
|
|
#ifndef rtmSetSFunction
|
|
# define rtmSetSFunction(rtm, idx, val) ((rtm)->childSfunctions[idx] = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetSampleTime
|
|
# define rtmGetSampleTime(rtm, idx) ((rtm)->Timing.sampleTimes[idx])
|
|
#endif
|
|
|
|
#ifndef rtmSetSampleTime
|
|
# define rtmSetSampleTime(rtm, idx, val) ((rtm)->Timing.sampleTimes[idx] = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetSampleTimeTaskID
|
|
# define rtmGetSampleTimeTaskID(rtm, idx) ((rtm)->Timing.sampleTimeTaskIDPtr[idx])
|
|
#endif
|
|
|
|
#ifndef rtmSetSampleTimeTaskID
|
|
# define rtmSetSampleTimeTaskID(rtm, idx, val) ((rtm)->Timing.sampleTimeTaskIDPtr[idx] = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetVarNextHitTimeList
|
|
# define rtmGetVarNextHitTimeList(rtm, idx) ((rtm)->Timing.varNextHitTimesList[idx])
|
|
#endif
|
|
|
|
#ifndef rtmSetVarNextHitTimeList
|
|
# define rtmSetVarNextHitTimeList(rtm, idx, val) ((rtm)->Timing.varNextHitTimesList[idx] = (val))
|
|
#endif
|
|
|
|
#ifndef rtmIsContinuousTask
|
|
# define rtmIsContinuousTask(rtm, tid) ((tid) == 0)
|
|
#endif
|
|
|
|
#ifndef rtmGetErrorStatus
|
|
# define rtmGetErrorStatus(rtm) ((rtm)->errorStatus)
|
|
#endif
|
|
|
|
#ifndef rtmSetErrorStatus
|
|
# define rtmSetErrorStatus(rtm, val) ((rtm)->errorStatus = (val))
|
|
#endif
|
|
|
|
#ifndef rtmIsMajorTimeStep
|
|
# define rtmIsMajorTimeStep(rtm) (((rtm)->Timing.simTimeStep) == MAJOR_TIME_STEP)
|
|
#endif
|
|
|
|
#ifndef rtmIsMinorTimeStep
|
|
# define rtmIsMinorTimeStep(rtm) (((rtm)->Timing.simTimeStep) == MINOR_TIME_STEP)
|
|
#endif
|
|
|
|
#ifndef rtmIsSampleHit
|
|
# define rtmIsSampleHit(rtm, sti, tid) ((rtmIsMajorTimeStep((rtm)) && (rtm)->Timing.sampleHits[(rtm)->Timing.sampleTimeTaskIDPtr[sti]]))
|
|
#endif
|
|
|
|
#ifndef rtmGetStopRequested
|
|
# define rtmGetStopRequested(rtm) ((rtm)->Timing.stopRequestedFlag)
|
|
#endif
|
|
|
|
#ifndef rtmSetStopRequested
|
|
# define rtmSetStopRequested(rtm, val) ((rtm)->Timing.stopRequestedFlag = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetStopRequestedPtr
|
|
# define rtmGetStopRequestedPtr(rtm) (&((rtm)->Timing.stopRequestedFlag))
|
|
#endif
|
|
|
|
#ifndef rtmGetT
|
|
# define rtmGetT(rtm) (rtmGetTPtr((rtm))[0])
|
|
#endif
|
|
|
|
#ifndef rtmSetT
|
|
# define rtmSetT(rtm, val) /* Do Nothing */
|
|
#endif
|
|
|
|
#ifndef rtmGetTFinal
|
|
# define rtmGetTFinal(rtm) ((rtm)->Timing.tFinal)
|
|
#endif
|
|
|
|
#ifndef rtmSetTFinal
|
|
# define rtmSetTFinal(rtm, val) ((rtm)->Timing.tFinal = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetTPtr
|
|
# define rtmGetTPtr(rtm) ((rtm)->Timing.t)
|
|
#endif
|
|
|
|
#ifndef rtmSetTPtr
|
|
# define rtmSetTPtr(rtm, val) ((rtm)->Timing.t = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetTStart
|
|
# define rtmGetTStart(rtm) ((rtm)->Timing.tStart)
|
|
#endif
|
|
|
|
#ifndef rtmSetTStart
|
|
# define rtmSetTStart(rtm, val) ((rtm)->Timing.tStart = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetTaskTime
|
|
# define rtmGetTaskTime(rtm, sti) (rtmGetTPtr((rtm))[(rtm)->Timing.sampleTimeTaskIDPtr[sti]])
|
|
#endif
|
|
|
|
#ifndef rtmSetTaskTime
|
|
# define rtmSetTaskTime(rtm, sti, val) (rtmGetTPtr((rtm))[sti] = (val))
|
|
#endif
|
|
|
|
#ifndef rtmGetTimeOfLastOutput
|
|
# define rtmGetTimeOfLastOutput(rtm) ((rtm)->Timing.timeOfLastOutput)
|
|
#endif
|
|
|
|
#ifdef rtmGetRTWSolverInfo
|
|
#undef rtmGetRTWSolverInfo
|
|
#endif
|
|
|
|
#define rtmGetRTWSolverInfo(rtm) &((rtm)->solverInfo)
|
|
#define rtModel_WheelSpd1 RT_MODEL_WheelSpd1_T
|
|
|
|
/* Definition for use in the target main file */
|
|
#define WheelSpd1_rtModel RT_MODEL_WheelSpd1_T
|
|
|
|
/* user code (top of export header file) */
|
|
#include "can_message.h"
|
|
#include "xpcdatatypes.h"
|
|
|
|
/* Block signals (default storage) */
|
|
typedef struct {
|
|
CAN_DATATYPE CANPack; /* '<S5>/CAN Pack' */
|
|
CAN_DATATYPE CANRead1_o2; /* '<S1>/CAN Read1' */
|
|
real_T ContMode; /* '<S4>/ContM' */
|
|
real_T Ready; /* '<S5>/Constant' */
|
|
real_T Gear; /* '<S5>/Constant1' */
|
|
real_T BMS; /* '<S5>/Constant2' */
|
|
real_T PosTQLim; /* '<S5>/Constant3' */
|
|
real_T NegTQLim; /* '<S5>/Constant4' */
|
|
real_T Clock1; /* '<S6>/Clock1' */
|
|
real_T Product; /* '<S6>/Product' */
|
|
real_T Gain; /* '<S6>/Gain' */
|
|
real_T FromWs; /* '<S10>/FromWs' */
|
|
real_T InputSine; /* '<S4>/InputSine' */
|
|
real_T TargetSpd; /* '<S4>/Multiport Switch' */
|
|
real_T d1; /* '<S9>/d1' */
|
|
real_T Sum3; /* '<S9>/Sum3' */
|
|
real_T gain; /* '<S9>/gain' */
|
|
real_T gain2; /* '<S9>/gain2' */
|
|
real_T Product2; /* '<S9>/Product2' */
|
|
real_T gain1; /* '<S9>/gain1' */
|
|
real_T Sum1; /* '<S9>/Sum1' */
|
|
real_T d; /* '<S9>/d' */
|
|
real_T Product11; /* '<S9>/Product11' */
|
|
real_T Sum2; /* '<S9>/Sum2' */
|
|
real_T Sum4; /* '<S9>/Sum4' */
|
|
real_T Product1; /* '<S9>/Product1' */
|
|
real_T Product2_c; /* '<S17>/Product2' */
|
|
real_T d_a; /* '<S22>/d' */
|
|
real_T Sum2_h; /* '<S22>/Sum2' */
|
|
real_T gain_m; /* '<S22>/gain' */
|
|
real_T d1_d; /* '<S22>/d1' */
|
|
real_T Sum1_n; /* '<S22>/Sum1' */
|
|
real_T Product1_f; /* '<S17>/Product1' */
|
|
real_T d_b; /* '<S23>/d' */
|
|
real_T Sum2_g; /* '<S23>/Sum2' */
|
|
real_T gain_o; /* '<S23>/gain' */
|
|
real_T d1_c; /* '<S23>/d1' */
|
|
real_T Sum1_p; /* '<S23>/Sum1' */
|
|
real_T Product_n; /* '<S17>/Product' */
|
|
real_T d_bp; /* '<S24>/d' */
|
|
real_T Sum2_k; /* '<S24>/Sum2' */
|
|
real_T gain_d; /* '<S24>/gain' */
|
|
real_T d1_f; /* '<S24>/d1' */
|
|
real_T Sum1_k; /* '<S24>/Sum1' */
|
|
real_T Add5; /* '<S17>/Add5' */
|
|
real_T Gain_l; /* '<S17>/Gain' */
|
|
real_T Delay1; /* '<S26>/Delay1' */
|
|
real_T gain1_g; /* '<S26>/gain1' */
|
|
real_T Delay; /* '<S26>/Delay' */
|
|
real_T Sum3_d; /* '<S26>/Sum3' */
|
|
real_T gain2_h; /* '<S26>/gain2' */
|
|
real_T Product2_e; /* '<S26>/Product2' */
|
|
real_T xnxn1xn2; /* '<S26>/x(n), x(n-1), x(n-2)' */
|
|
real_T gain3; /* '<S26>/gain3' */
|
|
real_T Sum4_c; /* '<S26>/Sum4' */
|
|
real_T Delay2; /* '<S26>/Delay2' */
|
|
real_T yn1; /* '<S26>/y(n-1)' */
|
|
real_T Sum1_a; /* '<S26>/Sum1' */
|
|
real_T Product3; /* '<S26>/Product3' */
|
|
real_T gain4; /* '<S26>/gain4' */
|
|
real_T Product4; /* '<S26>/Product4' */
|
|
real_T Sum5; /* '<S26>/Sum5' */
|
|
real_T Delay3; /* '<S26>/Delay3' */
|
|
real_T yn2; /* '<S26>/y(n-2)' */
|
|
real_T Sum2_c; /* '<S26>/Sum2' */
|
|
real_T Sum6; /* '<S26>/Sum6' */
|
|
real_T Product1_n; /* '<S26>/Product1' */
|
|
real_T d1_b; /* '<S25>/d1' */
|
|
real_T Sum3_c; /* '<S25>/Sum3' */
|
|
real_T gain_e; /* '<S25>/gain' */
|
|
real_T gain2_k; /* '<S25>/gain2' */
|
|
real_T Product2_p; /* '<S25>/Product2' */
|
|
real_T gain1_gt; /* '<S25>/gain1' */
|
|
real_T Sum1_px; /* '<S25>/Sum1' */
|
|
real_T d_i; /* '<S25>/d' */
|
|
real_T Product11_e; /* '<S25>/Product11' */
|
|
real_T Sum2_kk; /* '<S25>/Sum2' */
|
|
real_T Sum4_l; /* '<S25>/Sum4' */
|
|
real_T Product1_i; /* '<S25>/Product1' */
|
|
real_T FFGain; /* '<S17>/FFGain' */
|
|
real_T Error; /* '<S4>/Subtract' */
|
|
real_T Gain_a; /* '<S18>/Gain' */
|
|
real_T Kp; /* '<S18>/Kp' */
|
|
real_T gain_mk; /* '<S19>/gain ' */
|
|
real_T Kp_b; /* '<S19>/Kp' */
|
|
real_T Ki; /* '<S19>/Ki' */
|
|
real_T gain2_n; /* '<S20>/gain2' */
|
|
real_T tau; /* '<S20>/Product2' */
|
|
real_T utau; /* '<S20>/gain3' */
|
|
real_T d1_cf; /* '<S21>/d1' */
|
|
real_T Sum1_d; /* '<S21>/Sum1' */
|
|
real_T gain_ds; /* '<S21>/gain' */
|
|
real_T d_c; /* '<S21>/d' */
|
|
real_T Sum2_l; /* '<S21>/Sum2' */
|
|
real_T d1_p; /* '<S20>/d1' */
|
|
real_T Sum3_g; /* '<S20>/Sum3' */
|
|
real_T Product3_e; /* '<S20>/Product3' */
|
|
real_T Sum1_i; /* '<S20>/Sum1' */
|
|
real_T d_j; /* '<S20>/d' */
|
|
real_T Product11_n; /* '<S20>/Product11' */
|
|
real_T Sum2_j; /* '<S20>/Sum2' */
|
|
real_T Sum4_a; /* '<S20>/Sum4' */
|
|
real_T Product1_a; /* '<S20>/Product1' */
|
|
real_T MultiportSwitch1; /* '<S16>/Multiport Switch1' */
|
|
real_T FBOut; /* '<S8>/FBGain' */
|
|
real_T Add; /* '<S8>/Add' */
|
|
real_T Memory; /* '<S4>/Memory' */
|
|
real_T Product4_o; /* '<S7>/Product4' */
|
|
real_T d_in; /* '<S11>/d' */
|
|
real_T Sum2_hn; /* '<S11>/Sum2' */
|
|
real_T gain_j; /* '<S11>/gain' */
|
|
real_T d1_e; /* '<S11>/d1' */
|
|
real_T Sum1_m; /* '<S11>/Sum1' */
|
|
real_T Product3_f; /* '<S7>/Product3' */
|
|
real_T d_n; /* '<S12>/d' */
|
|
real_T Sum2_kl; /* '<S12>/Sum2' */
|
|
real_T gain_g; /* '<S12>/gain' */
|
|
real_T d1_bp; /* '<S12>/d1' */
|
|
real_T Sum1_f; /* '<S12>/Sum1' */
|
|
real_T Product2_l; /* '<S7>/Product2' */
|
|
real_T d_cu; /* '<S13>/d' */
|
|
real_T Sum2_a; /* '<S13>/Sum2' */
|
|
real_T gain_gz; /* '<S13>/gain' */
|
|
real_T d1_di; /* '<S13>/d1' */
|
|
real_T Sum1_g; /* '<S13>/Sum1' */
|
|
real_T Add2; /* '<S7>/Add2' */
|
|
real_T Gain_c; /* '<S7>/Gain' */
|
|
real_T Add3; /* '<S7>/Add3' */
|
|
real_T d1_n; /* '<S14>/d1' */
|
|
real_T Sum3_f; /* '<S14>/Sum3' */
|
|
real_T gain_o3; /* '<S14>/gain' */
|
|
real_T gain2_m; /* '<S14>/gain2' */
|
|
real_T Product2_h; /* '<S14>/Product2' */
|
|
real_T gain1_k; /* '<S14>/gain1' */
|
|
real_T Sum1_e; /* '<S14>/Sum1' */
|
|
real_T d_p; /* '<S14>/d' */
|
|
real_T Product11_i; /* '<S14>/Product11' */
|
|
real_T Sum2_b; /* '<S14>/Sum2' */
|
|
real_T Sum4_k; /* '<S14>/Sum4' */
|
|
real_T Product1_l; /* '<S14>/Product1' */
|
|
real_T Delay1_n; /* '<S15>/Delay1' */
|
|
real_T gain1_f; /* '<S15>/gain1' */
|
|
real_T Delay_a; /* '<S15>/Delay' */
|
|
real_T Sum3_a; /* '<S15>/Sum3' */
|
|
real_T gain2_d; /* '<S15>/gain2' */
|
|
real_T Product2_m; /* '<S15>/Product2' */
|
|
real_T xnxn1xn2_a; /* '<S15>/x(n), x(n-1), x(n-2)' */
|
|
real_T gain3_b; /* '<S15>/gain3' */
|
|
real_T Sum4_kn; /* '<S15>/Sum4' */
|
|
real_T Delay2_n; /* '<S15>/Delay2' */
|
|
real_T yn1_m; /* '<S15>/y(n-1)' */
|
|
real_T Sum1_ek; /* '<S15>/Sum1' */
|
|
real_T Product3_i; /* '<S15>/Product3' */
|
|
real_T gain4_g; /* '<S15>/gain4' */
|
|
real_T Product4_i; /* '<S15>/Product4' */
|
|
real_T Sum5_f; /* '<S15>/Sum5' */
|
|
real_T Delay3_i; /* '<S15>/Delay3' */
|
|
real_T yn2_g; /* '<S15>/y(n-2)' */
|
|
real_T Sum2_m; /* '<S15>/Sum2' */
|
|
real_T Sum6_g; /* '<S15>/Sum6' */
|
|
real_T Product1_fm; /* '<S15>/Product1' */
|
|
real_T Product_d; /* '<S4>/Product' */
|
|
real_T Subtract2; /* '<S4>/Subtract2' */
|
|
real_T ControlFlag; /* '<S4>/ControlFlag' */
|
|
real_T ControlOutput; /* '<S4>/Saturation' */
|
|
real_T Constant1; /* '<S8>/Constant1' */
|
|
real_T Constant16; /* '<S8>/Constant16' */
|
|
real_T Constant17; /* '<S8>/Constant17' */
|
|
real_T Constant2; /* '<S8>/Constant2' */
|
|
real_T Product_k; /* '<S18>/Product' */
|
|
real_T Divide2; /* '<S19>/Divide2' */
|
|
real_T Divide1; /* '<S19>/Divide1' */
|
|
real_T Add_k; /* '<S19>/Add' */
|
|
real_T Product1_lf; /* '<S6>/Product1' */
|
|
real_T Sum; /* '<S6>/Sum' */
|
|
real_T Product2_g; /* '<S6>/Product2' */
|
|
real_T Output; /* '<S6>/Output' */
|
|
real_T Gain1; /* '<S4>/Gain1' */
|
|
real_T Gain_d; /* '<S4>/Gain' */
|
|
real_T RPM; /* '<S1>/CAN Unpack2' */
|
|
real_T TQ; /* '<S1>/CAN Unpack2' */
|
|
boolean_T CANRead1_o1; /* '<S1>/CAN Read1' */
|
|
} B_WheelSpd1_T;
|
|
|
|
/* Block states (default storage) for system '<Root>' */
|
|
typedef struct {
|
|
real_T d1_DSTATE; /* '<S9>/d1' */
|
|
real_T d_DSTATE; /* '<S9>/d' */
|
|
real_T d_DSTATE_a; /* '<S22>/d' */
|
|
real_T d1_DSTATE_l; /* '<S22>/d1' */
|
|
real_T d_DSTATE_i; /* '<S23>/d' */
|
|
real_T d1_DSTATE_a; /* '<S23>/d1' */
|
|
real_T d_DSTATE_ak; /* '<S24>/d' */
|
|
real_T d1_DSTATE_f; /* '<S24>/d1' */
|
|
real_T Delay1_DSTATE; /* '<S26>/Delay1' */
|
|
real_T Delay_DSTATE[2]; /* '<S26>/Delay' */
|
|
real_T Delay2_DSTATE; /* '<S26>/Delay2' */
|
|
real_T Delay3_DSTATE[2]; /* '<S26>/Delay3' */
|
|
real_T d1_DSTATE_b; /* '<S25>/d1' */
|
|
real_T d_DSTATE_o; /* '<S25>/d' */
|
|
real_T d1_DSTATE_g; /* '<S21>/d1' */
|
|
real_T d_DSTATE_ir; /* '<S21>/d' */
|
|
real_T d1_DSTATE_lw; /* '<S20>/d1' */
|
|
real_T d_DSTATE_b; /* '<S20>/d' */
|
|
real_T d_DSTATE_bw; /* '<S11>/d' */
|
|
real_T d1_DSTATE_gc; /* '<S11>/d1' */
|
|
real_T d_DSTATE_d; /* '<S12>/d' */
|
|
real_T d1_DSTATE_l3; /* '<S12>/d1' */
|
|
real_T d_DSTATE_g; /* '<S13>/d' */
|
|
real_T d1_DSTATE_c; /* '<S13>/d1' */
|
|
real_T d1_DSTATE_m; /* '<S14>/d1' */
|
|
real_T d_DSTATE_h; /* '<S14>/d' */
|
|
real_T Delay1_DSTATE_i; /* '<S15>/Delay1' */
|
|
real_T Delay_DSTATE_g[2]; /* '<S15>/Delay' */
|
|
real_T Delay2_DSTATE_c; /* '<S15>/Delay2' */
|
|
real_T Delay3_DSTATE_o[2]; /* '<S15>/Delay3' */
|
|
real_T Memory_PreviousInput; /* '<S4>/Memory' */
|
|
struct {
|
|
void *TimePtr;
|
|
void *DataPtr;
|
|
void *RSimInfoPtr;
|
|
} FromWs_PWORK; /* '<S10>/FromWs' */
|
|
|
|
void *CANWrite1_PWORK; /* '<S5>/CAN Write1' */
|
|
struct {
|
|
void *AQHandles;
|
|
void *SlioLTF;
|
|
} HiddenToAsyncQueue_InsertedFor_; /* synthesized block */
|
|
|
|
struct {
|
|
void *AQHandles;
|
|
void *SlioLTF;
|
|
} HiddenToAsyncQueue_InsertedFo_c; /* synthesized block */
|
|
|
|
struct {
|
|
void *AQHandles;
|
|
void *SlioLTF;
|
|
} HiddenToAsyncQueue_InsertedF_cg; /* synthesized block */
|
|
|
|
struct {
|
|
void *AQHandles;
|
|
void *SlioLTF;
|
|
} HiddenToAsyncQueue_InsertedFo_k; /* synthesized block */
|
|
|
|
struct {
|
|
void *AQHandles;
|
|
void *SlioLTF;
|
|
} HiddenToAsyncQueue_InsertedFo_g; /* synthesized block */
|
|
|
|
struct {
|
|
void *AQHandles;
|
|
void *SlioLTF;
|
|
} HiddenToAsyncQueue_InsertedFo_d; /* synthesized block */
|
|
|
|
struct {
|
|
void *AQHandles;
|
|
void *SlioLTF;
|
|
} HiddenToAsyncQueue_InsertedFo_j; /* synthesized block */
|
|
|
|
struct {
|
|
void *AQHandles;
|
|
void *SlioLTF;
|
|
} HiddenToAsyncQueue_InsertedFo_b; /* synthesized block */
|
|
|
|
struct {
|
|
void *AQHandles;
|
|
void *SlioLTF;
|
|
} HiddenToAsyncQueue_InsertedFo_i; /* synthesized block */
|
|
|
|
struct {
|
|
void *AQHandles;
|
|
void *SlioLTF;
|
|
} HiddenToAsyncQueue_InsertedFo_e; /* synthesized block */
|
|
|
|
struct {
|
|
void *AQHandles;
|
|
void *SlioLTF;
|
|
} HiddenToAsyncQueue_InsertedFo_h; /* synthesized block */
|
|
|
|
struct {
|
|
void *AQHandles;
|
|
void *SlioLTF;
|
|
} HiddenToAsyncQueue_InsertedF_bl; /* synthesized block */
|
|
|
|
struct {
|
|
void *AQHandles;
|
|
void *SlioLTF;
|
|
} HiddenToAsyncQueue_InsertedF_cb; /* synthesized block */
|
|
|
|
struct {
|
|
void *AQHandles;
|
|
void *SlioLTF;
|
|
} HiddenToAsyncQueue_InsertedFo_l; /* synthesized block */
|
|
|
|
struct {
|
|
void *AQHandles;
|
|
void *SlioLTF;
|
|
} HiddenToAsyncQueue_InsertedF_ga; /* synthesized block */
|
|
|
|
struct {
|
|
void *AQHandles;
|
|
void *SlioLTF;
|
|
} HiddenToAsyncQueue_InsertedF_gg; /* synthesized block */
|
|
|
|
struct {
|
|
int_T PrevIndex;
|
|
} FromWs_IWORK; /* '<S10>/FromWs' */
|
|
|
|
int_T CANPack_ModeSignalID; /* '<S5>/CAN Pack' */
|
|
int_T CANWrite1_IWORK; /* '<S5>/CAN Write1' */
|
|
int_T CANSetup_IWORK; /* '<S1>/CAN Setup' */
|
|
int_T CANRead1_IWORK; /* '<S1>/CAN Read1' */
|
|
int_T CANUnpack2_ModeSignalID; /* '<S1>/CAN Unpack2' */
|
|
int_T CANUnpack2_StatusPortID; /* '<S1>/CAN Unpack2' */
|
|
} DW_WheelSpd1_T;
|
|
|
|
/* Backward compatible GRT Identifiers */
|
|
#define rtB WheelSpd1_B
|
|
#define BlockIO B_WheelSpd1_T
|
|
#define rtP WheelSpd1_P
|
|
#define Parameters P_WheelSpd1_T
|
|
#define rtDWork WheelSpd1_DW
|
|
#define D_Work DW_WheelSpd1_T
|
|
|
|
/* Parameters (default storage) */
|
|
struct P_WheelSpd1_T_ {
|
|
real_T K; /* Variable: K
|
|
* Referenced by:
|
|
* '<S7>/Gain'
|
|
* '<S8>/Constant2'
|
|
* '<S17>/Gain'
|
|
*/
|
|
real_T P; /* Variable: P
|
|
* Referenced by:
|
|
* '<S7>/Constant3'
|
|
* '<S7>/Constant4'
|
|
* '<S7>/Constant5'
|
|
* '<S8>/Constant16'
|
|
* '<S17>/Constant3'
|
|
* '<S17>/Constant4'
|
|
* '<S17>/Constant5'
|
|
*/
|
|
real_T Ts; /* Variable: Ts
|
|
* Referenced by:
|
|
* '<S9>/Constant'
|
|
* '<S9>/gain'
|
|
* '<S11>/gain'
|
|
* '<S12>/gain'
|
|
* '<S13>/gain'
|
|
* '<S14>/Constant'
|
|
* '<S14>/gain'
|
|
* '<S15>/Constant'
|
|
* '<S22>/gain'
|
|
* '<S23>/gain'
|
|
* '<S24>/gain'
|
|
* '<S25>/Constant'
|
|
* '<S25>/gain'
|
|
* '<S26>/Constant'
|
|
* '<S20>/Constant'
|
|
* '<S20>/Constant2'
|
|
* '<S21>/gain'
|
|
*/
|
|
real_T Wn; /* Variable: Wn
|
|
* Referenced by:
|
|
* '<S7>/Constant3'
|
|
* '<S7>/Constant4'
|
|
* '<S8>/Constant1'
|
|
* '<S17>/Constant3'
|
|
* '<S17>/Constant4'
|
|
*/
|
|
real_T jeta; /* Variable: jeta
|
|
* Referenced by:
|
|
* '<S7>/Constant3'
|
|
* '<S7>/Constant4'
|
|
* '<S8>/Constant17'
|
|
* '<S17>/Constant3'
|
|
* '<S17>/Constant4'
|
|
*/
|
|
real_T ChirpSignal_T; /* Mask Parameter: ChirpSignal_T
|
|
* Referenced by: '<S6>/targetTime'
|
|
*/
|
|
real_T ChirpSignal_f1; /* Mask Parameter: ChirpSignal_f1
|
|
* Referenced by:
|
|
* '<S6>/deltaFreq'
|
|
* '<S6>/initialFreq'
|
|
*/
|
|
real_T ChirpSignal_f2; /* Mask Parameter: ChirpSignal_f2
|
|
* Referenced by: '<S6>/deltaFreq'
|
|
*/
|
|
real_T CANSetup_P1_Size[2]; /* Computed Parameter: CANSetup_P1_Size
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P1; /* Expression: id
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P2_Size[2]; /* Computed Parameter: CANSetup_P2_Size
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P2[2]; /* Computed Parameter: CANSetup_P2
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P3_Size[2]; /* Computed Parameter: CANSetup_P3_Size
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P3; /* Expression: PCISlot
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P4_Size[2]; /* Computed Parameter: CANSetup_P4_Size
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P4; /* Expression: port1
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P5_Size[2]; /* Computed Parameter: CANSetup_P5_Size
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P5; /* Expression: port2
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P6_Size[2]; /* Computed Parameter: CANSetup_P6_Size
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P6; /* Expression: opModeCAN1
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P7_Size[2]; /* Computed Parameter: CANSetup_P7_Size
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P7[4]; /* Expression: usrBdrCAN1
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P8_Size[2]; /* Computed Parameter: CANSetup_P8_Size
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P8[6]; /* Expression: usrBdrFD1
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P9_Size[2]; /* Computed Parameter: CANSetup_P9_Size
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P9[2]; /* Expression: stdAccMaskCAN1
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P10_Size[2]; /* Computed Parameter: CANSetup_P10_Size
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P10[2]; /* Expression: extAccMaskCAN1
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P11_Size[2]; /* Computed Parameter: CANSetup_P11_Size
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P11; /* Expression: opModeCAN2
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P12_Size[2]; /* Computed Parameter: CANSetup_P12_Size
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P12[4]; /* Expression: usrBdrCAN2
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P13_Size[2]; /* Computed Parameter: CANSetup_P13_Size
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P13[6]; /* Expression: usrBdrFD2
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P14_Size[2]; /* Computed Parameter: CANSetup_P14_Size
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P14[2]; /* Expression: stdAccMaskCAN2
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P15_Size[2]; /* Computed Parameter: CANSetup_P15_Size
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P15[2]; /* Expression: extAccMaskCAN2
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P16_Size[2]; /* Computed Parameter: CANSetup_P16_Size
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P16; /* Expression: initStruct
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P17_Size[2]; /* Computed Parameter: CANSetup_P17_Size
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P17; /* Expression: termStruct
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P18_Size[2]; /* Computed Parameter: CANSetup_P18_Size
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P18[5]; /* Computed Parameter: CANSetup_P18
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P19_Size[2]; /* Computed Parameter: CANSetup_P19_Size
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P19; /* Expression: qtyMod
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P20_Size[2]; /* Computed Parameter: CANSetup_P20_Size
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P20[2]; /* Expression: chNo
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P21_Size[2]; /* Computed Parameter: CANSetup_P21_Size
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P21[2]; /* Expression: ptTypes
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P22_Size[2]; /* Computed Parameter: CANSetup_P22_Size
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P22[2]; /* Expression: isProtlFD
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P23_Size[2]; /* Computed Parameter: CANSetup_P23_Size
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P23[2]; /* Expression: protlHelpIdx
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P24_Size[2]; /* Computed Parameter: CANSetup_P24_Size
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANSetup_P24; /* Expression: isFDMod
|
|
* Referenced by: '<S1>/CAN Setup'
|
|
*/
|
|
real_T CANRead1_P1_Size[2]; /* Computed Parameter: CANRead1_P1_Size
|
|
* Referenced by: '<S1>/CAN Read1'
|
|
*/
|
|
real_T CANRead1_P1; /* Expression: id
|
|
* Referenced by: '<S1>/CAN Read1'
|
|
*/
|
|
real_T CANRead1_P2_Size[2]; /* Computed Parameter: CANRead1_P2_Size
|
|
* Referenced by: '<S1>/CAN Read1'
|
|
*/
|
|
real_T CANRead1_P2; /* Expression: sampleTime
|
|
* Referenced by: '<S1>/CAN Read1'
|
|
*/
|
|
real_T CANRead1_P3_Size[2]; /* Computed Parameter: CANRead1_P3_Size
|
|
* Referenced by: '<S1>/CAN Read1'
|
|
*/
|
|
real_T CANRead1_P3; /* Expression: messageType
|
|
* Referenced by: '<S1>/CAN Read1'
|
|
*/
|
|
real_T CANRead1_P4_Size[2]; /* Computed Parameter: CANRead1_P4_Size
|
|
* Referenced by: '<S1>/CAN Read1'
|
|
*/
|
|
real_T CANRead1_P4[5]; /* Computed Parameter: CANRead1_P4
|
|
* Referenced by: '<S1>/CAN Read1'
|
|
*/
|
|
real_T CANRead1_P5_Size[2]; /* Computed Parameter: CANRead1_P5_Size
|
|
* Referenced by: '<S1>/CAN Read1'
|
|
*/
|
|
real_T CANRead1_P5; /* Expression: ptIdx
|
|
* Referenced by: '<S1>/CAN Read1'
|
|
*/
|
|
real_T CANRead1_P6_Size[2]; /* Computed Parameter: CANRead1_P6_Size
|
|
* Referenced by: '<S1>/CAN Read1'
|
|
*/
|
|
real_T CANRead1_P6; /* Expression: isFDMod
|
|
* Referenced by: '<S1>/CAN Read1'
|
|
*/
|
|
real_T Gain_Gain; /* Expression: 60
|
|
* Referenced by: '<S4>/Gain'
|
|
*/
|
|
real_T Gain1_Gain; /* Expression: 30
|
|
* Referenced by: '<S4>/Gain1'
|
|
*/
|
|
real_T ContMode_Value; /* Expression: 1
|
|
* Referenced by: '<S4>/ContMode'
|
|
*/
|
|
real_T ContM_Gain; /* Expression: 0
|
|
* Referenced by: '<S4>/ContM'
|
|
*/
|
|
real_T Constant_Value; /* Expression: 1
|
|
* Referenced by: '<S5>/Constant'
|
|
*/
|
|
real_T Constant1_Value; /* Expression: 4
|
|
* Referenced by: '<S5>/Constant1'
|
|
*/
|
|
real_T Constant2_Value; /* Expression: 0
|
|
* Referenced by: '<S5>/Constant2'
|
|
*/
|
|
real_T Constant3_Value; /* Expression: 10
|
|
* Referenced by: '<S5>/Constant3'
|
|
*/
|
|
real_T Constant4_Value; /* Expression: -10
|
|
* Referenced by: '<S5>/Constant4'
|
|
*/
|
|
real_T InputSelector_Value; /* Expression: 3
|
|
* Referenced by: '<S4>/InputSelector'
|
|
*/
|
|
real_T Gain_Gain_a; /* Expression: 0.5
|
|
* Referenced by: '<S6>/Gain'
|
|
*/
|
|
real_T InputSine_Amp; /* Expression: 1000
|
|
* Referenced by: '<S4>/InputSine'
|
|
*/
|
|
real_T InputSine_Bias; /* Expression: 0
|
|
* Referenced by: '<S4>/InputSine'
|
|
*/
|
|
real_T InputSine_Freq; /* Expression: 0.1*2*pi
|
|
* Referenced by: '<S4>/InputSine'
|
|
*/
|
|
real_T InputSine_Phase; /* Expression: 0
|
|
* Referenced by: '<S4>/InputSine'
|
|
*/
|
|
real_T d1_InitialCondition; /* Expression: 0
|
|
* Referenced by: '<S9>/d1'
|
|
*/
|
|
real_T Constant1_Value_n; /* Expression: 1
|
|
* Referenced by: '<S9>/Constant1'
|
|
*/
|
|
real_T Constant1_Value_a; /* Expression: 3
|
|
* Referenced by: '<S4>/Constant1'
|
|
*/
|
|
real_T gain2_Gain; /* Expression: 2*pi
|
|
* Referenced by: '<S9>/gain2'
|
|
*/
|
|
real_T gain1_Gain; /* Expression: 2
|
|
* Referenced by: '<S9>/gain1'
|
|
*/
|
|
real_T d_InitialCondition; /* Expression: 0
|
|
* Referenced by: '<S9>/d'
|
|
*/
|
|
real_T d_InitialCondition_j; /* Expression: 0
|
|
* Referenced by: '<S22>/d'
|
|
*/
|
|
real_T d1_InitialCondition_p; /* Expression: 0
|
|
* Referenced by: '<S22>/d1'
|
|
*/
|
|
real_T d_InitialCondition_b; /* Expression: 0
|
|
* Referenced by: '<S23>/d'
|
|
*/
|
|
real_T d1_InitialCondition_j; /* Expression: 0
|
|
* Referenced by: '<S23>/d1'
|
|
*/
|
|
real_T d_InitialCondition_f; /* Expression: 0
|
|
* Referenced by: '<S24>/d'
|
|
*/
|
|
real_T d1_InitialCondition_l; /* Expression: 0
|
|
* Referenced by: '<S24>/d1'
|
|
*/
|
|
real_T Delay1_InitialCondition; /* Expression: 0
|
|
* Referenced by: '<S26>/Delay1'
|
|
*/
|
|
real_T gain1_Gain_b; /* Expression: 2
|
|
* Referenced by: '<S26>/gain1'
|
|
*/
|
|
real_T Delay_InitialCondition; /* Expression: 0
|
|
* Referenced by: '<S26>/Delay'
|
|
*/
|
|
real_T FF_CutoffFreq_Value; /* Expression: 30
|
|
* Referenced by: '<S8>/FF_CutoffFreq'
|
|
*/
|
|
real_T gain2_Gain_p; /* Expression: 2*pi
|
|
* Referenced by: '<S26>/gain2'
|
|
*/
|
|
real_T gain3_Gain; /* Expression: 2
|
|
* Referenced by: '<S26>/gain3'
|
|
*/
|
|
real_T Constant1_Value_p; /* Expression: 8
|
|
* Referenced by: '<S26>/Constant1'
|
|
*/
|
|
real_T Delay2_InitialCondition; /* Expression: 0
|
|
* Referenced by: '<S26>/Delay2'
|
|
*/
|
|
real_T gain4_Gain; /* Expression: 4
|
|
* Referenced by: '<S26>/gain4'
|
|
*/
|
|
real_T zeta_Value; /* Expression: 0.707
|
|
* Referenced by: '<S17>/zeta'
|
|
*/
|
|
real_T Constant2_Value_f; /* Expression: 4
|
|
* Referenced by: '<S26>/Constant2'
|
|
*/
|
|
real_T Delay3_InitialCondition; /* Expression: 0
|
|
* Referenced by: '<S26>/Delay3'
|
|
*/
|
|
real_T d1_InitialCondition_e; /* Expression: 0
|
|
* Referenced by: '<S25>/d1'
|
|
*/
|
|
real_T Constant1_Value_h; /* Expression: 1
|
|
* Referenced by: '<S25>/Constant1'
|
|
*/
|
|
real_T Constant1_Value_i; /* Expression: 30
|
|
* Referenced by: '<S17>/Constant1'
|
|
*/
|
|
real_T gain2_Gain_po; /* Expression: 2*pi
|
|
* Referenced by: '<S25>/gain2'
|
|
*/
|
|
real_T gain1_Gain_f; /* Expression: 2
|
|
* Referenced by: '<S25>/gain1'
|
|
*/
|
|
real_T d_InitialCondition_o; /* Expression: 0
|
|
* Referenced by: '<S25>/d'
|
|
*/
|
|
real_T FFGain_Gain; /* Expression: 1
|
|
* Referenced by: '<S17>/FFGain'
|
|
*/
|
|
real_T Selector_Value; /* Expression: 1
|
|
* Referenced by: '<S8>/Selector'
|
|
*/
|
|
real_T BW_P_Value; /* Expression: 2.3
|
|
* Referenced by: '<S8>/BW_P'
|
|
*/
|
|
real_T Gain_Gain_n; /* Expression: 2*pi
|
|
* Referenced by: '<S18>/Gain'
|
|
*/
|
|
real_T BW_PI_Value; /* Expression: 15
|
|
* Referenced by: '<S8>/BW_PI'
|
|
*/
|
|
real_T gain_Gain; /* Expression: 2*pi
|
|
* Referenced by: '<S19>/gain '
|
|
*/
|
|
real_T Constant1_Value_l; /* Expression: 1
|
|
* Referenced by: '<S20>/Constant1'
|
|
*/
|
|
real_T Constant_Value_d; /* Expression: 0.05
|
|
* Referenced by: '<S19>/Constant'
|
|
*/
|
|
real_T gain2_Gain_c; /* Expression: 2*pi
|
|
* Referenced by: '<S20>/gain2'
|
|
*/
|
|
real_T gain3_Gain_o; /* Expression: 2
|
|
* Referenced by: '<S20>/gain3'
|
|
*/
|
|
real_T d1_InitialCondition_a; /* Expression: 0
|
|
* Referenced by: '<S21>/d1'
|
|
*/
|
|
real_T d_InitialCondition_g; /* Expression: 0
|
|
* Referenced by: '<S21>/d'
|
|
*/
|
|
real_T d1_InitialCondition_g; /* Expression: 0
|
|
* Referenced by: '<S20>/d1'
|
|
*/
|
|
real_T d_InitialCondition_l; /* Expression: 0
|
|
* Referenced by: '<S20>/d'
|
|
*/
|
|
real_T FBGain_Gain; /* Expression: 1
|
|
* Referenced by: '<S8>/FBGain'
|
|
*/
|
|
real_T Memory_InitialCondition; /* Expression: 0
|
|
* Referenced by: '<S4>/Memory'
|
|
*/
|
|
real_T d_InitialCondition_k; /* Expression: 0
|
|
* Referenced by: '<S11>/d'
|
|
*/
|
|
real_T d1_InitialCondition_e1; /* Expression: 0
|
|
* Referenced by: '<S11>/d1'
|
|
*/
|
|
real_T d_InitialCondition_be; /* Expression: 0
|
|
* Referenced by: '<S12>/d'
|
|
*/
|
|
real_T d1_InitialCondition_h; /* Expression: 0
|
|
* Referenced by: '<S12>/d1'
|
|
*/
|
|
real_T d_InitialCondition_k0; /* Expression: 0
|
|
* Referenced by: '<S13>/d'
|
|
*/
|
|
real_T d1_InitialCondition_d; /* Expression: 0
|
|
* Referenced by: '<S13>/d1'
|
|
*/
|
|
real_T d1_InitialCondition_c; /* Expression: 0
|
|
* Referenced by: '<S14>/d1'
|
|
*/
|
|
real_T Constant1_Value_id; /* Expression: 1
|
|
* Referenced by: '<S14>/Constant1'
|
|
*/
|
|
real_T Pole_Value; /* Expression: 5
|
|
* Referenced by: '<S4>/Pole'
|
|
*/
|
|
real_T gain2_Gain_a; /* Expression: 2*pi
|
|
* Referenced by: '<S14>/gain2'
|
|
*/
|
|
real_T gain1_Gain_f2; /* Expression: 2
|
|
* Referenced by: '<S14>/gain1'
|
|
*/
|
|
real_T d_InitialCondition_kh; /* Expression: 0
|
|
* Referenced by: '<S14>/d'
|
|
*/
|
|
real_T Delay1_InitialCondition_c; /* Expression: 0
|
|
* Referenced by: '<S15>/Delay1'
|
|
*/
|
|
real_T gain1_Gain_n; /* Expression: 2
|
|
* Referenced by: '<S15>/gain1'
|
|
*/
|
|
real_T Delay_InitialCondition_c; /* Expression: 0
|
|
* Referenced by: '<S15>/Delay'
|
|
*/
|
|
real_T Qfilter2_Value; /* Expression: 0.4
|
|
* Referenced by: '<S4>/Qfilter2'
|
|
*/
|
|
real_T gain2_Gain_f; /* Expression: 2*pi
|
|
* Referenced by: '<S15>/gain2'
|
|
*/
|
|
real_T gain3_Gain_d; /* Expression: 2
|
|
* Referenced by: '<S15>/gain3'
|
|
*/
|
|
real_T Constant1_Value_e; /* Expression: 8
|
|
* Referenced by: '<S15>/Constant1'
|
|
*/
|
|
real_T Delay2_InitialCondition_c; /* Expression: 0
|
|
* Referenced by: '<S15>/Delay2'
|
|
*/
|
|
real_T gain4_Gain_i; /* Expression: 4
|
|
* Referenced by: '<S15>/gain4'
|
|
*/
|
|
real_T zeta1_Value; /* Expression: 0.707
|
|
* Referenced by: '<S7>/zeta1'
|
|
*/
|
|
real_T Constant2_Value_h; /* Expression: 4
|
|
* Referenced by: '<S15>/Constant2'
|
|
*/
|
|
real_T Delay3_InitialCondition_f; /* Expression: 0
|
|
* Referenced by: '<S15>/Delay3'
|
|
*/
|
|
real_T DOBFlag_Value; /* Expression: 1
|
|
* Referenced by: '<S4>/DOBFlag'
|
|
*/
|
|
real_T ControlFlag_Gain; /* Expression: 1
|
|
* Referenced by: '<S4>/ControlFlag'
|
|
*/
|
|
real_T Saturation_UpperSat; /* Expression: 20
|
|
* Referenced by: '<S4>/Saturation'
|
|
*/
|
|
real_T Saturation_LowerSat; /* Expression: -20
|
|
* Referenced by: '<S4>/Saturation'
|
|
*/
|
|
real_T CANWrite1_P1_Size[2]; /* Computed Parameter: CANWrite1_P1_Size
|
|
* Referenced by: '<S5>/CAN Write1'
|
|
*/
|
|
real_T CANWrite1_P1; /* Expression: id
|
|
* Referenced by: '<S5>/CAN Write1'
|
|
*/
|
|
real_T CANWrite1_P2_Size[2]; /* Computed Parameter: CANWrite1_P2_Size
|
|
* Referenced by: '<S5>/CAN Write1'
|
|
*/
|
|
real_T CANWrite1_P2; /* Expression: sampleTime
|
|
* Referenced by: '<S5>/CAN Write1'
|
|
*/
|
|
real_T CANWrite1_P3_Size[2]; /* Computed Parameter: CANWrite1_P3_Size
|
|
* Referenced by: '<S5>/CAN Write1'
|
|
*/
|
|
real_T CANWrite1_P3; /* Expression: messageType
|
|
* Referenced by: '<S5>/CAN Write1'
|
|
*/
|
|
real_T CANWrite1_P4_Size[2]; /* Computed Parameter: CANWrite1_P4_Size
|
|
* Referenced by: '<S5>/CAN Write1'
|
|
*/
|
|
real_T CANWrite1_P4; /* Expression: enaStatusPort
|
|
* Referenced by: '<S5>/CAN Write1'
|
|
*/
|
|
real_T CANWrite1_P5_Size[2]; /* Computed Parameter: CANWrite1_P5_Size
|
|
* Referenced by: '<S5>/CAN Write1'
|
|
*/
|
|
real_T CANWrite1_P5[5]; /* Computed Parameter: CANWrite1_P5
|
|
* Referenced by: '<S5>/CAN Write1'
|
|
*/
|
|
real_T CANWrite1_P6_Size[2]; /* Computed Parameter: CANWrite1_P6_Size
|
|
* Referenced by: '<S5>/CAN Write1'
|
|
*/
|
|
real_T CANWrite1_P6; /* Expression: ptIdx
|
|
* Referenced by: '<S5>/CAN Write1'
|
|
*/
|
|
real_T CANWrite1_P7_Size[2]; /* Computed Parameter: CANWrite1_P7_Size
|
|
* Referenced by: '<S5>/CAN Write1'
|
|
*/
|
|
real_T CANWrite1_P7; /* Expression: isFDMod
|
|
* Referenced by: '<S5>/CAN Write1'
|
|
*/
|
|
uint32_T Delay1_DelayLength; /* Computed Parameter: Delay1_DelayLength
|
|
* Referenced by: '<S26>/Delay1'
|
|
*/
|
|
uint32_T Delay_DelayLength; /* Computed Parameter: Delay_DelayLength
|
|
* Referenced by: '<S26>/Delay'
|
|
*/
|
|
uint32_T Delay2_DelayLength; /* Computed Parameter: Delay2_DelayLength
|
|
* Referenced by: '<S26>/Delay2'
|
|
*/
|
|
uint32_T Delay3_DelayLength; /* Computed Parameter: Delay3_DelayLength
|
|
* Referenced by: '<S26>/Delay3'
|
|
*/
|
|
uint32_T Delay1_DelayLength_g; /* Computed Parameter: Delay1_DelayLength_g
|
|
* Referenced by: '<S15>/Delay1'
|
|
*/
|
|
uint32_T Delay_DelayLength_f; /* Computed Parameter: Delay_DelayLength_f
|
|
* Referenced by: '<S15>/Delay'
|
|
*/
|
|
uint32_T Delay2_DelayLength_c; /* Computed Parameter: Delay2_DelayLength_c
|
|
* Referenced by: '<S15>/Delay2'
|
|
*/
|
|
uint32_T Delay3_DelayLength_g; /* Computed Parameter: Delay3_DelayLength_g
|
|
* Referenced by: '<S15>/Delay3'
|
|
*/
|
|
};
|
|
|
|
/* Real-time Model Data Structure */
|
|
struct tag_RTM_WheelSpd1_T {
|
|
const char_T *path;
|
|
const char_T *modelName;
|
|
struct SimStruct_tag * *childSfunctions;
|
|
const char_T *errorStatus;
|
|
SS_SimMode simMode;
|
|
RTWLogInfo *rtwLogInfo;
|
|
RTWExtModeInfo *extModeInfo;
|
|
RTWSolverInfo solverInfo;
|
|
RTWSolverInfo *solverInfoPtr;
|
|
void *sfcnInfo;
|
|
|
|
/*
|
|
* NonInlinedSFcns:
|
|
* The following substructure contains information regarding
|
|
* non-inlined s-functions used in the model.
|
|
*/
|
|
struct {
|
|
RTWSfcnInfo sfcnInfo;
|
|
time_T *taskTimePtrs[2];
|
|
SimStruct childSFunctions[3];
|
|
SimStruct *childSFunctionPtrs[3];
|
|
struct _ssBlkInfo2 blkInfo2[3];
|
|
struct _ssSFcnModelMethods2 methods2[3];
|
|
struct _ssSFcnModelMethods3 methods3[3];
|
|
struct _ssSFcnModelMethods4 methods4[3];
|
|
struct _ssStatesInfo2 statesInfo2[3];
|
|
ssPeriodicStatesInfo periodicStatesInfo[3];
|
|
struct _ssPortInfo2 inputOutputPortInfo2[3];
|
|
struct {
|
|
time_T sfcnPeriod[1];
|
|
time_T sfcnOffset[1];
|
|
int_T sfcnTsMap[1];
|
|
uint_T attribs[24];
|
|
mxArray *params[24];
|
|
struct _ssDWorkRecord dWork[1];
|
|
struct _ssDWorkAuxRecord dWorkAux[1];
|
|
} Sfcn0;
|
|
|
|
struct {
|
|
time_T sfcnPeriod[1];
|
|
time_T sfcnOffset[1];
|
|
int_T sfcnTsMap[1];
|
|
struct _ssPortOutputs outputPortInfo[2];
|
|
struct _ssOutPortUnit outputPortUnits[2];
|
|
struct _ssOutPortCoSimAttribute outputPortCoSimAttribute[2];
|
|
uint_T attribs[6];
|
|
mxArray *params[6];
|
|
struct _ssDWorkRecord dWork[1];
|
|
struct _ssDWorkAuxRecord dWorkAux[1];
|
|
} Sfcn1;
|
|
|
|
struct {
|
|
time_T sfcnPeriod[1];
|
|
time_T sfcnOffset[1];
|
|
int_T sfcnTsMap[1];
|
|
struct _ssPortInputs inputPortInfo[1];
|
|
struct _ssInPortUnit inputPortUnits[1];
|
|
struct _ssInPortCoSimAttribute inputPortCoSimAttribute[1];
|
|
uint_T attribs[7];
|
|
mxArray *params[7];
|
|
struct _ssDWorkRecord dWork[2];
|
|
struct _ssDWorkAuxRecord dWorkAux[2];
|
|
} Sfcn2;
|
|
} NonInlinedSFcns;
|
|
|
|
void *blockIO;
|
|
const void *constBlockIO;
|
|
void *defaultParam;
|
|
ZCSigState *prevZCSigState;
|
|
real_T *contStates;
|
|
int_T *periodicContStateIndices;
|
|
real_T *periodicContStateRanges;
|
|
real_T *derivs;
|
|
void *zcSignalValues;
|
|
void *inputs;
|
|
void *outputs;
|
|
boolean_T *contStateDisabled;
|
|
boolean_T zCCacheNeedsReset;
|
|
boolean_T derivCacheNeedsReset;
|
|
boolean_T CTOutputIncnstWithState;
|
|
void *dwork;
|
|
|
|
/*
|
|
* DataMapInfo:
|
|
* The following substructure contains information regarding
|
|
* structures generated in the model's C API.
|
|
*/
|
|
struct {
|
|
rtwCAPI_ModelMappingInfo mmi;
|
|
} DataMapInfo;
|
|
|
|
/*
|
|
* Sizes:
|
|
* The following substructure contains sizes information
|
|
* for many of the model attributes such as inputs, outputs,
|
|
* dwork, sample times, etc.
|
|
*/
|
|
struct {
|
|
uint32_T checksums[4];
|
|
uint32_T options;
|
|
int_T numContStates;
|
|
int_T numPeriodicContStates;
|
|
int_T numU;
|
|
int_T numY;
|
|
int_T numSampTimes;
|
|
int_T numBlocks;
|
|
int_T numBlockIO;
|
|
int_T numBlockPrms;
|
|
int_T numDwork;
|
|
int_T numSFcnPrms;
|
|
int_T numSFcns;
|
|
int_T numIports;
|
|
int_T numOports;
|
|
int_T numNonSampZCs;
|
|
int_T sysDirFeedThru;
|
|
int_T rtwGenSfcn;
|
|
} Sizes;
|
|
|
|
/*
|
|
* SpecialInfo:
|
|
* The following substructure contains special information
|
|
* related to other components that are dependent on RTW.
|
|
*/
|
|
struct {
|
|
const void *mappingInfo;
|
|
void *xpcData;
|
|
} SpecialInfo;
|
|
|
|
/*
|
|
* Timing:
|
|
* The following substructure contains information regarding
|
|
* the timing information for the model.
|
|
*/
|
|
struct {
|
|
time_T stepSize;
|
|
uint32_T clockTick0;
|
|
uint32_T clockTickH0;
|
|
time_T stepSize0;
|
|
uint32_T clockTick1;
|
|
uint32_T clockTickH1;
|
|
time_T stepSize1;
|
|
time_T tStart;
|
|
time_T tFinal;
|
|
time_T timeOfLastOutput;
|
|
void *timingData;
|
|
real_T *varNextHitTimesList;
|
|
SimTimeStep simTimeStep;
|
|
boolean_T stopRequestedFlag;
|
|
time_T *sampleTimes;
|
|
time_T *offsetTimes;
|
|
int_T *sampleTimeTaskIDPtr;
|
|
int_T *sampleHits;
|
|
int_T *perTaskSampleHits;
|
|
time_T *t;
|
|
time_T sampleTimesArray[2];
|
|
time_T offsetTimesArray[2];
|
|
int_T sampleTimeTaskIDArray[2];
|
|
int_T sampleHitArray[2];
|
|
int_T perTaskSampleHitsArray[4];
|
|
time_T tArray[2];
|
|
} Timing;
|
|
};
|
|
|
|
/* Block parameters (default storage) */
|
|
extern P_WheelSpd1_T WheelSpd1_P;
|
|
|
|
/* Block signals (default storage) */
|
|
extern B_WheelSpd1_T WheelSpd1_B;
|
|
|
|
/* Block states (default storage) */
|
|
extern DW_WheelSpd1_T WheelSpd1_DW;
|
|
|
|
/*====================*
|
|
* External functions *
|
|
*====================*/
|
|
extern WheelSpd1_rtModel *WheelSpd1(void);
|
|
extern void MdlInitializeSizes(void);
|
|
extern void MdlInitializeSampleTimes(void);
|
|
extern void MdlInitialize(void);
|
|
extern void MdlStart(void);
|
|
extern void MdlOutputs(int_T tid);
|
|
extern void MdlUpdate(int_T tid);
|
|
extern void MdlTerminate(void);
|
|
|
|
/* Function to get C API Model Mapping Static Info */
|
|
extern const rtwCAPI_ModelMappingStaticInfo*
|
|
WheelSpd1_GetCAPIStaticMap(void);
|
|
|
|
/* Real-time Model object */
|
|
extern RT_MODEL_WheelSpd1_T *const WheelSpd1_M;
|
|
|
|
/*-
|
|
* The generated code includes comments that allow you to trace directly
|
|
* back to the appropriate location in the model. The basic format
|
|
* is <system>/block_name, where system is the system number (uniquely
|
|
* assigned by Simulink) and block_name is the name of the block.
|
|
*
|
|
* Use the MATLAB hilite_system command to trace the generated code back
|
|
* to the model. For example,
|
|
*
|
|
* hilite_system('<S3>') - opens system 3
|
|
* hilite_system('<S3>/Kp') - opens and selects block Kp which resides in S3
|
|
*
|
|
* Here is the system hierarchy for this model
|
|
*
|
|
* '<Root>' : 'WheelSpd1'
|
|
* '<S1>' : 'WheelSpd1/DAQ_In'
|
|
* '<S2>' : 'WheelSpd1/DAQ_Out'
|
|
* '<S3>' : 'WheelSpd1/Input Signal Conditioning'
|
|
* '<S4>' : 'WheelSpd1/Mon_Cont'
|
|
* '<S5>' : 'WheelSpd1/DAQ_Out/CANBoard'
|
|
* '<S6>' : 'WheelSpd1/Mon_Cont/Chirp Signal'
|
|
* '<S7>' : 'WheelSpd1/Mon_Cont/DOB'
|
|
* '<S8>' : 'WheelSpd1/Mon_Cont/FF+PID Controller'
|
|
* '<S9>' : 'WheelSpd1/Mon_Cont/LPFM'
|
|
* '<S10>' : 'WheelSpd1/Mon_Cont/Signal Builder'
|
|
* '<S11>' : 'WheelSpd1/Mon_Cont/DOB/Dot3'
|
|
* '<S12>' : 'WheelSpd1/Mon_Cont/DOB/Dot4'
|
|
* '<S13>' : 'WheelSpd1/Mon_Cont/DOB/Dot5'
|
|
* '<S14>' : 'WheelSpd1/Mon_Cont/DOB/LPFM'
|
|
* '<S15>' : 'WheelSpd1/Mon_Cont/DOB/Second order LPF'
|
|
* '<S16>' : 'WheelSpd1/Mon_Cont/FF+PID Controller/FB'
|
|
* '<S17>' : 'WheelSpd1/Mon_Cont/FF+PID Controller/FF'
|
|
* '<S18>' : 'WheelSpd1/Mon_Cont/FF+PID Controller/FB/P'
|
|
* '<S19>' : 'WheelSpd1/Mon_Cont/FF+PID Controller/FB/PI'
|
|
* '<S20>' : 'WheelSpd1/Mon_Cont/FF+PID Controller/FB/PI/HPF'
|
|
* '<S21>' : 'WheelSpd1/Mon_Cont/FF+PID Controller/FB/PI/Integrator1'
|
|
* '<S22>' : 'WheelSpd1/Mon_Cont/FF+PID Controller/FF/Dot'
|
|
* '<S23>' : 'WheelSpd1/Mon_Cont/FF+PID Controller/FF/Dot2'
|
|
* '<S24>' : 'WheelSpd1/Mon_Cont/FF+PID Controller/FF/Dot3'
|
|
* '<S25>' : 'WheelSpd1/Mon_Cont/FF+PID Controller/FF/LPFM'
|
|
* '<S26>' : 'WheelSpd1/Mon_Cont/FF+PID Controller/FF/Second order LPF'
|
|
*/
|
|
#endif /* RTW_HEADER_WheelSpd1_h_ */
|