mirror of
https://github.com/Dev-KATECH/ADM.git
synced 2026-05-17 01:43:59 +09:00
1432 lines
47 KiB
C
1432 lines
47 KiB
C
/*
|
|
* CANTest.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 "CANTest".
|
|
*
|
|
* Model version : 1.360
|
|
* Simulink Coder version : 8.14 (R2018a) 06-Feb-2018
|
|
* C source code generated on : Tue Jul 11 11:56:08 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_CANTest_h_
|
|
#define RTW_HEADER_CANTest_h_
|
|
#include <stddef.h>
|
|
#include <string.h>
|
|
#include "rtw_modelmap.h"
|
|
#ifndef CANTest_COMMON_INCLUDES_
|
|
# define CANTest_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 /* CANTest_COMMON_INCLUDES_ */
|
|
|
|
#include "CANTest_types.h"
|
|
|
|
/* Shared type includes */
|
|
#include "multiword_types.h"
|
|
#include "rt_defines.h"
|
|
#include "rt_nonfinite.h"
|
|
|
|
/* Macros for accessing real-time model data structure */
|
|
#ifndef 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) 0
|
|
#endif
|
|
|
|
#ifndef rtmGetErrorStatus
|
|
# define rtmGetErrorStatus(rtm) ((rtm)->errorStatus)
|
|
#endif
|
|
|
|
#ifndef rtmSetErrorStatus
|
|
# define rtmSetErrorStatus(rtm, val) ((rtm)->errorStatus = (val))
|
|
#endif
|
|
|
|
#ifndef rtmIsSampleHit
|
|
# define rtmIsSampleHit(rtm, sti, tid) ((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_CANTest RT_MODEL_CANTest_T
|
|
|
|
/* Definition for use in the target main file */
|
|
#define CANTest_rtModel RT_MODEL_CANTest_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 d1; /* '<S6>/d1' */
|
|
real_T Sum3; /* '<S6>/Sum3' */
|
|
real_T gain; /* '<S6>/gain' */
|
|
real_T gain2; /* '<S6>/gain2' */
|
|
real_T Product2; /* '<S6>/Product2' */
|
|
real_T gain1; /* '<S6>/gain1' */
|
|
real_T Sum1; /* '<S6>/Sum1' */
|
|
real_T d; /* '<S6>/d' */
|
|
real_T Product11; /* '<S6>/Product11' */
|
|
real_T Sum2; /* '<S6>/Sum2' */
|
|
real_T Sum4; /* '<S6>/Sum4' */
|
|
real_T Product1; /* '<S6>/Product1' */
|
|
real_T RPM; /* '<S1>/CAN Unpack2' */
|
|
real_T TQ; /* '<S1>/CAN Unpack2' */
|
|
boolean_T CANRead1_o1; /* '<S1>/CAN Read1' */
|
|
} B_CANTest_T;
|
|
|
|
/* Block states (default storage) for system '<Root>' */
|
|
typedef struct {
|
|
real_T d1_DSTATE; /* '<S6>/d1' */
|
|
real_T d_DSTATE; /* '<S6>/d' */
|
|
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 */
|
|
|
|
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_CANTest_T;
|
|
|
|
/* Backward compatible GRT Identifiers */
|
|
#define rtB CANTest_B
|
|
#define BlockIO B_CANTest_T
|
|
#define rtP CANTest_P
|
|
#define Parameters P_CANTest_T
|
|
#define rtDWork CANTest_DW
|
|
#define D_Work DW_CANTest_T
|
|
|
|
/* Parameters (default storage) */
|
|
struct P_CANTest_T_ {
|
|
real_T Ts; /* Variable: Ts
|
|
* Referenced by:
|
|
* '<S6>/Constant'
|
|
* '<S6>/gain'
|
|
*/
|
|
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 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: -2
|
|
* Referenced by: '<S5>/Constant4'
|
|
*/
|
|
real_T TQCom_Value; /* Expression: 0
|
|
* Referenced by: '<S4>/TQCom'
|
|
*/
|
|
real_T d1_InitialCondition; /* Expression: 0
|
|
* Referenced by: '<S6>/d1'
|
|
*/
|
|
real_T Constant1_Value_a; /* Expression: 1
|
|
* Referenced by: '<S6>/Constant1'
|
|
*/
|
|
real_T Constant1_Value_j; /* Expression: 5
|
|
* Referenced by: '<S4>/Constant1'
|
|
*/
|
|
real_T gain2_Gain; /* Expression: 2*pi
|
|
* Referenced by: '<S6>/gain2'
|
|
*/
|
|
real_T gain1_Gain; /* Expression: 2
|
|
* Referenced by: '<S6>/gain1'
|
|
*/
|
|
real_T d_InitialCondition; /* Expression: 0
|
|
* Referenced by: '<S6>/d'
|
|
*/
|
|
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'
|
|
*/
|
|
};
|
|
|
|
/* Real-time Model Data Structure */
|
|
struct tag_RTM_CANTest_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[1];
|
|
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;
|
|
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[1];
|
|
time_T offsetTimesArray[1];
|
|
int_T sampleTimeTaskIDArray[1];
|
|
int_T sampleHitArray[1];
|
|
int_T perTaskSampleHitsArray[1];
|
|
time_T tArray[1];
|
|
} Timing;
|
|
};
|
|
|
|
/* Block parameters (default storage) */
|
|
extern P_CANTest_T CANTest_P;
|
|
|
|
/* Block signals (default storage) */
|
|
extern B_CANTest_T CANTest_B;
|
|
|
|
/* Block states (default storage) */
|
|
extern DW_CANTest_T CANTest_DW;
|
|
|
|
/*====================*
|
|
* External functions *
|
|
*====================*/
|
|
extern CANTest_rtModel *CANTest(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*
|
|
CANTest_GetCAPIStaticMap(void);
|
|
|
|
/* Real-time Model object */
|
|
extern RT_MODEL_CANTest_T *const CANTest_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>' : 'CANTest'
|
|
* '<S1>' : 'CANTest/DAQ_In'
|
|
* '<S2>' : 'CANTest/DAQ_Out'
|
|
* '<S3>' : 'CANTest/Input Signal Conditioning'
|
|
* '<S4>' : 'CANTest/Mon_Cont'
|
|
* '<S5>' : 'CANTest/DAQ_Out/CANBoard'
|
|
* '<S6>' : 'CANTest/Mon_Cont/LPFM'
|
|
*/
|
|
#endif /* RTW_HEADER_CANTest_h_ */
|