From 3ed1b56a865e09b37b72aa9bbf4457d455765100 Mon Sep 17 00:00:00 2001 From: Emilio Corigliano <emilio.corigliano@skywarder.eu> Date: Wed, 25 Oct 2023 18:41:07 +0200 Subject: [PATCH] [Coder][ADA] Inserted the autocoded and packed ADA files --- .../ADA/run_ADA_grt_rtw/CMakeLists.txt | 105 ++ .../run_ADA/ADA/run_ADA_grt_rtw/buildInfo.mat | Bin 0 -> 25213 bytes .../ADA/run_ADA_grt_rtw/multiword_types.h | 1167 +++++++++++++++++ .../run_ADA/ADA/run_ADA_grt_rtw/rtmodel.h | 39 + .../run_ADA/ADA/run_ADA_grt_rtw/rtwtypes.h | 41 + .../run_ADA/ADA/run_ADA_grt_rtw/run_ADA.cpp | 347 +++++ .../run_ADA/ADA/run_ADA_grt_rtw/run_ADA.h | 212 +++ .../ADA/run_ADA_grt_rtw/run_ADA_data.cpp | 41 + .../ADA/run_ADA_grt_rtw/run_ADA_private.h | 26 + .../ADA/run_ADA_grt_rtw/run_ADA_types.h | 43 + .../run_ADA/R2023a/extern/include/tmwtypes.h | 888 +++++++++++++ .../rtw/c/src/common/rt_cppclass_main.cpp | 452 +++++++ .../rtw/c/src/ext_mode/common/ext_work.h | 127 ++ .../run_ADA/R2023a/rtw/c/src/rt_logging.h | 290 ++++ .../R2023a/simulink/include/rtw_continuous.h | 109 ++ .../R2023a/simulink/include/rtw_solver.h | 292 +++++ 16 files changed, 4179 insertions(+) create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/CMakeLists.txt create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/buildInfo.mat create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/multiword_types.h create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/rtmodel.h create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/rtwtypes.h create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA.cpp create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA.h create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA_data.cpp create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA_private.h create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA_types.h create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/extern/include/tmwtypes.h create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/rtw/c/src/common/rt_cppclass_main.cpp create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/rtw/c/src/ext_mode/common/ext_work.h create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/rtw/c/src/rt_logging.h create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/simulink/include/rtw_continuous.h create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/simulink/include/rtw_solver.h diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/CMakeLists.txt b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/CMakeLists.txt new file mode 100644 index 000000000..9218d4ba5 --- /dev/null +++ b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/CMakeLists.txt @@ -0,0 +1,105 @@ +###################################################################### +# CMakeLists.txt generated for component run_ADA +# Product type: executable +###################################################################### +cmake_minimum_required(VERSION 3.12) +project(run_ADA) +if(DEFINED ENV{CMAKE_EXPORT_COMPILE_COMMANDS} AND NOT DEFINED CMAKE_EXPORT_COMPILE_COMMANDS) + set(CMAKE_EXPORT_COMPILE_COMMANDS $ENV{CMAKE_EXPORT_COMPILE_COMMANDS}) +endif() + + +###################################################################### +## Path variables +###################################################################### +get_filename_component(START_DIR .. ABSOLUTE) +set(MATLAB_ROOT C:/Program\ Files/MATLAB/R2023a CACHE PATH "") +if(${CMAKE_CURRENT_BINARY_DIR} STREQUAL ${CMAKE_CURRENT_SOURCE_DIR}) + set(BUILDING_IN_SOURCE_DIR TRUE) + set(BINARY_START_DIR "${START_DIR}") +else() + set(BUILDING_IN_SOURCE_DIR FALSE) + set(BINARY_START_DIR "${CMAKE_BINARY_DIR}") +endif() +if(WIN32 AND NOT MINGW) + set(SYSLIB_PREFIX "lib") +else() + set(SYSLIB_PREFIX "") +endif() + +###################################################################### +## System libraries +###################################################################### +find_library(FOUND_LIBM m NO_SYSTEM_ENVIRONMENT_PATH PATHS ${CMAKE_C_IMPLICIT_LINK_DIRECTORIES} + ${CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES}) + +###################################################################### +## Target definition and commands +###################################################################### +add_executable(run_ADA ${START_DIR}/run_ADA_grt_rtw/run_ADA.cpp + ${START_DIR}/run_ADA_grt_rtw/run_ADA_data.cpp + ${MATLAB_ROOT}/rtw/c/src/common/rt_cppclass_main.cpp) +set_target_properties(run_ADA PROPERTIES + PREFIX "" + POSITION_INDEPENDENT_CODE ON + RUNTIME_OUTPUT_DIRECTORY "${BINARY_START_DIR}/./$<0:>" + LIBRARY_OUTPUT_DIRECTORY "${BINARY_START_DIR}/./$<0:>" + ARCHIVE_OUTPUT_DIRECTORY "${BINARY_START_DIR}/./$<0:>") +target_compile_features(run_ADA PUBLIC cxx_std_11) +target_compile_definitions(run_ADA PRIVATE -DMODEL=run_ADA + -DNUMST=1 + -DNCSTATES=0 + -DHAVESTDIO + -DRT + -DUSE_RTMODEL + -DCLASSIC_INTERFACE=0 + -DALLOCATIONFCN=0 + -DTID01EQ=0 + -DMAT_FILE=0 + -DONESTEPFCN=1 + -DTERMFCN=1 + -DMULTI_INSTANCE_CODE=1 + -DINTEGER_CODE=0 + -DMT=0) +target_include_directories(run_ADA PRIVATE ${START_DIR} + ${START_DIR}/run_ADA_grt_rtw + ${MATLAB_ROOT}/extern/include + ${MATLAB_ROOT}/simulink/include + ${MATLAB_ROOT}/rtw/c/src + ${MATLAB_ROOT}/rtw/c/src/ext_mode/common) +target_link_libraries(run_ADA PRIVATE $<$<BOOL:${FOUND_LIBM}>:m>) +if(WIN32) + target_link_libraries(run_ADA PRIVATE kernel32 + ws2_32 + mswsock + advapi32) +endif() + +###################################################################### +## Extract debug symbols +###################################################################### +if(APPLE AND (CMAKE_C_COMPILER_ID STREQUAL "AppleClang")) + string(APPEND _dsymutilcmd "$<IF:$<CONFIG:DEBUG,RELWITHDEBINFO>," + "xcrun;dsymutil;$<TARGET_FILE:run_ADA>;--flat," + "true" + >) + add_custom_command(TARGET run_ADA + POST_BUILD + COMMAND "${_dsymutilcmd}" + COMMAND_EXPAND_LISTS + BYPRODUCTS run_ADA.dwarf) +endif() + + +###################################################################### +## Build success message +###################################################################### +add_custom_command(TARGET run_ADA POST_BUILD + COMMAND ${CMAKE_COMMAND} -E cmake_echo_color --cyan "\\#\\#\\# Created executable: $<TARGET_FILE:run_ADA>") + +###################################################################### +## Call toolchain hook function if defined +###################################################################### +if(COMMAND toolchain_target_hook) + toolchain_target_hook(run_ADA) +endif() diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/buildInfo.mat b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/buildInfo.mat new file mode 100644 index 0000000000000000000000000000000000000000..003c26d1bbf82b717b08edb897e43d006ab0bba0 GIT binary patch literal 25213 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 A761SM literal 0 HcmV?d00001 diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/multiword_types.h b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/multiword_types.h new file mode 100644 index 000000000..7baddd213 --- /dev/null +++ b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/multiword_types.h @@ -0,0 +1,1167 @@ +/* + * multiword_types.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 "run_ADA". + * + * Model version : 1.25 + * Simulink Coder version : 9.9 (R2023a) 19-Nov-2022 + * C++ source code generated on : Wed Oct 25 17:58:39 2023 + * + * Target selection: grt.tlc + * Note: GRT includes extra infrastructure and instrumentation for prototyping + * Embedded hardware selection: Intel->x86-64 (Windows64) + * Code generation objective: Execution efficiency + * Validation result: Not run + */ + +#ifndef MULTIWORD_TYPES_H +#define MULTIWORD_TYPES_H +#include "rtwtypes.h" + +/* + * MultiWord supporting definitions + */ +typedef long int long_T; + +/* + * MultiWord types + */ +typedef struct { + uint32_T chunks[2]; +} int64m_T; + +typedef struct { + int64m_T re; + int64m_T im; +} cint64m_T; + +typedef struct { + uint32_T chunks[2]; +} uint64m_T; + +typedef struct { + uint64m_T re; + uint64m_T im; +} cuint64m_T; + +typedef struct { + uint32_T chunks[3]; +} int96m_T; + +typedef struct { + int96m_T re; + int96m_T im; +} cint96m_T; + +typedef struct { + uint32_T chunks[3]; +} uint96m_T; + +typedef struct { + uint96m_T re; + uint96m_T im; +} cuint96m_T; + +typedef struct { + uint32_T chunks[4]; +} int128m_T; + +typedef struct { + int128m_T re; + int128m_T im; +} cint128m_T; + +typedef struct { + uint32_T chunks[4]; +} uint128m_T; + +typedef struct { + uint128m_T re; + uint128m_T im; +} cuint128m_T; + +typedef struct { + uint32_T chunks[5]; +} int160m_T; + +typedef struct { + int160m_T re; + int160m_T im; +} cint160m_T; + +typedef struct { + uint32_T chunks[5]; +} uint160m_T; + +typedef struct { + uint160m_T re; + uint160m_T im; +} cuint160m_T; + +typedef struct { + uint32_T chunks[6]; +} int192m_T; + +typedef struct { + int192m_T re; + int192m_T im; +} cint192m_T; + +typedef struct { + uint32_T chunks[6]; +} uint192m_T; + +typedef struct { + uint192m_T re; + uint192m_T im; +} cuint192m_T; + +typedef struct { + uint32_T chunks[7]; +} int224m_T; + +typedef struct { + int224m_T re; + int224m_T im; +} cint224m_T; + +typedef struct { + uint32_T chunks[7]; +} uint224m_T; + +typedef struct { + uint224m_T re; + uint224m_T im; +} cuint224m_T; + +typedef struct { + uint32_T chunks[8]; +} int256m_T; + +typedef struct { + int256m_T re; + int256m_T im; +} cint256m_T; + +typedef struct { + uint32_T chunks[8]; +} uint256m_T; + +typedef struct { + uint256m_T re; + uint256m_T im; +} cuint256m_T; + +typedef struct { + uint32_T chunks[9]; +} int288m_T; + +typedef struct { + int288m_T re; + int288m_T im; +} cint288m_T; + +typedef struct { + uint32_T chunks[9]; +} uint288m_T; + +typedef struct { + uint288m_T re; + uint288m_T im; +} cuint288m_T; + +typedef struct { + uint32_T chunks[10]; +} int320m_T; + +typedef struct { + int320m_T re; + int320m_T im; +} cint320m_T; + +typedef struct { + uint32_T chunks[10]; +} uint320m_T; + +typedef struct { + uint320m_T re; + uint320m_T im; +} cuint320m_T; + +typedef struct { + uint32_T chunks[11]; +} int352m_T; + +typedef struct { + int352m_T re; + int352m_T im; +} cint352m_T; + +typedef struct { + uint32_T chunks[11]; +} uint352m_T; + +typedef struct { + uint352m_T re; + uint352m_T im; +} cuint352m_T; + +typedef struct { + uint32_T chunks[12]; +} int384m_T; + +typedef struct { + int384m_T re; + int384m_T im; +} cint384m_T; + +typedef struct { + uint32_T chunks[12]; +} uint384m_T; + +typedef struct { + uint384m_T re; + uint384m_T im; +} cuint384m_T; + +typedef struct { + uint32_T chunks[13]; +} int416m_T; + +typedef struct { + int416m_T re; + int416m_T im; +} cint416m_T; + +typedef struct { + uint32_T chunks[13]; +} uint416m_T; + +typedef struct { + uint416m_T re; + uint416m_T im; +} cuint416m_T; + +typedef struct { + uint32_T chunks[14]; +} int448m_T; + +typedef struct { + int448m_T re; + int448m_T im; +} cint448m_T; + +typedef struct { + uint32_T chunks[14]; +} uint448m_T; + +typedef struct { + uint448m_T re; + uint448m_T im; +} cuint448m_T; + +typedef struct { + uint32_T chunks[15]; +} int480m_T; + +typedef struct { + int480m_T re; + int480m_T im; +} cint480m_T; + +typedef struct { + uint32_T chunks[15]; +} uint480m_T; + +typedef struct { + uint480m_T re; + uint480m_T im; +} cuint480m_T; + +typedef struct { + uint32_T chunks[16]; +} int512m_T; + +typedef struct { + int512m_T re; + int512m_T im; +} cint512m_T; + +typedef struct { + uint32_T chunks[16]; +} uint512m_T; + +typedef struct { + uint512m_T re; + uint512m_T im; +} cuint512m_T; + +typedef struct { + uint32_T chunks[17]; +} int544m_T; + +typedef struct { + int544m_T re; + int544m_T im; +} cint544m_T; + +typedef struct { + uint32_T chunks[17]; +} uint544m_T; + +typedef struct { + uint544m_T re; + uint544m_T im; +} cuint544m_T; + +typedef struct { + uint32_T chunks[18]; +} int576m_T; + +typedef struct { + int576m_T re; + int576m_T im; +} cint576m_T; + +typedef struct { + uint32_T chunks[18]; +} uint576m_T; + +typedef struct { + uint576m_T re; + uint576m_T im; +} cuint576m_T; + +typedef struct { + uint32_T chunks[19]; +} int608m_T; + +typedef struct { + int608m_T re; + int608m_T im; +} cint608m_T; + +typedef struct { + uint32_T chunks[19]; +} uint608m_T; + +typedef struct { + uint608m_T re; + uint608m_T im; +} cuint608m_T; + +typedef struct { + uint32_T chunks[20]; +} int640m_T; + +typedef struct { + int640m_T re; + int640m_T im; +} cint640m_T; + +typedef struct { + uint32_T chunks[20]; +} uint640m_T; + +typedef struct { + uint640m_T re; + uint640m_T im; +} cuint640m_T; + +typedef struct { + uint32_T chunks[21]; +} int672m_T; + +typedef struct { + int672m_T re; + int672m_T im; +} cint672m_T; + +typedef struct { + uint32_T chunks[21]; +} uint672m_T; + +typedef struct { + uint672m_T re; + uint672m_T im; +} cuint672m_T; + +typedef struct { + uint32_T chunks[22]; +} int704m_T; + +typedef struct { + int704m_T re; + int704m_T im; +} cint704m_T; + +typedef struct { + uint32_T chunks[22]; +} uint704m_T; + +typedef struct { + uint704m_T re; + uint704m_T im; +} cuint704m_T; + +typedef struct { + uint32_T chunks[23]; +} int736m_T; + +typedef struct { + int736m_T re; + int736m_T im; +} cint736m_T; + +typedef struct { + uint32_T chunks[23]; +} uint736m_T; + +typedef struct { + uint736m_T re; + uint736m_T im; +} cuint736m_T; + +typedef struct { + uint32_T chunks[24]; +} int768m_T; + +typedef struct { + int768m_T re; + int768m_T im; +} cint768m_T; + +typedef struct { + uint32_T chunks[24]; +} uint768m_T; + +typedef struct { + uint768m_T re; + uint768m_T im; +} cuint768m_T; + +typedef struct { + uint32_T chunks[25]; +} int800m_T; + +typedef struct { + int800m_T re; + int800m_T im; +} cint800m_T; + +typedef struct { + uint32_T chunks[25]; +} uint800m_T; + +typedef struct { + uint800m_T re; + uint800m_T im; +} cuint800m_T; + +typedef struct { + uint32_T chunks[26]; +} int832m_T; + +typedef struct { + int832m_T re; + int832m_T im; +} cint832m_T; + +typedef struct { + uint32_T chunks[26]; +} uint832m_T; + +typedef struct { + uint832m_T re; + uint832m_T im; +} cuint832m_T; + +typedef struct { + uint32_T chunks[27]; +} int864m_T; + +typedef struct { + int864m_T re; + int864m_T im; +} cint864m_T; + +typedef struct { + uint32_T chunks[27]; +} uint864m_T; + +typedef struct { + uint864m_T re; + uint864m_T im; +} cuint864m_T; + +typedef struct { + uint32_T chunks[28]; +} int896m_T; + +typedef struct { + int896m_T re; + int896m_T im; +} cint896m_T; + +typedef struct { + uint32_T chunks[28]; +} uint896m_T; + +typedef struct { + uint896m_T re; + uint896m_T im; +} cuint896m_T; + +typedef struct { + uint32_T chunks[29]; +} int928m_T; + +typedef struct { + int928m_T re; + int928m_T im; +} cint928m_T; + +typedef struct { + uint32_T chunks[29]; +} uint928m_T; + +typedef struct { + uint928m_T re; + uint928m_T im; +} cuint928m_T; + +typedef struct { + uint32_T chunks[30]; +} int960m_T; + +typedef struct { + int960m_T re; + int960m_T im; +} cint960m_T; + +typedef struct { + uint32_T chunks[30]; +} uint960m_T; + +typedef struct { + uint960m_T re; + uint960m_T im; +} cuint960m_T; + +typedef struct { + uint32_T chunks[31]; +} int992m_T; + +typedef struct { + int992m_T re; + int992m_T im; +} cint992m_T; + +typedef struct { + uint32_T chunks[31]; +} uint992m_T; + +typedef struct { + uint992m_T re; + uint992m_T im; +} cuint992m_T; + +typedef struct { + uint32_T chunks[32]; +} int1024m_T; + +typedef struct { + int1024m_T re; + int1024m_T im; +} cint1024m_T; + +typedef struct { + uint32_T chunks[32]; +} uint1024m_T; + +typedef struct { + uint1024m_T re; + uint1024m_T im; +} cuint1024m_T; + +typedef struct { + uint32_T chunks[33]; +} int1056m_T; + +typedef struct { + int1056m_T re; + int1056m_T im; +} cint1056m_T; + +typedef struct { + uint32_T chunks[33]; +} uint1056m_T; + +typedef struct { + uint1056m_T re; + uint1056m_T im; +} cuint1056m_T; + +typedef struct { + uint32_T chunks[34]; +} int1088m_T; + +typedef struct { + int1088m_T re; + int1088m_T im; +} cint1088m_T; + +typedef struct { + uint32_T chunks[34]; +} uint1088m_T; + +typedef struct { + uint1088m_T re; + uint1088m_T im; +} cuint1088m_T; + +typedef struct { + uint32_T chunks[35]; +} int1120m_T; + +typedef struct { + int1120m_T re; + int1120m_T im; +} cint1120m_T; + +typedef struct { + uint32_T chunks[35]; +} uint1120m_T; + +typedef struct { + uint1120m_T re; + uint1120m_T im; +} cuint1120m_T; + +typedef struct { + uint32_T chunks[36]; +} int1152m_T; + +typedef struct { + int1152m_T re; + int1152m_T im; +} cint1152m_T; + +typedef struct { + uint32_T chunks[36]; +} uint1152m_T; + +typedef struct { + uint1152m_T re; + uint1152m_T im; +} cuint1152m_T; + +typedef struct { + uint32_T chunks[37]; +} int1184m_T; + +typedef struct { + int1184m_T re; + int1184m_T im; +} cint1184m_T; + +typedef struct { + uint32_T chunks[37]; +} uint1184m_T; + +typedef struct { + uint1184m_T re; + uint1184m_T im; +} cuint1184m_T; + +typedef struct { + uint32_T chunks[38]; +} int1216m_T; + +typedef struct { + int1216m_T re; + int1216m_T im; +} cint1216m_T; + +typedef struct { + uint32_T chunks[38]; +} uint1216m_T; + +typedef struct { + uint1216m_T re; + uint1216m_T im; +} cuint1216m_T; + +typedef struct { + uint32_T chunks[39]; +} int1248m_T; + +typedef struct { + int1248m_T re; + int1248m_T im; +} cint1248m_T; + +typedef struct { + uint32_T chunks[39]; +} uint1248m_T; + +typedef struct { + uint1248m_T re; + uint1248m_T im; +} cuint1248m_T; + +typedef struct { + uint32_T chunks[40]; +} int1280m_T; + +typedef struct { + int1280m_T re; + int1280m_T im; +} cint1280m_T; + +typedef struct { + uint32_T chunks[40]; +} uint1280m_T; + +typedef struct { + uint1280m_T re; + uint1280m_T im; +} cuint1280m_T; + +typedef struct { + uint32_T chunks[41]; +} int1312m_T; + +typedef struct { + int1312m_T re; + int1312m_T im; +} cint1312m_T; + +typedef struct { + uint32_T chunks[41]; +} uint1312m_T; + +typedef struct { + uint1312m_T re; + uint1312m_T im; +} cuint1312m_T; + +typedef struct { + uint32_T chunks[42]; +} int1344m_T; + +typedef struct { + int1344m_T re; + int1344m_T im; +} cint1344m_T; + +typedef struct { + uint32_T chunks[42]; +} uint1344m_T; + +typedef struct { + uint1344m_T re; + uint1344m_T im; +} cuint1344m_T; + +typedef struct { + uint32_T chunks[43]; +} int1376m_T; + +typedef struct { + int1376m_T re; + int1376m_T im; +} cint1376m_T; + +typedef struct { + uint32_T chunks[43]; +} uint1376m_T; + +typedef struct { + uint1376m_T re; + uint1376m_T im; +} cuint1376m_T; + +typedef struct { + uint32_T chunks[44]; +} int1408m_T; + +typedef struct { + int1408m_T re; + int1408m_T im; +} cint1408m_T; + +typedef struct { + uint32_T chunks[44]; +} uint1408m_T; + +typedef struct { + uint1408m_T re; + uint1408m_T im; +} cuint1408m_T; + +typedef struct { + uint32_T chunks[45]; +} int1440m_T; + +typedef struct { + int1440m_T re; + int1440m_T im; +} cint1440m_T; + +typedef struct { + uint32_T chunks[45]; +} uint1440m_T; + +typedef struct { + uint1440m_T re; + uint1440m_T im; +} cuint1440m_T; + +typedef struct { + uint32_T chunks[46]; +} int1472m_T; + +typedef struct { + int1472m_T re; + int1472m_T im; +} cint1472m_T; + +typedef struct { + uint32_T chunks[46]; +} uint1472m_T; + +typedef struct { + uint1472m_T re; + uint1472m_T im; +} cuint1472m_T; + +typedef struct { + uint32_T chunks[47]; +} int1504m_T; + +typedef struct { + int1504m_T re; + int1504m_T im; +} cint1504m_T; + +typedef struct { + uint32_T chunks[47]; +} uint1504m_T; + +typedef struct { + uint1504m_T re; + uint1504m_T im; +} cuint1504m_T; + +typedef struct { + uint32_T chunks[48]; +} int1536m_T; + +typedef struct { + int1536m_T re; + int1536m_T im; +} cint1536m_T; + +typedef struct { + uint32_T chunks[48]; +} uint1536m_T; + +typedef struct { + uint1536m_T re; + uint1536m_T im; +} cuint1536m_T; + +typedef struct { + uint32_T chunks[49]; +} int1568m_T; + +typedef struct { + int1568m_T re; + int1568m_T im; +} cint1568m_T; + +typedef struct { + uint32_T chunks[49]; +} uint1568m_T; + +typedef struct { + uint1568m_T re; + uint1568m_T im; +} cuint1568m_T; + +typedef struct { + uint32_T chunks[50]; +} int1600m_T; + +typedef struct { + int1600m_T re; + int1600m_T im; +} cint1600m_T; + +typedef struct { + uint32_T chunks[50]; +} uint1600m_T; + +typedef struct { + uint1600m_T re; + uint1600m_T im; +} cuint1600m_T; + +typedef struct { + uint32_T chunks[51]; +} int1632m_T; + +typedef struct { + int1632m_T re; + int1632m_T im; +} cint1632m_T; + +typedef struct { + uint32_T chunks[51]; +} uint1632m_T; + +typedef struct { + uint1632m_T re; + uint1632m_T im; +} cuint1632m_T; + +typedef struct { + uint32_T chunks[52]; +} int1664m_T; + +typedef struct { + int1664m_T re; + int1664m_T im; +} cint1664m_T; + +typedef struct { + uint32_T chunks[52]; +} uint1664m_T; + +typedef struct { + uint1664m_T re; + uint1664m_T im; +} cuint1664m_T; + +typedef struct { + uint32_T chunks[53]; +} int1696m_T; + +typedef struct { + int1696m_T re; + int1696m_T im; +} cint1696m_T; + +typedef struct { + uint32_T chunks[53]; +} uint1696m_T; + +typedef struct { + uint1696m_T re; + uint1696m_T im; +} cuint1696m_T; + +typedef struct { + uint32_T chunks[54]; +} int1728m_T; + +typedef struct { + int1728m_T re; + int1728m_T im; +} cint1728m_T; + +typedef struct { + uint32_T chunks[54]; +} uint1728m_T; + +typedef struct { + uint1728m_T re; + uint1728m_T im; +} cuint1728m_T; + +typedef struct { + uint32_T chunks[55]; +} int1760m_T; + +typedef struct { + int1760m_T re; + int1760m_T im; +} cint1760m_T; + +typedef struct { + uint32_T chunks[55]; +} uint1760m_T; + +typedef struct { + uint1760m_T re; + uint1760m_T im; +} cuint1760m_T; + +typedef struct { + uint32_T chunks[56]; +} int1792m_T; + +typedef struct { + int1792m_T re; + int1792m_T im; +} cint1792m_T; + +typedef struct { + uint32_T chunks[56]; +} uint1792m_T; + +typedef struct { + uint1792m_T re; + uint1792m_T im; +} cuint1792m_T; + +typedef struct { + uint32_T chunks[57]; +} int1824m_T; + +typedef struct { + int1824m_T re; + int1824m_T im; +} cint1824m_T; + +typedef struct { + uint32_T chunks[57]; +} uint1824m_T; + +typedef struct { + uint1824m_T re; + uint1824m_T im; +} cuint1824m_T; + +typedef struct { + uint32_T chunks[58]; +} int1856m_T; + +typedef struct { + int1856m_T re; + int1856m_T im; +} cint1856m_T; + +typedef struct { + uint32_T chunks[58]; +} uint1856m_T; + +typedef struct { + uint1856m_T re; + uint1856m_T im; +} cuint1856m_T; + +typedef struct { + uint32_T chunks[59]; +} int1888m_T; + +typedef struct { + int1888m_T re; + int1888m_T im; +} cint1888m_T; + +typedef struct { + uint32_T chunks[59]; +} uint1888m_T; + +typedef struct { + uint1888m_T re; + uint1888m_T im; +} cuint1888m_T; + +typedef struct { + uint32_T chunks[60]; +} int1920m_T; + +typedef struct { + int1920m_T re; + int1920m_T im; +} cint1920m_T; + +typedef struct { + uint32_T chunks[60]; +} uint1920m_T; + +typedef struct { + uint1920m_T re; + uint1920m_T im; +} cuint1920m_T; + +typedef struct { + uint32_T chunks[61]; +} int1952m_T; + +typedef struct { + int1952m_T re; + int1952m_T im; +} cint1952m_T; + +typedef struct { + uint32_T chunks[61]; +} uint1952m_T; + +typedef struct { + uint1952m_T re; + uint1952m_T im; +} cuint1952m_T; + +typedef struct { + uint32_T chunks[62]; +} int1984m_T; + +typedef struct { + int1984m_T re; + int1984m_T im; +} cint1984m_T; + +typedef struct { + uint32_T chunks[62]; +} uint1984m_T; + +typedef struct { + uint1984m_T re; + uint1984m_T im; +} cuint1984m_T; + +typedef struct { + uint32_T chunks[63]; +} int2016m_T; + +typedef struct { + int2016m_T re; + int2016m_T im; +} cint2016m_T; + +typedef struct { + uint32_T chunks[63]; +} uint2016m_T; + +typedef struct { + uint2016m_T re; + uint2016m_T im; +} cuint2016m_T; + +typedef struct { + uint32_T chunks[64]; +} int2048m_T; + +typedef struct { + int2048m_T re; + int2048m_T im; +} cint2048m_T; + +typedef struct { + uint32_T chunks[64]; +} uint2048m_T; + +typedef struct { + uint2048m_T re; + uint2048m_T im; +} cuint2048m_T; + +#endif /* MULTIWORD_TYPES_H */ diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/rtmodel.h b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/rtmodel.h new file mode 100644 index 000000000..10431a4cc --- /dev/null +++ b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/rtmodel.h @@ -0,0 +1,39 @@ +/* + * rtmodel.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 "run_ADA". + * + * Model version : 1.25 + * Simulink Coder version : 9.9 (R2023a) 19-Nov-2022 + * C++ source code generated on : Wed Oct 25 17:58:39 2023 + * + * Target selection: grt.tlc + * Note: GRT includes extra infrastructure and instrumentation for prototyping + * Embedded hardware selection: Intel->x86-64 (Windows64) + * Code generation objective: Execution efficiency + * Validation result: Not run + */ + +#ifndef RTW_HEADER_rtmodel_h_ +#define RTW_HEADER_rtmodel_h_ +#include "run_ADA.h" +#define MODEL_CLASSNAME run_ADA +#define MODEL_STEPNAME step +#define GRTINTERFACE 0 + +/* + * ROOT_IO_FORMAT: 0 (Individual arguments) + * ROOT_IO_FORMAT: 1 (Structure reference) + * ROOT_IO_FORMAT: 2 (Part of model data structure) + */ +#define ROOT_IO_FORMAT 2 + +/* Macros generated for backwards compatibility */ +#ifndef rtmGetStopRequested +#define rtmGetStopRequested(rtm) ((void*) 0) +#endif +#endif /* RTW_HEADER_rtmodel_h_ */ diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/rtwtypes.h b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/rtwtypes.h new file mode 100644 index 000000000..1ffac7ee7 --- /dev/null +++ b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/rtwtypes.h @@ -0,0 +1,41 @@ +/* + * rtwtypes.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 "run_ADA". + * + * Model version : 1.25 + * Simulink Coder version : 9.9 (R2023a) 19-Nov-2022 + * C++ source code generated on : Wed Oct 25 17:58:39 2023 + * + * Target selection: grt.tlc + * Note: GRT includes extra infrastructure and instrumentation for prototyping + * Embedded hardware selection: Intel->x86-64 (Windows64) + * Code generation objective: Execution efficiency + * Validation result: Not run + */ + +#ifndef RTWTYPES_H +#define RTWTYPES_H +#include "tmwtypes.h" +#ifndef POINTER_T +#define POINTER_T + +typedef void * pointer_T; + +#endif + +/* Logical type definitions */ +#if (!defined(__cplusplus)) +#ifndef false +#define false (0U) +#endif + +#ifndef true +#define true (1U) +#endif +#endif +#endif /* RTWTYPES_H */ diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA.cpp b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA.cpp new file mode 100644 index 000000000..79e57b2fa --- /dev/null +++ b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA.cpp @@ -0,0 +1,347 @@ +/* + * run_ADA.cpp + * + * 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 "run_ADA". + * + * Model version : 1.25 + * Simulink Coder version : 9.9 (R2023a) 19-Nov-2022 + * C++ source code generated on : Wed Oct 25 17:58:39 2023 + * + * Target selection: grt.tlc + * Note: GRT includes extra infrastructure and instrumentation for prototyping + * Embedded hardware selection: Intel->x86-64 (Windows64) + * Code generation objective: Execution efficiency + * Validation result: Not run + */ + +#include "run_ADA.h" +#include "rtwtypes.h" +#include <cstring> +#include <cmath> +#include <emmintrin.h> + +/* System initialize for atomic system: '<Root>/run_ADA' */ +void run_ADA::run_ADA_run_ADA_Init(DW_run_ADA_run_ADA_T *localDW) +{ + /* InitializeConditions for Memory: '<S1>/H_memory' */ + localDW->H_memory_PreviousInput[0] = 1.0; + localDW->H_memory_PreviousInput[1] = 0.0; + localDW->H_memory_PreviousInput[2] = 0.0; + + /* InitializeConditions for Memory: '<S1>/F_memory' */ + std::memcpy(&localDW->F_memory_PreviousInput[0], + &run_ADA_ConstP.F_memory_InitialCondition[0], 9U * sizeof(real_T)); + + /* InitializeConditions for Memory: '<S1>/P_memory' */ + std::memcpy(&localDW->P_memory_PreviousInput[0], &run_ADA_ConstP.pooled5[0], + 9U * sizeof(real_T)); + + /* InitializeConditions for Memory: '<S1>/Q_memory' */ + std::memcpy(&localDW->Q_memory_PreviousInput[0], + &run_ADA_ConstP.Q_memory_InitialCondition[0], 9U * sizeof(real_T)); + + /* InitializeConditions for Memory: '<S1>/H_memory1' */ + localDW->H_memory1_PreviousInput = 4000.0; + + /* InitializeConditions for Memory: '<S1>/x_memory' */ + localDW->x_memory_PreviousInput[0] = 0.0; + localDW->x_memory_PreviousInput[1] = 0.0; + localDW->x_memory_PreviousInput[2] = 1.0; +} + +/* Output and update for atomic system: '<Root>/run_ADA' */ +void run_ADA::run_ADA_run_ADA(real_T rtu_Pressure, B_run_ADA_run_ADA_T *localB, + DW_run_ADA_run_ADA_T *localDW) const +{ + __m128d tmp_0; + __m128d tmp_1; + __m128d tmp_2; + real_T rtb_Add[9]; + real_T tmp[9]; + real_T rtb_K[3]; + real_T rtb_MatrixMultiply[3]; + real_T F_memory_PreviousInput; + real_T F_memory_PreviousInput_0; + real_T F_memory_PreviousInput_1; + real_T P_memory_PreviousInput; + real_T P_memory_PreviousInput_0; + real_T rtb_MatrixMultiply_0; + real_T rtb_Product_n; + real_T x_memory_PreviousInput; + int32_T i; + int32_T i_0; + int32_T rtb_Add_tmp; + + /* Product: '<S3>/Matrix Multiply1' incorporates: + * Math: '<S3>/Transpose' + * Memory: '<S1>/F_memory' + * Memory: '<S1>/P_memory' + */ + for (i_0 = 0; i_0 < 3; i_0++) { + rtb_Product_n = localDW->P_memory_PreviousInput[i_0 + 3]; + P_memory_PreviousInput = localDW->P_memory_PreviousInput[i_0]; + P_memory_PreviousInput_0 = localDW->P_memory_PreviousInput[i_0 + 6]; + for (i = 0; i < 3; i++) { + tmp[i_0 + 3 * i] = (localDW->F_memory_PreviousInput[i + 3] * rtb_Product_n + + P_memory_PreviousInput * + localDW->F_memory_PreviousInput[i]) + + localDW->F_memory_PreviousInput[i + 6] * P_memory_PreviousInput_0; + } + } + + /* Product: '<S2>/Matrix Multiply' */ + rtb_Product_n = 0.0; + for (i_0 = 0; i_0 < 3; i_0++) { + /* Sum: '<S3>/Add' incorporates: + * Memory: '<S1>/F_memory' + * Product: '<S3>/Matrix Multiply1' + */ + F_memory_PreviousInput = localDW->F_memory_PreviousInput[i_0 + 3]; + F_memory_PreviousInput_0 = localDW->F_memory_PreviousInput[i_0]; + F_memory_PreviousInput_1 = localDW->F_memory_PreviousInput[i_0 + 6]; + + /* Product: '<S2>/Matrix Multiply' */ + P_memory_PreviousInput = 0.0; + for (i = 0; i < 3; i++) { + /* Sum: '<S3>/Add' incorporates: + * Memory: '<S1>/Q_memory' + * Product: '<S3>/Matrix Multiply1' + */ + rtb_Add_tmp = 3 * i + i_0; + P_memory_PreviousInput_0 = ((tmp[3 * i + 1] * F_memory_PreviousInput + + tmp[3 * i] * F_memory_PreviousInput_0) + tmp[3 * i + 2] * + F_memory_PreviousInput_1) + localDW->Q_memory_PreviousInput[rtb_Add_tmp]; + rtb_Add[rtb_Add_tmp] = P_memory_PreviousInput_0; + + /* Product: '<S2>/Matrix Multiply' incorporates: + * Memory: '<S1>/H_memory' + */ + P_memory_PreviousInput += P_memory_PreviousInput_0 * + localDW->H_memory_PreviousInput[i]; + } + + /* Product: '<S2>/Matrix Multiply' incorporates: + * Memory: '<S1>/H_memory' + */ + rtb_Product_n += localDW->H_memory_PreviousInput[i_0] * + P_memory_PreviousInput; + } + + /* Sum: '<S2>/Add' incorporates: + * Memory: '<S1>/H_memory1' + * Product: '<S2>/Matrix Multiply' + */ + rtb_Product_n += localDW->H_memory1_PreviousInput; + + /* Product: '<S2>/Matrix Multiply1' incorporates: + * Memory: '<S1>/H_memory' + */ + P_memory_PreviousInput = localDW->H_memory_PreviousInput[0] / rtb_Product_n; + P_memory_PreviousInput_0 = localDW->H_memory_PreviousInput[1] / rtb_Product_n; + F_memory_PreviousInput = localDW->H_memory_PreviousInput[2] / rtb_Product_n; + + /* Product: '<S2>/Matrix Multiply4' */ + rtb_Product_n = 0.0; + + /* Memory: '<S1>/x_memory' incorporates: + * Product: '<S3>/Matrix Multiply' + */ + F_memory_PreviousInput_0 = localDW->x_memory_PreviousInput[1]; + F_memory_PreviousInput_1 = localDW->x_memory_PreviousInput[0]; + x_memory_PreviousInput = localDW->x_memory_PreviousInput[2]; + for (i_0 = 0; i_0 < 3; i_0++) { + /* Product: '<S3>/Matrix Multiply' incorporates: + * Memory: '<S1>/F_memory' + * Memory: '<S1>/x_memory' + */ + rtb_MatrixMultiply_0 = (localDW->F_memory_PreviousInput[i_0 + 3] * + F_memory_PreviousInput_0 + localDW->F_memory_PreviousInput[i_0] * + F_memory_PreviousInput_1) + localDW->F_memory_PreviousInput[i_0 + 6] * + x_memory_PreviousInput; + rtb_MatrixMultiply[i_0] = rtb_MatrixMultiply_0; + + /* Product: '<S2>/Matrix Multiply1' incorporates: + * Sum: '<S3>/Add' + */ + rtb_K[i_0] = (rtb_Add[i_0 + 3] * P_memory_PreviousInput_0 + rtb_Add[i_0] * + P_memory_PreviousInput) + rtb_Add[i_0 + 6] * + F_memory_PreviousInput; + + /* Product: '<S2>/Matrix Multiply4' incorporates: + * Memory: '<S1>/H_memory' + * Product: '<S3>/Matrix Multiply' + */ + rtb_Product_n += localDW->H_memory_PreviousInput[i_0] * rtb_MatrixMultiply_0; + } + + /* Sum: '<S2>/Subtract' incorporates: + * Product: '<S2>/Matrix Multiply4' + */ + rtb_Product_n = rtu_Pressure - rtb_Product_n; + + /* DigitalClock: '<S1>/Digital Clock' */ + localB->BusCreator.timestamp = ((((&run_ADA_M)->Timing.clockTick0+(&run_ADA_M + )->Timing.clockTickH0* 4294967296.0)) * 0.02); + for (i = 0; i < 3; i++) { + /* Sum: '<S2>/Add2' incorporates: + * Product: '<S2>/Matrix Multiply1' + * Product: '<S2>/Matrix Multiply5' + * Product: '<S3>/Matrix Multiply' + */ + localDW->x_memory_PreviousInput[i] = rtb_K[i] * rtb_Product_n + + rtb_MatrixMultiply[i]; + + /* Memory: '<S1>/H_memory' incorporates: + * Product: '<S2>/Matrix Multiply2' + */ + P_memory_PreviousInput = localDW->H_memory_PreviousInput[i]; + + /* Sum: '<S2>/Add1' incorporates: + * Constant: '<S2>/I' + * Memory: '<S1>/H_memory' + * Product: '<S2>/Matrix Multiply1' + * Product: '<S2>/Matrix Multiply2' + */ + tmp[3 * i] = run_ADA_ConstP.pooled5[3 * i] - rtb_K[0] * + P_memory_PreviousInput; + i_0 = 3 * i + 1; + tmp[i_0] = run_ADA_ConstP.pooled5[i_0] - rtb_K[1] * P_memory_PreviousInput; + i_0 = 3 * i + 2; + tmp[i_0] = run_ADA_ConstP.pooled5[i_0] - rtb_K[2] * P_memory_PreviousInput; + } + + /* Math: '<S4>/Pow' incorporates: + * Constant: '<S4>/P_ref' + * Math: '<S5>/Pow' + * Product: '<S4>/Divide1' + */ + P_memory_PreviousInput = std::pow(localDW->x_memory_PreviousInput[0] / + 101325.0, 0.19025441011522382); + + /* Product: '<S4>/Product' incorporates: + * Constant: '<S4>/Constant' + * Math: '<S4>/Pow' + * Sum: '<S4>/Subtract' + */ + rtb_Product_n = (1.0 - P_memory_PreviousInput) * 44330.769230769227; + + /* Sum: '<S1>/Subtract' incorporates: + * Constant: '<S1>/Constant' + */ + localB->BusCreator.aglAltitude = rtb_Product_n - 160.0; + + /* BusCreator: '<S1>/Bus Creator' incorporates: + * Constant: '<S5>/Constant1' + * Constant: '<S5>/T_ref' + * Constant: '<S5>/a' + * Gain: '<S5>/Gain' + * Product: '<S5>/Divide' + * Product: '<S5>/Product' + * Product: '<S5>/Product1' + */ + localB->BusCreator.mslAltitude = rtb_Product_n; + localB->BusCreator.verticalSpeed = -(1.0 / (0.0012366536657489548 * + localDW->x_memory_PreviousInput[0]) * (288.15 * + localDW->x_memory_PreviousInput[1] * P_memory_PreviousInput)); + localB->BusCreator.x0 = localDW->x_memory_PreviousInput[0]; + localB->BusCreator.x1 = localDW->x_memory_PreviousInput[1]; + localB->BusCreator.x2 = localDW->x_memory_PreviousInput[2]; + + /* Update for Memory: '<S1>/P_memory' incorporates: + * Product: '<S2>/Matrix Multiply3' + */ + for (i_0 = 0; i_0 < 3; i_0++) { + /* Product: '<S2>/Matrix Multiply3' incorporates: + * Sum: '<S3>/Add' + */ + P_memory_PreviousInput = rtb_Add[3 * i_0 + 1]; + P_memory_PreviousInput_0 = rtb_Add[3 * i_0]; + rtb_Product_n = rtb_Add[3 * i_0 + 2]; + for (i = 0; i <= 0; i += 2) { + tmp_0 = _mm_loadu_pd(&tmp[i + 3]); + tmp_1 = _mm_loadu_pd(&tmp[i]); + tmp_2 = _mm_loadu_pd(&tmp[i + 6]); + _mm_storeu_pd(&localDW->P_memory_PreviousInput[i + 3 * i_0], _mm_add_pd + (_mm_add_pd(_mm_mul_pd(_mm_set1_pd(P_memory_PreviousInput), + tmp_0), _mm_mul_pd(_mm_set1_pd(P_memory_PreviousInput_0), tmp_1)), + _mm_mul_pd(_mm_set1_pd(rtb_Product_n), tmp_2))); + } + + for (i = 2; i < 3; i++) { + localDW->P_memory_PreviousInput[i + 3 * i_0] = (tmp[i + 3] * + P_memory_PreviousInput + P_memory_PreviousInput_0 * tmp[i]) + tmp[i + 6] + * rtb_Product_n; + } + } + + /* End of Update for Memory: '<S1>/P_memory' */ +} + +/* Model step function */ +void run_ADA::step() +{ + /* Outputs for Atomic SubSystem: '<Root>/run_ADA' */ + + /* Inport: '<Root>/Pressure' */ + run_ADA_run_ADA(run_ADA_U.Pressure, &run_ADA_B.run_ADA_e, + &run_ADA_DW.run_ADA_e); + + /* End of Outputs for SubSystem: '<Root>/run_ADA' */ + + /* Outport: '<Root>/ADAState' */ + run_ADA_Y.ADAState_o = run_ADA_B.run_ADA_e.BusCreator; + + /* Update absolute time for base rate */ + /* The "clockTick0" counts the number of times the code of this task has + * been executed. The resolution of this integer timer is 0.02, which is the step size + * of the task. Size of "clockTick0" ensures timer will not overflow during the + * application lifespan selected. + * Timer of this task consists of two 32 bit unsigned integers. + * The two integers represent the low bits Timing.clockTick0 and the high bits + * Timing.clockTickH0. When the low bit overflows to 0, the high bits increment. + */ + (&run_ADA_M)->Timing.clockTick0++; + if (!(&run_ADA_M)->Timing.clockTick0) { + (&run_ADA_M)->Timing.clockTickH0++; + } +} + +/* Model initialize function */ +void run_ADA::initialize() +{ + /* SystemInitialize for Atomic SubSystem: '<Root>/run_ADA' */ + run_ADA_run_ADA_Init(&run_ADA_DW.run_ADA_e); + + /* End of SystemInitialize for SubSystem: '<Root>/run_ADA' */ +} + +/* Model terminate function */ +void run_ADA::terminate() +{ + /* (no terminate code required) */ +} + +/* Constructor */ +run_ADA::run_ADA() : + run_ADA_U(), + run_ADA_Y(), + run_ADA_B(), + run_ADA_DW(), + run_ADA_M() +{ + /* Currently there is no constructor body generated.*/ +} + +/* Destructor */ +/* Currently there is no destructor body generated.*/ +run_ADA::~run_ADA() = default; + +/* Real-Time Model get method */ +RT_MODEL_run_ADA_T * run_ADA::getRTM() +{ + return (&run_ADA_M); +} diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA.h b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA.h new file mode 100644 index 000000000..a8c397ba8 --- /dev/null +++ b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA.h @@ -0,0 +1,212 @@ +/* + * run_ADA.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 "run_ADA". + * + * Model version : 1.25 + * Simulink Coder version : 9.9 (R2023a) 19-Nov-2022 + * C++ source code generated on : Wed Oct 25 17:58:39 2023 + * + * Target selection: grt.tlc + * Note: GRT includes extra infrastructure and instrumentation for prototyping + * Embedded hardware selection: Intel->x86-64 (Windows64) + * Code generation objective: Execution efficiency + * Validation result: Not run + */ + +#ifndef RTW_HEADER_run_ADA_h_ +#define RTW_HEADER_run_ADA_h_ +#include "rtwtypes.h" +#include "rtw_continuous.h" +#include "rtw_solver.h" +#include "run_ADA_types.h" + +/* Macros for accessing real-time model data structure */ +#ifndef rtmGetErrorStatus +#define rtmGetErrorStatus(rtm) ((rtm)->errorStatus) +#endif + +#ifndef rtmSetErrorStatus +#define rtmSetErrorStatus(rtm, val) ((rtm)->errorStatus = (val)) +#endif + +/* Block signals for system '<Root>/run_ADA' */ +struct B_run_ADA_run_ADA_T { + ADAState BusCreator; /* '<S1>/Bus Creator' */ +}; + +/* Block states (default storage) for system '<Root>/run_ADA' */ +struct DW_run_ADA_run_ADA_T { + real_T H_memory_PreviousInput[3]; /* '<S1>/H_memory' */ + real_T F_memory_PreviousInput[9]; /* '<S1>/F_memory' */ + real_T P_memory_PreviousInput[9]; /* '<S1>/P_memory' */ + real_T Q_memory_PreviousInput[9]; /* '<S1>/Q_memory' */ + real_T H_memory1_PreviousInput; /* '<S1>/H_memory1' */ + real_T MatrixMultiply1_DWORK4; /* '<S2>/Matrix Multiply1' */ + real_T x_memory_PreviousInput[3]; /* '<S1>/x_memory' */ +}; + +/* Block signals (default storage) */ +struct B_run_ADA_T { + B_run_ADA_run_ADA_T run_ADA_e; /* '<Root>/run_ADA' */ +}; + +/* Block states (default storage) for system '<Root>' */ +struct DW_run_ADA_T { + DW_run_ADA_run_ADA_T run_ADA_e; /* '<Root>/run_ADA' */ +}; + +/* Constant parameters (default storage) */ +struct ConstP_run_ADA_T { + /* Expression: [1 0.02 0.5*0.02^2; 0 1 0.02; 0 0 1] + * Referenced by: '<S1>/F_memory' + */ + real_T F_memory_InitialCondition[9]; + + /* Pooled Parameter (Expression: eye(3)) + * Referenced by: + * '<S1>/P_memory' + * '<S2>/I' + */ + real_T pooled5[9]; + + /* Expression: [30 0 0; 0 10 0; 0 0 2.5] + * Referenced by: '<S1>/Q_memory' + */ + real_T Q_memory_InitialCondition[9]; +}; + +/* External inputs (root inport signals with default storage) */ +struct ExtU_run_ADA_T { + real_T Pressure; /* '<Root>/Pressure' */ +}; + +/* External outputs (root outports fed by signals with default storage) */ +struct ExtY_run_ADA_T { + ADAState ADAState_o; /* '<Root>/ADAState' */ +}; + +/* Real-time Model Data Structure */ +struct tag_RTM_run_ADA_T { + const char_T *errorStatus; + + /* + * Timing: + * The following substructure contains information regarding + * the timing information for the model. + */ + struct { + uint32_T clockTick0; + uint32_T clockTickH0; + } Timing; +}; + +/* Constant parameters (default storage) */ +extern const ConstP_run_ADA_T run_ADA_ConstP; + +/* Class declaration for model run_ADA */ +class run_ADA final +{ + /* public data and function members */ + public: + /* Copy Constructor */ + run_ADA(run_ADA const&) = delete; + + /* Assignment Operator */ + run_ADA& operator= (run_ADA const&) & = delete; + + /* Move Constructor */ + run_ADA(run_ADA &&) = delete; + + /* Move Assignment Operator */ + run_ADA& operator= (run_ADA &&) = delete; + + /* Real-Time Model get method */ + RT_MODEL_run_ADA_T * getRTM(); + + /* Root inports set method */ + void setExternalInputs(const ExtU_run_ADA_T *pExtU_run_ADA_T) + { + run_ADA_U = *pExtU_run_ADA_T; + } + + /* Root outports get method */ + const ExtY_run_ADA_T &getExternalOutputs() const + { + return run_ADA_Y; + } + + /* Initial conditions function */ + void initialize(); + + /* model step function */ + void step(); + + /* model terminate function */ + static void terminate(); + + /* Constructor */ + run_ADA(); + + /* Destructor */ + ~run_ADA(); + + /* private data and function members */ + private: + /* External inputs */ + ExtU_run_ADA_T run_ADA_U; + + /* External outputs */ + ExtY_run_ADA_T run_ADA_Y; + + /* Block signals */ + B_run_ADA_T run_ADA_B; + + /* Block states */ + DW_run_ADA_T run_ADA_DW; + + /* private member function(s) for subsystem '<Root>/run_ADA'*/ + static void run_ADA_run_ADA_Init(DW_run_ADA_run_ADA_T *localDW); + void run_ADA_run_ADA(real_T rtu_Pressure, B_run_ADA_run_ADA_T *localB, + DW_run_ADA_run_ADA_T *localDW) const; + + /* Real-Time Model */ + RT_MODEL_run_ADA_T run_ADA_M; +}; + +/*- + * These blocks were eliminated from the model due to optimizations: + * + * Block '<S2>/Reshape' : Reshape block reduction + * Block '<S2>/Reshape2' : Reshape block reduction + */ + +/*- + * 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. + * + * Note that this particular code originates from a subsystem build, + * and has its own system numbers different from the parent model. + * Refer to the system hierarchy for this subsystem below, and use the + * MATLAB hilite_system command to trace the generated code back + * to the parent model. For example, + * + * hilite_system('test_ada/run_ADA') - opens subsystem test_ada/run_ADA + * hilite_system('test_ada/run_ADA/Kp') - opens and selects block Kp + * + * Here is the system hierarchy for this model + * + * '<Root>' : 'test_ada' + * '<S1>' : 'test_ada/run_ADA' + * '<S2>' : 'test_ada/run_ADA/Correction' + * '<S3>' : 'test_ada/run_ADA/Prediction' + * '<S4>' : 'test_ada/run_ADA/getAltitude' + * '<S5>' : 'test_ada/run_ADA/getVelocity' + */ +#endif /* RTW_HEADER_run_ADA_h_ */ diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA_data.cpp b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA_data.cpp new file mode 100644 index 000000000..c75ebc634 --- /dev/null +++ b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA_data.cpp @@ -0,0 +1,41 @@ +/* + * run_ADA_data.cpp + * + * 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 "run_ADA". + * + * Model version : 1.25 + * Simulink Coder version : 9.9 (R2023a) 19-Nov-2022 + * C++ source code generated on : Wed Oct 25 17:58:39 2023 + * + * Target selection: grt.tlc + * Note: GRT includes extra infrastructure and instrumentation for prototyping + * Embedded hardware selection: Intel->x86-64 (Windows64) + * Code generation objective: Execution efficiency + * Validation result: Not run + */ + +#include "run_ADA.h" + +/* Constant parameters (default storage) */ +const ConstP_run_ADA_T run_ADA_ConstP{ + /* Expression: [1 0.02 0.5*0.02^2; 0 1 0.02; 0 0 1] + * Referenced by: '<S1>/F_memory' + */ + { 1.0, 0.0, 0.0, 0.02, 1.0, 0.0, 0.0002, 0.02, 1.0 }, + + /* Pooled Parameter (Expression: eye(3)) + * Referenced by: + * '<S1>/P_memory' + * '<S2>/I' + */ + { 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0 }, + + /* Expression: [30 0 0; 0 10 0; 0 0 2.5] + * Referenced by: '<S1>/Q_memory' + */ + { 30.0, 0.0, 0.0, 0.0, 10.0, 0.0, 0.0, 0.0, 2.5 } +}; diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA_private.h b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA_private.h new file mode 100644 index 000000000..f8ee91da1 --- /dev/null +++ b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA_private.h @@ -0,0 +1,26 @@ +/* + * run_ADA_private.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 "run_ADA". + * + * Model version : 1.25 + * Simulink Coder version : 9.9 (R2023a) 19-Nov-2022 + * C++ source code generated on : Wed Oct 25 17:58:39 2023 + * + * Target selection: grt.tlc + * Note: GRT includes extra infrastructure and instrumentation for prototyping + * Embedded hardware selection: Intel->x86-64 (Windows64) + * Code generation objective: Execution efficiency + * Validation result: Not run + */ + +#ifndef RTW_HEADER_run_ADA_private_h_ +#define RTW_HEADER_run_ADA_private_h_ +#include "rtwtypes.h" +#include "multiword_types.h" +#include "run_ADA_types.h" +#endif /* RTW_HEADER_run_ADA_private_h_ */ diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA_types.h b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA_types.h new file mode 100644 index 000000000..bf526cd98 --- /dev/null +++ b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA_types.h @@ -0,0 +1,43 @@ +/* + * run_ADA_types.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 "run_ADA". + * + * Model version : 1.25 + * Simulink Coder version : 9.9 (R2023a) 19-Nov-2022 + * C++ source code generated on : Wed Oct 25 17:58:39 2023 + * + * Target selection: grt.tlc + * Note: GRT includes extra infrastructure and instrumentation for prototyping + * Embedded hardware selection: Intel->x86-64 (Windows64) + * Code generation objective: Execution efficiency + * Validation result: Not run + */ + +#ifndef RTW_HEADER_run_ADA_types_h_ +#define RTW_HEADER_run_ADA_types_h_ +#include "rtwtypes.h" +#ifndef DEFINED_TYPEDEF_FOR_ADAState_ +#define DEFINED_TYPEDEF_FOR_ADAState_ + +struct ADAState +{ + real_T timestamp; + real_T mslAltitude; + real_T aglAltitude; + real_T verticalSpeed; + real_T x0; + real_T x1; + real_T x2; +}; + +#endif + +/* Forward declaration for rtModel */ +typedef struct tag_RTM_run_ADA_T RT_MODEL_run_ADA_T; + +#endif /* RTW_HEADER_run_ADA_types_h_ */ diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/extern/include/tmwtypes.h b/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/extern/include/tmwtypes.h new file mode 100644 index 000000000..e7f52fc38 --- /dev/null +++ b/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/extern/include/tmwtypes.h @@ -0,0 +1,888 @@ +/* + * Copyright 1984-2018 The MathWorks, Inc. + */ + +#if defined(_MSC_VER) +# pragma once +#endif +#if defined(__GNUC__) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 3)) +# pragma once +#endif + +#ifndef tmwtypes_h +#define tmwtypes_h + +#ifndef __TMWTYPES__ +#define __TMWTYPES__ +/* + * File : tmwtypes.h + * Abstract: + * Data types for use with MATLAB/SIMULINK and the Real-Time Workshop. + * + * When compiling stand-alone model code, data types can be overridden + * via compiler switches. + * + * Define NO_FLOATS to eliminate reference to real_T, etc. + */ + +#ifdef MW_LIBTOOLING +#include "mwstdint.h" +#endif + +#include <limits.h> + +/* __STDC_VERSION__ version check below means "check for a C99 compiler". + + Visual Studio (checked on versions 2015 and 2017) does + not define __STDC_VERSION__, however it has stdbool.h available, + thus a separate check for _MSC_VER below. + */ +#if defined(__APPLE_CC__) \ + || (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) \ + || (defined(_MSC_VER) && (_MSC_VER >= 1900)) +#ifndef tmwtypes_do_not_include_stdbool +#include <stdbool.h> +#endif +#endif + +#define LOGICAL_IS_A_TYPE +#define SPARSE_GENERALIZATION + +#ifdef NO_FLOATS +# define double double_not_allowed +# define float float_not_allowed +#endif /*NO_FLOATS*/ + +#ifndef NO_FLOATS + +#ifndef __MWERKS__ +# ifdef __STDC__ +# include <float.h> +# else +# ifndef FLT_MANT_DIG +# define FLT_MANT_DIG 24 +# endif +# ifndef DBL_MANT_DIG +# define DBL_MANT_DIG 53 +# endif +# endif +#endif + +#endif /*NO_FLOATS*/ + +/* + * The following data types cannot be overridden when building MEX files. + */ +#ifdef MATLAB_MEX_FILE +# undef CHARACTER_T +# undef INTEGER_T +# undef BOOLEAN_T +# undef REAL_T +# undef TIME_T +#endif + +/* + * The uchar_T, ushort_T and ulong_T types are needed for compilers which do + * not allow defines to be specified, at the command line, with spaces in them. + */ + +typedef unsigned char uchar_T; +typedef unsigned short ushort_T; +typedef unsigned long ulong_T; + +#if (defined(_MSC_VER) && _MSC_VER >= 1500) \ + || defined(__x86_64__) || defined(__LP64__) \ + || defined(__LCC64__) + +typedef unsigned long long ulonglong_T; +#endif + + + +/*=======================================================================* + * Fixed width word size data types: * + * int8_T, int16_T, int32_T - signed 8, 16, or 32 bit integers * + * uint8_T, uint16_T, uint32_T - unsigned 8, 16, or 32 bit integers * + * real32_T, real64_T - 32 and 64 bit floating point numbers * + *=======================================================================*/ + +/* When used with Real Time Workshop generated code, this + * header file can be used with a variety of compilers. + * + * The compiler could be for an 8 bit embedded processor that + * only had 8 bits per integer and 16 bits per long. + * In that example, a 32 bit integer size is not even available. + * This header file should be robust to that. + * + * For the case of an 8 bit processor, the preprocessor + * may be limited to 16 bit math like its target. That limitation + * would mean that 32 bit comparisons can't be done accurately. + * To increase robustness to this, comparisons are done against + * smaller values first. An inaccurate 32 bit comparison isn't + * attempted if the 16 bit comparison has already succeeded. + * + * Limitations on preprocessor math can also be stricter than + * for the target. There are known cases where a compiler + * targeting processors with 64 bit longs can't do accurate + * preprocessor comparisons on more than 32 bits. + */ + +/* Determine the number of bits for int, long, short, and char. + * If one fails to be determined, set the number of bits to -1 + */ + +#ifndef TMW_BITS_PER_INT +# if INT_MAX == 0x7FL +# define TMW_BITS_PER_INT 8 +# elif INT_MAX == 0x7FFFL +# define TMW_BITS_PER_INT 16 +# elif INT_MAX == 0x7FFFFFFFL +# define TMW_BITS_PER_INT 32 +# else +# define TMW_BITS_PER_INT -1 +# endif +#endif + +#ifndef TMW_BITS_PER_LONG +# if LONG_MAX == 0x7FL +# define TMW_BITS_PER_LONG 8 +# elif LONG_MAX == 0x7FFFL +# define TMW_BITS_PER_LONG 16 +# elif LONG_MAX == 0x7FFFFFFFL +# define TMW_BITS_PER_LONG 32 +# else +# define TMW_BITS_PER_LONG -1 +# endif +#endif + +#ifndef TMW_BITS_PER_SHRT +# if SHRT_MAX == 0x7FL +# define TMW_BITS_PER_SHRT 8 +# elif SHRT_MAX == 0x7FFFL +# define TMW_BITS_PER_SHRT 16 +# elif SHRT_MAX == 0x7FFFFFFFL +# define TMW_BITS_PER_SHRT 32 +# else +# define TMW_BITS_PER_SHRT -1 +# endif +#endif + +#ifndef TMW_BITS_PER_SCHAR +# if SCHAR_MAX == 0x7FL +# define TMW_BITS_PER_SCHAR 8 +# elif SCHAR_MAX == 0x7FFFL +# define TMW_BITS_PER_SCHAR 16 +# elif SCHAR_MAX == 0x7FFFFFFFL +# define TMW_BITS_PER_SCHAR 32 +# else +# define TMW_BITS_PER_SCHAR -1 +# endif +#endif + +#ifndef TMW_CHAR_SIGNED +# if SCHAR_MAX == CHAR_MAX +# define TMW_CHAR_SIGNED 1 +# else +# define TMW_CHAR_SIGNED 0 +# endif +#endif + +/* It is common for one or more of the integer types + * to be the same size. For example, on many embedded + * processors, both shorts and ints are 16 bits. On + * processors used for workstations, it is quite common + * for both int and long to be 32 bits. + * When there is more than one choice for typdef'ing + * a portable type like int16_T or uint32_T, in + * concept, it should not matter which choice is made. + * However, some style guides and some code checking + * tools do identify and complain about seemingly + * irrelevant differences. For example, a code + * checking tool may complain about an implicit + * conversion from int to short even though both + * are 16 bits. To reduce these types of + * complaints, it is best to make int the + * preferred choice when more than one is available. + */ + +#ifndef INT8_T +# if defined(MW_LIBTOOLING) +# define INT8_T int8_t +# elif TMW_BITS_PER_INT == 8 +# define INT8_T int +# elif TMW_BITS_PER_LONG == 8 +# define INT8_T long +# elif TMW_BITS_PER_SCHAR == 8 +# define INT8_T signed char +# elif TMW_BITS_PER_SHRT == 8 +# define INT8_T short +# endif +#endif +#ifdef INT8_T + typedef INT8_T int8_T; +#endif + +#ifndef UINT8_T +# if defined(MW_LIBTOOLING) +# define UINT8_T uint8_t +# elif TMW_BITS_PER_INT == 8 +# define UINT8_T unsigned int +# elif TMW_BITS_PER_LONG == 8 +# define UINT8_T unsigned long +# elif TMW_BITS_PER_SCHAR == 8 +# define UINT8_T unsigned char +# elif TMW_BITS_PER_SHRT == 8 +# define UINT8_T unsigned short +# endif +#endif +#ifdef UINT8_T + typedef UINT8_T uint8_T; +#endif + + +#ifndef INT16_T +# if defined(MW_LIBTOOLING) +# define INT16_T int16_t +# elif TMW_BITS_PER_INT == 16 +# define INT16_T int +# elif TMW_BITS_PER_LONG == 16 +# define INT16_T long +# elif TMW_BITS_PER_SCHAR == 16 +# define INT16_T signed char +# elif TMW_BITS_PER_SHRT == 16 +# define INT16_T short +# endif +#endif +#ifdef INT16_T + typedef INT16_T int16_T; +#endif + + +#ifndef UINT16_T +# if defined(MW_LIBTOOLING) +# define UINT16_T uint16_t +# elif TMW_BITS_PER_INT == 16 +# define UINT16_T unsigned int +# elif TMW_BITS_PER_LONG == 16 +# define UINT16_T unsigned long +# elif TMW_BITS_PER_SCHAR == 16 +# define UINT16_T unsigned char +# elif TMW_BITS_PER_SHRT == 16 +# define UINT16_T unsigned short +# endif +#endif +#ifdef UINT16_T + typedef UINT16_T uint16_T; +#endif + + +#ifndef INT32_T +# if defined(MW_LIBTOOLING) +# define INT32_T int32_t +# elif TMW_BITS_PER_INT == 32 +# define INT32_T int +# elif TMW_BITS_PER_LONG == 32 +# define INT32_T long +# elif TMW_BITS_PER_SCHAR == 32 +# define INT32_T signed char +# elif TMW_BITS_PER_SHRT == 32 +# define INT32_T short +# endif +#endif +#ifdef INT32_T + typedef INT32_T int32_T; +#endif + + +#ifndef UINT32_T +# if defined(MW_LIBTOOLING) +# define UINT32_T uint32_t +# elif TMW_BITS_PER_INT == 32 +# define UINT32_T unsigned int +# elif TMW_BITS_PER_LONG == 32 +# define UINT32_T unsigned long +# elif TMW_BITS_PER_SCHAR == 32 +# define UINT32_T unsigned char +# elif TMW_BITS_PER_SHRT == 32 +# define UINT32_T unsigned short +# endif +#endif +#ifdef UINT32_T + typedef UINT32_T uint32_T; +#endif + +/* The following is used to emulate smaller integer types when only + * larger types are available. For example, compilers for TI C3x/C4x DSPs + * define char and short to be 32 bits, so 8 and 16 bits are not directly + * available. This target is commonly used with RTW rapid prototyping. + * Other DSPs define char to be 16 bits, so 8 bits is not directly + * available. + */ +#ifndef INT8_T +# ifdef INT16_T +# define INT8_T INT16_T + typedef INT8_T int8_T; +# else +# ifdef INT32_T +# define INT8_T INT32_T + typedef INT8_T int8_T; +# endif +# endif +#endif + +#ifndef UINT8_T +# ifdef UINT16_T +# define UINT8_T UINT16_T + typedef UINT8_T uint8_T; +# else +# ifdef UINT32_T +# define UINT8_T UINT32_T + typedef UINT8_T uint8_T; +# endif +# endif +#endif + +#ifndef INT16_T +# ifdef INT32_T +# define INT16_T INT32_T + typedef INT16_T int16_T; +# endif +#endif + +#ifndef UINT16_T +# ifdef UINT32_T +# define UINT16_T UINT32_T + typedef UINT16_T uint16_T; +# endif +#endif + + +#ifndef NO_FLOATS + +#ifndef REAL32_T +# ifndef __MWERKS__ +# if FLT_MANT_DIG >= 23 +# define REAL32_T float +# endif +# else +# define REAL32_T float +# endif +#endif +#ifdef REAL32_T + typedef REAL32_T real32_T; +#endif + + +#ifndef REAL64_T +# ifndef __MWERKS__ +# if DBL_MANT_DIG >= 52 +# define REAL64_T double +# endif +# else +# define REAL64_T double +# endif +#endif +#ifdef REAL64_T + typedef REAL64_T real64_T; +#endif + +#endif /* NO_FLOATS*/ + +/*=======================================================================* + * Fixed width word size data types: * + * int64_T - signed 64 bit integers * + * uint64_T - unsigned 64 bit integers * + *=======================================================================*/ + +# if defined(MW_LIBTOOLING) +# ifdef INT64_T +# undef INT64_T +# endif +# define INT64_T int64_t +# ifdef UINT64_T +# undef UINT64_T +# endif +# define UINT64_T uint64_t +# endif +#if !defined(INT64_T) || !defined(UINT64_T) || !defined(FMT64) +# if defined(__APPLE__) || defined(__clang__) +# ifndef INT64_T +# define INT64_T long long +# endif +# ifndef UINT64_T +# define UINT64_T unsigned long long +# endif +# ifndef FMT64 +# define FMT64 "ll" +# endif +# if defined(__LP64__) && !defined(INT_TYPE_64_IS_LONG) +# define INT_TYPE_64_IS_LONG +# endif +# elif (defined(__x86_64__) || defined(__LP64__))&& !defined(__MINGW64__) +# ifndef INT64_T +# define INT64_T long +# endif +# ifndef UINT64_T +# define UINT64_T unsigned long +# endif +# ifndef FMT64 +# define FMT64 "l" +# endif +# if !defined(INT_TYPE_64_IS_LONG) +# define INT_TYPE_64_IS_LONG +# endif +# elif defined(_MSC_VER) || (defined(__BORLANDC__) && __BORLANDC__ >= 0x530) \ + || (defined(__WATCOMC__) && __WATCOMC__ >= 1100) +# ifndef INT64_T +# define INT64_T __int64 +# endif +# ifndef UINT64_T +# define UINT64_T unsigned __int64 +# endif +# ifndef FMT64 +# define FMT64 "I64" +# endif +# elif defined(__GNUC__) || defined(TMW_ENABLE_INT64) \ + || defined(__LCC64__) +# ifndef INT64_T +# define INT64_T long long +# endif +# ifndef UINT64_T +# define UINT64_T unsigned long long +# endif +# ifndef FMT64 +# define FMT64 "ll" +# endif +# endif + +#endif + +#if defined(INT64_T) +# if defined(__GNUC__) && \ + ((__GNUC__ > 2) || ((__GNUC__ == 2) && (__GNUC_MINOR__ >=9))) + __extension__ +# endif + typedef INT64_T int64_T; +#endif + +#if defined(_WIN64) || (defined(__APPLE__) && defined(__LP64__)) \ + || defined(__x86_64__) \ + || defined(__LP64__) +# define INT_TYPE_64_IS_SUPPORTED +#endif + +#if defined(UINT64_T) +# if defined(__GNUC__) && \ + ((__GNUC__ > 2) || ((__GNUC__ == 2) && (__GNUC_MINOR__ >=9))) + __extension__ +# endif + typedef UINT64_T uint64_T; +#endif + +/*===========================================================================* + * Format string modifiers for using size_t variables in printf statements. * + *===========================================================================*/ + +#ifndef FMT_SIZE_T +# if (defined( __GNUC__ ) || defined(_STDC_C99))&& !defined(__MINGW64__) +# define FMT_SIZE_T "z" +# elif defined (__WATCOMC__) +# define FMT_SIZE_T "l" +# elif defined (_WIN32 ) +# define FMT_SIZE_T "I" +# else +# define FMT_SIZE_T "l" +# endif +#endif + +#ifndef FMT_PTRDIFF_T +# if defined(__APPLE__) +# define FMT_PTRDIFF_T "l" +# elif defined( __GNUC__ ) || defined(_STDC_C99) +# define FMT_PTRDIFF_T "t" +# elif defined (__WATCOMC__) +# define FMT_PTRDIFF_T "l" +# elif defined (_WIN32 ) +# define FMT_PTRDIFF_T "I" +# else +# define FMT_PTRDIFF_T "l" +# endif +#endif + +/*===========================================================================* + * General or logical data types where the word size is not guaranteed. * + * real_T - possible settings include real32_T or real64_T * + * time_T - possible settings include real32_T or real64_T * + * boolean_T * + * char_T * + * int_T * + * uint_T * + * byte_T * + *===========================================================================*/ + +#ifndef NO_FLOATS + +#ifndef REAL_T +# ifdef REAL64_T +# define REAL_T real64_T +# else +# ifdef REAL32_T +# define REAL_T real32_T +# endif +# endif +#endif +#ifdef REAL_T + typedef REAL_T real_T; +#endif + +#ifndef TIME_T +# ifdef REAL_T +# define TIME_T real_T +# endif +#endif +#ifdef TIME_T + typedef TIME_T time_T; +#endif + +#endif /* NO_FLOATS */ + +#ifndef BOOLEAN_T +# if defined(UINT8_T) +# define BOOLEAN_T UINT8_T +# else +# define BOOLEAN_T unsigned int +# endif +#endif +typedef BOOLEAN_T boolean_T; + + +#ifndef CHARACTER_T +# define CHARACTER_T char +#endif +typedef CHARACTER_T char_T; + + +#ifndef INTEGER_T +# define INTEGER_T int +#endif +typedef INTEGER_T int_T; + + +#ifndef UINTEGER_T +# define UINTEGER_T unsigned +#endif +typedef UINTEGER_T uint_T; + + +#ifndef BYTE_T +# define BYTE_T unsigned char +#endif +typedef BYTE_T byte_T; + + +/*===========================================================================* + * Define Complex Structures * + *===========================================================================*/ +#ifndef NO_FLOATS + +#ifndef CREAL32_T +# ifdef REAL32_T + typedef struct { + real32_T re, im; + } creal32_T; +# define CREAL32_T creal32_T +# endif +#endif + +#ifndef CREAL64_T +# ifdef REAL64_T + typedef struct { + real64_T re, im; + } creal64_T; +# define CREAL64_T creal64_T +# endif +#endif + +#ifndef CREAL_T +# ifdef REAL_T + typedef struct { + real_T re, im; + } creal_T; +# define CREAL_T creal_T +# endif +#endif + +#endif /* NO_FLOATS */ + +#ifndef CINT8_T +# ifdef INT8_T + typedef struct { + int8_T re, im; + } cint8_T; +# define CINT8_T cint8_T +# endif +#endif + +#ifndef CUINT8_T +# ifdef UINT8_T + typedef struct { + uint8_T re, im; + } cuint8_T; +# define CUINT8_T cuint8_T +# endif +#endif + +#ifndef CINT16_T +# ifdef INT16_T + typedef struct { + int16_T re, im; + } cint16_T; +# define CINT16_T cint16_T +# endif +#endif + +#ifndef CUINT16_T +# ifdef UINT16_T + typedef struct { + uint16_T re, im; + } cuint16_T; +# define CUINT16_T cuint16_T +# endif +#endif + +#ifndef CINT32_T +# ifdef INT32_T + typedef struct { + int32_T re, im; + } cint32_T; +# define CINT32_T cint32_T +# endif +#endif + +#ifndef CUINT32_T +# ifdef UINT32_T + typedef struct { + uint32_T re, im; + } cuint32_T; +# define CUINT32_T cuint32_T +# endif +#endif + +#ifndef CINT64_T +# ifdef INT64_T + typedef struct { + int64_T re, im; + } cint64_T; +# define CINT64_T cint64_T +# endif +#endif + +#ifndef CUINT64_T +# ifdef UINT64_T + typedef struct { + uint64_T re, im; + } cuint64_T; +# define CUINT64_T cuint64_T +# endif +#endif + +/*=======================================================================* + * Min and Max: * + * int8_T, int16_T, int32_T - signed 8, 16, or 32 bit integers * + * uint8_T, uint16_T, uint32_T - unsigned 8, 16, or 32 bit integers * + *=======================================================================*/ + +#define MAX_int8_T ((int8_T)(127)) /* 127 */ +#define MIN_int8_T ((int8_T)(-128)) /* -128 */ +#define MAX_uint8_T ((uint8_T)(255)) /* 255 */ +#define MIN_uint8_T ((uint8_T)(0)) + +#define MAX_int16_T ((int16_T)(32767)) /* 32767 */ +#define MIN_int16_T ((int16_T)(-32768)) /* -32768 */ +#define MAX_uint16_T ((uint16_T)(65535)) /* 65535 */ +#define MIN_uint16_T ((uint16_T)(0)) + +#define MAX_int32_T ((int32_T)(2147483647)) /* 2147483647 */ +#define MIN_int32_T ((int32_T)(-2147483647-1)) /* -2147483648 */ +#define MAX_uint32_T ((uint32_T)(0xFFFFFFFFU)) /* 4294967295 */ +#define MIN_uint32_T ((uint32_T)(0)) + +#if defined(_MSC_VER) || (defined(__BORLANDC__) && __BORLANDC__ >= 0x530) \ + || (defined(__WATCOMC__) && __WATCOMC__ >= 1100) \ + || defined(__LCC64__) +# ifdef INT64_T +# define MAX_int64_T ((int64_T)(9223372036854775807LL)) +# define MIN_int64_T ((int64_T)(-9223372036854775807LL-1LL)) +# endif +# ifdef UINT64_T +# define MAX_uint64_T ((uint64_T)(0xFFFFFFFFFFFFFFFFULL)) +# define MIN_uint64_T ((uint64_T)(0)) +# endif +#else +# ifdef INT64_T +# ifdef INT_TYPE_64_IS_LONG +# define MAX_int64_T ((int64_T)(9223372036854775807L)) +# define MIN_int64_T ((int64_T)(-9223372036854775807L-1L)) +# else +# define MAX_int64_T ((int64_T)(9223372036854775807LL)) +# define MIN_int64_T ((int64_T)(-9223372036854775807LL-1LL)) +# endif +# endif +# ifdef UINT64_T +# ifdef INT_TYPE_64_IS_LONG +# define MAX_uint64_T ((uint64_T)(0xFFFFFFFFFFFFFFFFUL)) +# define MIN_uint64_T ((uint64_T)(0)) +# else +# define MAX_uint64_T ((uint64_T)(0xFFFFFFFFFFFFFFFFULL)) +# define MIN_uint64_T ((uint64_T)(0)) +# endif +# endif +#endif + +#if (defined(_MSC_VER) && !defined(__clang__)) + +/* Conversion from unsigned __int64 to double is not implemented in Visual Studio + * and results in a compile error, thus the value must first be cast to + * signed __int64, and then to double. + * + * If the 64 bit int value is greater than 2^63-1, which is the signed int64 max, + * the macro below provides a workaround for casting a uint64 value to a double + * in windows. + */ +# define uint64_to_double(u) ( ((u) > _I64_MAX) ? \ + (double)(__int64)((u) - _I64_MAX - 1) + (double)_I64_MAX + 1: \ + (double)(__int64)(u) ) + +/* The following inline function should only be used in the macro double_to_uint64, + * as it only handles the specfic range of double between 2^63 and 2^64-1 */ +__forceinline +uint64_T double_to_uint64_helper(double d) { + union double_to_uint64_union_type { + double dd; + uint64_T i64; + } di; + di.dd = d; + return (((di.i64 & 0x000fffffffffffff) | 0x0010000000000000) << 11); +} + +/* The largest double value that can be cast to uint64 in windows is the + * signed int64 max, which is 2^63-1. The macro below provides + * a workaround for casting large double values to uint64 in windows. + */ +/* The magic number 18446744073709551616.0 is 2^64 */ +/* The magic number 9223372036854775808.0 is 2^63 */ +# define double_to_uint64(d) ( ((d) >= 18446744073709551616.0) ? \ + 0xffffffffffffffffULL : \ + ((d) >= 0.0) ? \ + ((d) >= 9223372036854775808.0) ? \ + double_to_uint64_helper(d) : \ + (unsigned __int64)(d) : \ + 0ULL ) +#else +# define uint64_to_double(u) ((double)(u)) +# if defined(__BORLANDC__) || defined(__WATCOMC__) || defined(__TICCSC__) +/* double_to_uint64 defined only for MSVC and UNIX */ +# else +# define double_to_uint64(d) ( ((d) >= 18446744073709551616.0) ? \ + (unsigned long long) 0xffffffffffffffffULL : \ + ((d) >= 0) ? (unsigned long long)(d) : (unsigned long long) 0 ) +# endif +#endif + +#if !defined(__cplusplus) && !defined(__bool_true_false_are_defined) + +#ifndef _bool_T +#define _bool_T + +typedef boolean_T bool; + +#ifndef false +#define false (0) +#endif +#ifndef true +#define true (1) +#endif + +#endif /* _bool_T */ + +#endif /* !__cplusplus */ + +/* + * This software assumes that the code is being compiled on a target using a + * 2's complement representation for signed integer values. + */ +#if ((SCHAR_MIN + 1) != -SCHAR_MAX) +#error "This code must be compiled using a 2's complement representation for signed integer values" +#endif + +/* + * Maximum length of a MATLAB identifier (function/variable/model) + * including the null-termination character. + */ +#define TMW_NAME_LENGTH_MAX 64 + +/* + * Maximum values for indices and dimensions + */ +#include <stddef.h> + +#ifdef MX_COMPAT_32 +typedef int mwSize; +typedef int mwIndex; +typedef int mwSignedIndex; +#else +typedef size_t mwSize; /* unsigned pointer-width integer */ +typedef size_t mwIndex; /* unsigned pointer-width integer */ +typedef ptrdiff_t mwSignedIndex; /* a signed pointer-width integer */ +#endif + + /* for the individual dim */ +/* If updating SLSize or SLIndex, update defintions in sl_types_def.h + as well. */ +#ifndef SLSIZE_SLINDEX + #define SLSIZE_SLINDEX + #ifdef INT_TYPE_64_IS_SUPPORTED + typedef int64_T SLIndex; + typedef int64_T SLSize; + #else + typedef int SLIndex; + typedef int SLSize; + #endif +#endif + +/* for the total size */ +#define SLIndexType size_t +#define INVALID_SIZET_VALUE (std::numeric_limits<SLIndexType>::max()) +#define MAX_VALID_SIZET_VALUE (std::numeric_limits<SLIndexType>::max() -1) + + +#if (defined(_LP64) || defined(_WIN64)) && !defined(MX_COMPAT_32) +/* Currently 2^48 based on hardware limitations */ +# define MWSIZE_MAX 281474976710655UL +# define MWINDEX_MAX 281474976710655UL +# define MWSINDEX_MAX 281474976710655L +# define MWSINDEX_MIN -281474976710655L +#else +# define MWSIZE_MAX 2147483647UL +# define MWINDEX_MAX 2147483647UL +# define MWSINDEX_MAX 2147483647L +# define MWSINDEX_MIN -2147483647L +#endif +#define MWSIZE_MIN 0UL +#define MWINDEX_MIN 0UL + +/** UTF-16 character type */ + +#if (defined(__cplusplus) && (__cplusplus >= 201103L)) || (defined(_HAS_CHAR16_T_LANGUAGE_SUPPORT) && _HAS_CHAR16_T_LANGUAGE_SUPPORT) +typedef char16_t CHAR16_T; +#define U16_STRING_LITERAL_PREFIX u +#elif defined(_MSC_VER) +typedef wchar_t CHAR16_T; +#define U16_STRING_LITERAL_PREFIX L +#else +typedef UINT16_T CHAR16_T; +#endif + +#endif /* __TMWTYPES__ */ + +#endif /* tmwtypes_h */ diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/rtw/c/src/common/rt_cppclass_main.cpp b/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/rtw/c/src/common/rt_cppclass_main.cpp new file mode 100644 index 000000000..7d0fb4a3c --- /dev/null +++ b/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/rtw/c/src/common/rt_cppclass_main.cpp @@ -0,0 +1,452 @@ +/* + * Copyright 2013-2022 The MathWorks, Inc. + * + * File: rt_cppclass_main.cpp + * + * Abstract: + * + * A real-time main that runs generated Simulink Coder code under most + * operating systems. Based on the definition of MULTITASKING, a single-task + * or multitask step function is employed. + * + * This file is a useful starting point for creating a custom main when + * targeting a custom floating point processor or integer micro-controller. + * + * Alternatively for ERT targets, you can generate a sample ert_main.cpp file + * with the generated code by selecting the "Generate an example main program" + * option. In this case, ert_main.cpp is precisely customized to the + * model requirements. + * + * Required Defines: + * + * MODEL - Model name + * NUMST - Number of sample times + * + */ + +/*==================* + * Required defines * + *==================*/ + +#ifndef MODEL +# error Must specify a model name. Define MODEL=name. +#else +/* create generic macros that work with any model */ +# define EXPAND_CONCAT(name1,name2) name1 ## name2 +# define CONCAT(name1,name2) EXPAND_CONCAT(name1,name2) +# define MODEL_INSTANCE CONCAT(MODEL,_Obj) +#endif + +#ifndef NUMST +# error Must specify the number of sample times. Define NUMST=number. +#endif + +#if CLASSIC_INTERFACE == 1 +# error "Classic call interface is not supported by rt_cppclass_main.cpp." +#endif + +#if ONESTEPFCN==0 +#error Separate output and update functions are not supported by rt_cppclass_main.cpp. \ +You must update rt_cppclass_main.cpp to suit your application needs, or select \ +the 'Single output/update function' option. +#endif + +#if TERMFCN==0 +#error The terminate function is required by rt_cppclass_main.cpp. \ +Select model configuration parameter 'Terminate function required' \ +or 'Generate an example main program' or modify rt_cppclass_main.cpp to \ +meet your application requirements. +#endif + +#define QUOTE1(name) #name +#define QUOTE(name) QUOTE1(name) /* need to expand name */ + +#ifndef SAVEFILE +# define MATFILE2(file) #file ".mat" +# define MATFILE1(file) MATFILE2(file) +# define MATFILE MATFILE1(MODEL) +#else +# define MATFILE QUOTE(SAVEFILE) +#endif + +/*==========* + * Includes * + *==========*/ + +#include "rtwtypes.h" +#if !defined(INTEGER_CODE) || INTEGER_CODE == 0 +# include <stdio.h> /* optional for printf */ +#else +extern "C" { + extern int printf(const char *, ...); + extern int fflush(void *); +} +#endif +#include <string.h> /* optional for strcmp */ +#include "rtmodel.h" /* includes model.h */ + +#include "rt_logging.h" +#ifdef UseMMIDataLogging +#include "rt_logging_mmi.h" +#endif + +#include "ext_work.h" + +#ifdef MODEL_STEP_FCN_CONTROL_USED +#error rt_cppclass_main.cpp does not support model step function prototype control. +#endif + +/*========================* + * Setup for multitasking * + *========================*/ + +/* + * Let MT be synonym for MULTITASKING (to shorten command line for DOS) + */ +#if defined(MT) +# if MT == 0 +# undef MT +# else +# define MULTITASKING 1 +# endif +#endif + +#if defined(TID01EQ) && TID01EQ == 1 +#define FIRST_TID 1 +#else +#define FIRST_TID 0 +#endif + +/*====================* + * External functions * + *====================*/ + +#if !defined(MULTITASKING) + /* single-rate step function */ + #define MODEL_STEP(obj) obj.MODEL_STEPNAME() +#else + /* multirate step function */ + #define MODEL_STEP MODEL_STEPNAME +#endif + + +/*==================================* + * Global data local to this module * + *==================================*/ +#ifndef MULTITASKING +static uint_T OverrunFlags[1]; /* ISR overrun flags */ +static uint_T eventFlags[1]; /* necessary for overlapping preemption */ +#else +static uint_T OverrunFlags[NUMST]; +static uint_T eventFlags[NUMST]; +#endif + +/* Create model instance */ +static MODEL_CLASSNAME MODEL_INSTANCE; + + +/*===================* + * Visible functions * + *===================*/ + +#if !defined(MULTITASKING) /* single task */ + +/* Function: rtOneStep ======================================================== + * + * Abstract: + * Perform one step of the model. This function is modeled such that + * it could be called from an interrupt service routine (ISR) with minor + * modifications. + */ +static void rt_OneStep(MODEL_CLASSNAME & mdl) +{ + /* Disable interrupts here */ + + /*********************************************** + * Check and see if base step time is too fast * + ***********************************************/ + if (OverrunFlags[0]++) { + rtmSetErrorStatus(mdl.getRTM(), "Overrun"); + } + + /************************************************* + * Check and see if an error status has been set * + * by an overrun or by the generated code. * + *************************************************/ + if (rtmGetErrorStatus(mdl.getRTM()) != NULL) { + return; + } + + /* Save FPU context here (if necessary) */ + /* Re-enable interrupts here */ + /* Set model inputs here */ + + /************** + * Step model * + **************/ + MODEL_STEP(mdl); + + /* Get model outputs here */ + + /************************** + * Decrement overrun flag * + **************************/ + OverrunFlags[0]--; + + rtExtModeCheckEndTrigger(); + + /* Disable interrupts here */ + /* Restore FPU context here (if necessary) */ + /* Re-enable interrupts here */ + +} /* end rtOneStep */ + +#else /* multitask */ + +/* Function: rtOneStep ======================================================== + * + * Abstract: + * Perform one step of the model. This function is modeled such that + * it could be called from an interrupt service routine (ISR) with minor + * modifications. + * + * Note that error checking is only necessary when this routine is + * attached to an interrupt. + * + * Also, you may wish to unroll any or all of for and while loops to + * improve the real-time performance of this function. + */ +static void rt_OneStep(MODEL_CLASSNAME & mdl) +{ + int_T i; + + /* Disable interrupts here */ + + /*********************************************** + * Check and see if base step time is too fast * + ***********************************************/ + if (OverrunFlags[0]++) { + rtmSetErrorStatus(mdl.getRTM(), "Overrun"); + } + + /************************************************* + * Check and see if an error status has been set * + * by an overrun or by the generated code. * + *************************************************/ + if (rtmGetErrorStatus(mdl.getRTM()) != NULL) { + return; + } + + /* Save FPU context here (if necessary) */ + /* Re-enable interrupts here */ + + /************************************************* + * Update EventFlags and check subrate overrun * + *************************************************/ + for (i = FIRST_TID+1; i < NUMST; i++) { + if (rtmStepTask(mdl.getRTM(),i) && eventFlags[i]++) { + OverrunFlags[0]--; + OverrunFlags[i]++; + /* Sampling too fast */ + rtmSetErrorStatus(mdl.getRTM(), "Overrun"); + return; + } + if (++rtmTaskCounter(mdl.getRTM(),i) == rtmCounterLimit(mdl.getRTM(),i)) + rtmTaskCounter(mdl.getRTM(), i) = 0; + } + + /* Set model inputs associated with base rate here */ + + /******************************************* + * Step the model for the base sample time * + *******************************************/ + MODEL_STEP(mdl,0); + + /* Get model outputs associated with base rate here */ + + /************************************************************************ + * Model step complete for base sample time, now it is okay to * + * re-interrupt this ISR. * + ************************************************************************/ + OverrunFlags[0]--; + + /********************************************************* + * Step the model for any other sample times (subrates) * + *********************************************************/ + for (i = FIRST_TID+1; i < NUMST; i++) { + /************************************************************* + * If task "i" is running, don't run any lower priority task * + *************************************************************/ + if (OverrunFlags[i]) return; + + if (eventFlags[i]) { + OverrunFlags[i]++; + + /* Set model inputs associated with subrate here */ + + /****************************************** + * Step the model for sample time "i" * + ******************************************/ + MODEL_STEP(mdl,i); + + /* Get model outputs associated with subrate here */ + + /********************************************** + * Indicate task complete for sample time "i" * + **********************************************/ + OverrunFlags[i]--; + eventFlags[i]--; + } + } + + rtExtModeCheckEndTrigger(); + /* Disable interrupts here */ + /* Restore FPU context here (if necessary) */ + /* Enable interrupts here */ + +} /* end rtOneStep */ + +#endif /* MULTITASKING */ + +/* Function: rt_InitModel ==================================================== + * + * Abstract: + * Initialized the model and the overrun flags + * + */ +static void rt_InitModel(MODEL_CLASSNAME & mdl) +{ +#if defined(MULTITASKING) + int i; + for(i=0; i < NUMST; i++) { + OverrunFlags[i] = 0; + eventFlags[i] = 0; + } +#else + OverrunFlags[0] = 0; + eventFlags[0] = 0; +#endif + + /************************ + * Initialize the model * + ************************/ + mdl.initialize(); +} + +/* Function: rt_TermModel ==================================================== + * + * Abstract: + * Terminates the model and prints the error status + * + */ +static int_T rt_TermModel(MODEL_CLASSNAME & mdl) +{ + mdl.terminate(); + + { + const char_T *errStatus = (const char_T *) (rtmGetErrorStatus(mdl.getRTM())); + + if (errStatus != NULL && strcmp(errStatus, "Simulation finished")) { + (void)printf("%s\n", errStatus); +#if defined(MULTITASKING) + int_T i; + for (i = 0; i < NUMST; i++) { + if (OverrunFlags[i]) { + (void)printf("ISR overrun - sampling rate too" + "fast for sample time index %d.\n", i); + } + } +#else + if (OverrunFlags[0]) { + (void)printf("ISR overrun - base sampling rate too fast.\n"); + } +#endif + + return(1); + } + } + + return(0); +} + +/* Function: main ============================================================= + * + * Abstract: + * Execute model on a generic target such as a workstation. + */ +int_T main(int_T argc, const char *argv[]) +{ + int_T ret; + + /* External mode */ + rtParseArgsForExtMode(argc, argv); + + /******************************************* + * warn if the model will run indefinitely * + *******************************************/ +#ifndef EXT_MODE +# define EXT_MODE 0 +#endif + +#if MAT_FILE==0 && EXT_MODE==0 + printf("warning: the simulation will run with no stop time; " + "to change this behavior select the 'MAT-file logging' option\n"); + fflush(NULL); +#endif + + /************************ + * Initialize the model * + ************************/ + rt_InitModel(MODEL_INSTANCE); + + /* External mode */ + rtSetTFinalForExtMode(&rtmGetTFinal(MODEL_INSTANCE.getRTM())); + rtExtModeCheckInit(NUMST); + rtExtModeWaitForStartPkt(rtmGetRTWExtModeInfo(MODEL_INSTANCE.getRTM()), + NUMST, + (boolean_T *)&rtmGetStopRequested(MODEL_INSTANCE.getRTM())); + + (void)printf("\n** starting the model **\n"); + + /*********************************************************************** + * Execute (step) the model. You may also attach rtOneStep to an ISR, * + * in which case you replace the call to rtOneStep with a call to a * + * background task. Note that the generated code sets error status * + * to "Simulation finished" when MatFileLogging is specified in TLC. * + ***********************************************************************/ + while (rtmGetErrorStatus(MODEL_INSTANCE.getRTM()) == NULL && + !rtmGetStopRequested(MODEL_INSTANCE.getRTM())) { + + rtExtModePauseIfNeeded(rtmGetRTWExtModeInfo(MODEL_INSTANCE.getRTM()), + NUMST, + (boolean_T *)&rtmGetStopRequested(MODEL_INSTANCE.getRTM())); + + if (rtmGetStopRequested(MODEL_INSTANCE.getRTM())) break; + + /* external mode */ + rtExtModeOneStep(rtmGetRTWExtModeInfo(MODEL_INSTANCE.getRTM()), + NUMST, + (boolean_T *)&rtmGetStopRequested(MODEL_INSTANCE.getRTM())); + + rt_OneStep(MODEL_INSTANCE); + } + + /******************************* + * Cleanup and exit (optional) * + *******************************/ + +#ifdef UseMMIDataLogging + rt_CleanUpForStateLogWithMMI(rtmGetRTWLogInfo(MODEL_INSTANCE.getRTM())); +#endif + rt_StopDataLogging(MATFILE,rtmGetRTWLogInfo(MODEL_INSTANCE.getRTM())); + + ret = rt_TermModel(MODEL_INSTANCE); + + rtExtModeShutdown(NUMST); + + return ret; +} + +/* [EOF] rt_cppclass_main.cpp */ + + diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/rtw/c/src/ext_mode/common/ext_work.h b/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/rtw/c/src/ext_mode/common/ext_work.h new file mode 100644 index 000000000..e7f132238 --- /dev/null +++ b/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/rtw/c/src/ext_mode/common/ext_work.h @@ -0,0 +1,127 @@ +/* + * Copyright 1994-2012 The MathWorks, Inc. + * + * File: ext_work.h + * + * Abstract: + * + */ + +#ifndef __EXT_WORK_OBJECT__ +#define __EXT_WORK_OBJECT__ + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef EXT_MODE +#include "ext_types.h" + +#if defined(VXWORKS) + /*VxWorks headers*/ + #include <vxWorks.h> + #include <taskLib.h> + #include <sysLib.h> + #include <semLib.h> + #include <rebootLib.h> + #include <logLib.h> + + extern void rtExtModeTornadoStartup(RTWExtModeInfo *ei, + int_T numSampTimes, + boolean_T *stopReqPtr, + int_T priority, + int32_T stack_size, + SEM_ID startStopSem); + + extern void rtExtModeTornadoCleanup(int_T numSampTimes); + + extern void rtExtModeTornadoSetPortInExtUD(const int_T port); + +#elif defined(C6000_EXT_MODE) + /* C6000 headers*/ + #include <std.h> + #include <stddef.h> + #include <sem.h> + + extern void rtExtModeC6000Startup( RTWExtModeInfo *ei, + int_T numSampTimes, + boolean_T *stopReqPtr); + + extern void rtExtModeC6000Cleanup(int_T numSampTimes); +#else + extern void rtExtModePauseIfNeeded(RTWExtModeInfo *ei, + int_T numSampTimes, + boolean_T *stopReqPtr); + + extern void rtExtModeWaitForStartPkt(RTWExtModeInfo *ei, + int_T numSampTimes, + boolean_T *stopReqPtr); + void rtExtModeInitUD(void); +#endif /* #if defined(VXWORKS) */ + +extern void rtExtModeOneStep(RTWExtModeInfo *ei, + int_T numSampTimes, + boolean_T *stopReqPtr); + +extern void rtExtModeCheckEndTrigger(void); + +extern void rtExtModeUploadCheckTrigger(int_T numSampTimes); + +extern void rtExtModeUpload(int_T tid, + real_T taskTime); + +extern void rtExtModeCheckInit(int_T numSampTimes); + +extern void rtExtModeShutdown(int_T numSampTimes); + +extern void rtExtModeParseArgs(int_T argc, + const char_T *argv[], + real_T *rtmFinal); + +extern void rtERTExtModeSetTFinal(real_T *rtmTFinal); +extern void rtSetTFinalForExtMode(real_T *rtmTFinal); + +extern void rtParseArgsForExtMode(int_T argc, + const char_T *argv[]); + +extern void rtERTExtModeStartMsg(void); + +#else /* #ifdef EXTMODE */ + +#if defined(VXWORKS) + #define rtExtModeTornadoStartup(ei, \ + numSampTimes, \ + stopReqPtr, \ + priority, \ + stack_size, \ + startStopSem) /* do nothing */ + #define rtExtModeTornadoCleanup(numSampTimes); /* do nothing */ + #define rtExtModeTornadoSetPortInExtUD(port); /* do nothing */ +#elif defined(C6000_EXT_MODE) + #define rtExtModePauseIfNeeded(ei,st,sr) /* do nothing */ + #define rtExtModeWaitForStartPkt(ei,st,sr) /* do nothing */ +#else + #define rtExtModePauseIfNeeded(ei,st,sr) /* do nothing */ + #define rtExtModeWaitForStartPkt(ei,st,sr) /* do nothing */ +#endif /* #ifdef VXWORKS */ + +#define rtExtModeOneStep(ei,st,sr) /* do nothing */ +#define rtExtModeCheckEndTrigger() /* do nothing */ +#define rtExtModeUploadCheckTrigger(numSampTimes) /* do nothing */ +#define rtExtModeUpload(t,ttime) /* do nothing */ +#define rtExtModeCheckInit(numSampTimes) /* do nothing */ +#define rtExtModeShutdown(numSampTimes) /* do nothing */ +#define rtExtModeParseArgs(argc, argv, tf); /* do nothing */ +#define rtERTExtModeSetTFinal(tf); /* do nothing */ +#define rtSetTFinalForExtMode(tf); /* do nothing */ +#define rtParseArgsForExtMode(argc, argv); (void)(argc); \ + (void)(argv); +#define rtERTExtModeStartMsg(); /* do nothing */ + +#endif /* #ifdef EXTMODE */ + +#ifdef __cplusplus +} +#endif + +#endif /* __EXT_WORK_OBJECT__ */ diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/rtw/c/src/rt_logging.h b/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/rtw/c/src/rt_logging.h new file mode 100644 index 000000000..954f55ee5 --- /dev/null +++ b/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/rtw/c/src/rt_logging.h @@ -0,0 +1,290 @@ +/* Copyright 2012-2022 The MathWorks, Inc. */ + +#ifndef rt_logging_h +#define rt_logging_h + +#if defined(_MSC_VER) +# pragma once +#endif +#if defined(__GNUC__) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 3)) +# pragma once +#endif + +#if !defined(MAT_FILE) || (defined(MAT_FILE) && MAT_FILE == 1) + +#include <stddef.h> /* size_t */ +#include "rtwtypes.h" +#include "builtin_typeid_types.h" +#include "multiword_types.h" +#ifdef IS_RAPID_ACCEL +#include "matrix.h" +#else +#include "rt_mxclassid.h" +#endif +#include "rtw_matlogging.h" + +#ifndef TMW_NAME_LENGTH_MAX +#define TMW_NAME_LENGTH_MAX 64 +#endif +#define mxMAXNAM TMW_NAME_LENGTH_MAX /* maximum name length */ + +/*=========* + * Defines * + *=========*/ + +/* + * Logging related functions and data structures + */ +typedef double MatReal; /* "real" data type used in model.mat */ +typedef struct LogVar_Tag LogVar; +typedef struct StructLogVar_Tag StructLogVar; + +typedef struct MatrixData_Tag { + char_T name[mxMAXNAM]; /* Name of the variable */ + int_T nRows; /* number of rows */ + int_T nCols; /* number of columns */ + int_T nDims; /* number of dimensions */ + int_T _dims[2]; /* most cases, dimensions are 2 */ + int_T *dims; /* dimensions of the log variable we + write to at each simulation time step. + E.g: (1) Non-frame data - + Signal dimension = [2 X 3] + numDims = 2 + dims[0] = 2, dims[1] = 3 + (2) Frame data - + Signal dimension = [2 X 3] + numDims = 1 + dims[0] = 3 */ + void *re; /* pointer to real part of the data */ + void *im; /* pointer to imaginary part, if complex */ + DTypeId dTypeID; /* data type id */ + size_t elSize; /* element size in bytes */ + + RTWLogDataTypeConvert dataTypeConvertInfo; + + mxClassID mxID; /* mxId corresponding to this dTypeID */ + uint32_T logical; /* is this a logical array ? */ + uint32_T complex; /* is this a complex matrix? */ + uint32_T frameData; /* is this data frame based? */ + uint32_T frameSize; /* is this data frame based? */ +} MatrixData; + +typedef struct ValDimsData_Tag { + char_T name[mxMAXNAM]; /* Name of the variable */ + int_T nRows; /* number of rows */ + int_T nCols; /* number of columns */ + void **currSigDims; /* dimensions of current output */ + int_T *currSigDimsSize; /* size in bytes of current sig dims */ + real_T *dimsData; /* pointer to the value of dimension */ +} ValDimsData; + +struct LogVar_Tag { + MatrixData data; /* Container for name, data etc., */ + ValDimsData *valDims; /* field of valueDimensions + 1. If all logging signals are fixed-size, + then we set this field to NULL; + 2. If any logging signal is variable-size, + then this field will be needed: + 1) For fixed-size signal, this field is + an empty matrix; + 2) Otherwise, it contains the dimension + information of the logging signal. + */ + int_T rowIdx; /* current row index */ + int_T wrapped; /* number of times the circular buffer + * has wrapped around */ + int_T nDataPoints; /* total number of data points logged */ + int_T usingDefaultBufSize; /* used to print a message at end */ + int_T okayToRealloc; /* reallocate during sim? */ + int_T decimation; /* decimation factor */ + int_T numHits; /* decimation hit count */ + + int_T *coords; + int_T *strides; + int_T *currStrides; /* coords, strides and currStrides will be + needed when logging variable-size + signal to calculate whether the + currently logging value is in the range. + If the current signal is fixed-size, + these pointers will be set to NULLs; + otherwise, we allocate memory for them. + (the size will be nDims in this case) + */ + + LogVar *next; +}; + +typedef struct SignalsStruct_Tag { + int_T numActiveFields; /* number of active fields */ + const char_T *fieldNames; + int_T numSignals; + LogVar *values; + MatrixData *dimensions; + MatrixData *labels; + MatrixData *plotStyles; + MatrixData *titles; + MatrixData *blockNames; + MatrixData *stateNames; + MatrixData *crossMdlRef; + + boolean_T logValueDimensions; /* If there's any variable-size signal + we also should log 'valueDimensions' + field */ + boolean_T *isVarDims; /* is this signal a variable-size signal? */ + +} SignalsStruct; + +struct StructLogVar_Tag { + char_T name[mxMAXNAM]; /* Name of the ML Struct variable */ + int_T numActiveFields; /* number of active fields */ + boolean_T logTime; + void *time; + SignalsStruct signals; + MatrixData *blockName; + + StructLogVar *next; +}; + +#define matUNKNOWN 0 +#define matINT8 1 +#define matUINT8 2 +#define matINT16 3 +#define matUINT16 4 +#define matINT32 5 +#define matUINT32 6 +#define matFLOAT 7 +#define matDOUBLE 9 +#define matINT64 12 +#define matUINT64 13 +#define matMATRIX 14 + +/* status of logging "valueDimensions" field */ +/* + NO_LOGVALDIMS: + No need to log valueDimensions: + All signals are fixed-sized. + + LOGVALDIMS_EMPTYMX: + Signals with mixed dimension modes, + and the signal logged currently + is fixed-sized. So set valueDimensions + field to an empty matrix. + + LOGVALDIMS_VARDIMS: + Signal logged currently is variable-sized. +*/ +typedef enum { + NO_LOGVALDIMS, + LOGVALDIMS_EMPTYMX, + LOGVALDIMS_VARDIMS +} LogValDimsStat; + + + +#ifdef __cplusplus +extern "C" { +#endif + +extern mxClassID rt_GetMxIdFromDTypeIdForRSim(BuiltInDTypeId dTypeID); + +extern mxClassID rt_GetMxIdFromDTypeId(BuiltInDTypeId dTypeID); + +extern LogVar *rt_CreateLogVarWithConvert( + RTWLogInfo *li, + const real_T startTime, + const real_T finalTime, + const real_T inStepSize, + const char_T **errStatus, + const char_T *varName, + BuiltInDTypeId inpDataTypeID, + const RTWLogDataTypeConvert *pDataTypeConvertInfo, + int_T logical, + int_T complex, + int_T frameData, + int_T nCols, + int_T nDims, + const int_T *dims, + LogValDimsStat logValDimsStat, + void **currSigDims, + int_T *currSigDimsSize, + int_T maxRows, + int_T decimation, + real_T sampleTime, + int_T appendToLogVarsList); + + +extern LogVar *rt_CreateLogVar(RTWLogInfo *li, + const real_T startTime, + const real_T finalTime, + const real_T inStepSize, + const char_T **errStatus, + const char_T *varName, + BuiltInDTypeId inpDataTypeID, + int_T logical, + int_T complex, + int_T frameData, + int_T nCols, + int_T nDims, + const int_T *dims, + LogValDimsStat logValDimsStat, + void **currSigDims, + int_T *currSigDimsSize, + int_T maxRows, + int_T decimation, + real_T sampleTime, + int_T appendToLogVarsList); + +extern StructLogVar *rt_CreateStructLogVar(RTWLogInfo *li, + const real_T startTime, + const real_T finalTime, + const real_T inStepSize, + const char_T **errStatus, + const char_T *varName, + boolean_T logTime, + int_T maxRows, + int_T decimation, + real_T sampleTime, + const RTWLogSignalInfo *sigInfo, + const char_T *blockName); + + +extern const char_T *rt_StartDataLoggingWithStartTime(RTWLogInfo *li, + const real_T startTime, + const real_T finalTime, + const real_T stepSize, + const char_T **errStatus); + +extern const char_T *rt_StartDataLogging(RTWLogInfo *li, + const real_T finalTime, + const real_T stepSize, + const char_T **errStatus); + +extern void rt_UpdateLogVar(LogVar *var, const void *data, boolean_T isVarDims); + +extern void rt_UpdateStructLogVar(StructLogVar *var, const real_T *t, const void *data); + +extern const char_T *rt_UpdateTXYLogVars(RTWLogInfo *li, time_T *tPtr); +extern const char_T *rt_UpdateTXXFYLogVars(RTWLogInfo *li, time_T *tPtr, boolean_T updateTXY); + +extern void rt_StopDataLoggingImpl(const char_T *file, RTWLogInfo *li, boolean_T isRaccel); + +extern void rt_StopDataLogging(const char_T *file, RTWLogInfo *li); + + +#ifdef __cplusplus +} +#endif + + +#else /*!defined(MAT_FILE) || (defined(MAT_FILE) && MAT_FILE == 1)*/ + +#define rt_StartDataLogging(li, finalTime, stepSize, errStatus) NULL /* do nothing */ +#define rt_UpdateTXYLogVars(li, tPtr) NULL /* do nothing */ +#define rt_StopDataLogging(file, li); /* do nothing */ + +#endif /*!defined(MAT_FILE) || (defined(MAT_FILE) && MAT_FILE == 1)*/ + +#endif /* rt_logging_h */ + +/* LocalWords: curr LOGVALDIMS EMPTYMX VARDIMS + */ diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/simulink/include/rtw_continuous.h b/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/simulink/include/rtw_continuous.h new file mode 100644 index 000000000..510f33f9a --- /dev/null +++ b/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/simulink/include/rtw_continuous.h @@ -0,0 +1,109 @@ +/* Copyright 1990-2022 The MathWorks, Inc. */ + +/* + * File: rtw_continuous.h + * + * Abstract: + * Type definitions for continuous-time support. + * + */ + +#ifndef RTW_CONTINUOUS_H__ +#define RTW_CONTINUOUS_H__ + +#ifdef MATLAB_MEX_FILE +#include "tmwtypes.h" +#else +#include "rtwtypes.h" +#endif + +/* For models registering MassMatrix */ +typedef enum { + SS_MATRIX_NONE, + SS_MATRIX_CONSTANT, + SS_MATRIX_TIMEDEP, + SS_MATRIX_STATEDEP +} ssMatrixType; + +typedef enum { + SOLVER_MODE_AUTO, /* only occurs in + mdlInitializeSizes/mdlInitializeSampleTimes */ + SOLVER_MODE_SINGLETASKING, + SOLVER_MODE_MULTITASKING +} SolverMode; + +typedef enum { MINOR_TIME_STEP, MAJOR_TIME_STEP } SimTimeStep; + +/* ============================================================================= + * Model methods object + * ============================================================================= + */ +typedef void (*rtMdlInitializeSizesFcn)(void* rtModel); +typedef void (*rtMdlInitializeSampleTimesFcn)(void* rtModel); +typedef void (*rtMdlStartFcn)(void* rtModel); +typedef void (*rtMdlOutputsFcn)(void* rtModel, int_T tid); +typedef void (*rtMdlUpdateFcn)(void* rtModel, int_T tid); +typedef void (*rtMdlDerivativesFcn)(void* rtModel); +typedef void (*rtMdlProjectionFcn)(void* rtModel); +typedef void (*rtMdlMassMatrixFcn)(void* rtModel); +typedef void (*rtMdlForcingFunctionFcn)(void* rtModel); +typedef void (*rtMdlTerminateFcn)(void* rtModel); +#ifdef RT_MALLOC +typedef real_T (*rtMdlDiscreteEventsFcn)(void* pModel, + int_T rtmNumSampTimes, + void* rtmTimingData, + int_T* rtmSampleHitPtr, + int_T* rtmPerTaskSampleHits); +#endif + +typedef struct _RTWRTModelMethodsInfo_tag { + void* rtModelPtr; + rtMdlInitializeSizesFcn rtmInitSizesFcn; + rtMdlInitializeSampleTimesFcn rtmInitSampTimesFcn; + rtMdlStartFcn rtmStartFcn; + rtMdlOutputsFcn rtmOutputsFcn; + rtMdlUpdateFcn rtmUpdateFcn; + rtMdlDerivativesFcn rtmDervisFcn; + rtMdlProjectionFcn rtmProjectionFcn; + rtMdlMassMatrixFcn rtmMassMatrixFcn; + rtMdlForcingFunctionFcn rtmForcingFunctionFcn; + rtMdlTerminateFcn rtmTerminateFcn; +#ifdef RT_MALLOC + rtMdlDiscreteEventsFcn rtmDiscreteEventsFcn; +#endif +} RTWRTModelMethodsInfo; + +#define rtmiSetRTModelPtr(M, rtmp) ((M).rtModelPtr = (rtmp)) +#define rtmiGetRTModelPtr(M) (M).rtModelPtr + +#define rtmiSetInitSizesFcn(M, fp) ((M).rtmInitSizesFcn = ((rtMdlInitializeSizesFcn)(fp))) +#define rtmiSetInitSampTimesFcn(M, fp) \ + ((M).rtmInitSampTimesFcn = ((rtMdlInitializeSampleTimesFcn)(fp))) +#define rtmiSetStartFcn(M, fp) ((M).rtmStartFcn = ((rtMdlStartFcn)(fp))) +#define rtmiSetOutputsFcn(M, fp) ((M).rtmOutputsFcn = ((rtMdlOutputsFcn)(fp))) +#define rtmiSetUpdateFcn(M, fp) ((M).rtmUpdateFcn = ((rtMdlUpdateFcn)(fp))) +#define rtmiSetDervisFcn(M, fp) ((M).rtmDervisFcn = ((rtMdlDerivativesFcn)(fp))) +#define rtmiSetProjectionFcn(M, fp) ((M).rtmProjectionFcn = ((rtMdlProjectionFcn)(fp))) +#define rtmiSetMassMatrixFcn(M, fp) ((M).rtmMassMatrixFcn = ((rtMdlMassMatrixFcn)(fp))) +#define rtmiSetForcingFunctionFcn(M, fp) \ + ((M).rtmForcingFunctionFcn = ((rtMdlForcingFunctionFcn)(fp))) +#define rtmiSetTerminateFcn(M, fp) ((M).rtmTerminateFcn = ((rtMdlTerminateFcn)(fp))) +#ifdef RT_MALLOC +#define rtmiSetDiscreteEventsFcn(M, fp) ((M).rtmDiscreteEventsFcn = ((rtMdlDiscreteEventsFcn)(fp))) +#endif + +#define rtmiInitializeSizes(M) ((*(M).rtmInitSizesFcn)((M).rtModelPtr)) +#define rtmiInitializeSampleTimes(M) ((*(M).rtmInitSampTimesFcn)((M).rtModelPtr)) +#define rtmiStart(M) ((*(M).rtmStartFcn)((M).rtModelPtr)) +#define rtmiOutputs(M, tid) ((*(M).rtmOutputsFcn)((M).rtModelPtr, tid)) +#define rtmiUpdate(M, tid) ((*(M).rtmUpdateFcn)((M).rtModelPtr, tid)) +#define rtmiDerivatives(M) ((*(M).rtmDervisFcn)((M).rtModelPtr)) +#define rtmiProjection(M) ((*(M).rtmProjectionFcn)((M).rtModelPtr)) +#define rtmiMassMatrix(M) ((*(M).rtmMassMatrixFcn)((M).rtModelPtr)) +#define rtmiForcingFunction(M) ((*(M).rtmForcingFunctionFcn)((M).rtModelPtr)) +#define rtmiTerminate(M) ((*(M).rtmTerminateFcn)((M).rtModelPtr)) +#ifdef RT_MALLOC +#define rtmiDiscreteEvents(M, x1, x2, x3, x4) \ + ((*(M).rtmDiscreteEventsFcn)((M).rtModelPtr, (x1), (x2), (x3), (x4))) +#endif +#endif /* __RTW_CONTINUOUS_H__ */ diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/simulink/include/rtw_solver.h b/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/simulink/include/rtw_solver.h new file mode 100644 index 000000000..40e4d9aa9 --- /dev/null +++ b/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/simulink/include/rtw_solver.h @@ -0,0 +1,292 @@ +/* + * File: rtw_solver.h + * + * Abstract: + * Type definitions for continuous-time solver support. + * + */ + +/* Copyright 1990-2021 The MathWorks, Inc. */ + +#ifndef RTW_SOLVER_H__ +#define RTW_SOLVER_H__ + +#include "rtw_continuous.h" + +/* ============================================================================= + * Solver object + * ============================================================================= + */ +#ifndef NO_FLOATS /* ERT integer-only */ +/* + * Enum for solver tolerance + */ +typedef enum { + SL_SOLVER_TOLERANCE_AUTO = 0, /* Set Automatically by Solver */ + SL_SOLVER_TOLERANCE_LOCAL = 1, /* Set Locally, e.g., by Blocks */ + SL_SOLVER_TOLERANCE_GLOBAL = 2, /* Set Globally, e.g., by Block Diagram */ + SL_SOLVER_TOLERANCE_UNDEFINED = 255 /* Signal uninitialized */ +} SL_SolverToleranceControlFlag_T; + + +/* + * Enum for jacobian method control + */ +typedef enum { + SL_JM_BD_AUTO = 0, + SL_JM_BD_SPARSE_PERTURBATION, + SL_JM_BD_FULL_PERTURBATION, + SL_JM_BD_SPARSE_ANALYTICAL, + SL_JM_BD_FULL_ANALYTICAL +} slJmBdControl; + + +typedef struct _ssSolverInfo_tag { + void* rtModelPtr; + + SimTimeStep* simTimeStepPtr; + void* solverData; + const char_T* solverName; + boolean_T isVariableStepSolver; + boolean_T solverNeedsReset; + SolverMode solverMode; + + time_T solverStopTime; + time_T* stepSizePtr; + time_T minStepSize; + time_T maxStepSize; + time_T fixedStepSize; + + int_T solverShapePreserveControl; + int_T solverMaxConsecutiveMinStep; + int_T maxNumMinSteps; + int_T solverMaxOrder; + real_T solverConsecutiveZCsStepRelTol; + int_T solverMaxConsecutiveZCs; + + int_T solverExtrapolationOrder; + int_T solverNumberNewtonIterations; + + int_T solverRefineFactor; + real_T solverRelTol; + real_T unused_real_T_1; + + real_T** dXPtr; + time_T** tPtr; + + int_T* numContStatesPtr; + real_T** contStatesPtr; + + int_T* numPeriodicContStatesPtr; + int_T** periodicContStateIndicesPtr; + real_T** periodicContStateRangesPtr; + + real_T* zcSignalVector; + uint8_T* zcEventsVector; + uint8_T* zcSignalAttrib; + int_T zcSignalVectorLength; + uint8_T* reserved; + + boolean_T foundContZcEvents; + boolean_T isAtLeftPostOfContZcEvent; + boolean_T isAtRightPostOfContZcEvent; + boolean_T adaptiveZcDetection; + + int_T numZcSignals; + + boolean_T stateProjection; + boolean_T robustResetMethod; /* user's preference */ + boolean_T updateJacobianAtReset; /* S-Fcn request (sticky) */ + boolean_T consistencyChecking; + + ssMatrixType massMatrixType; + int_T massMatrixNzMax; + int_T* massMatrixIr; + int_T* massMatrixJc; + real_T* massMatrixPr; + + const char_T** errStatusPtr; + + RTWRTModelMethodsInfo* modelMethodsPtr; + real_T zcThreshold; + int_T reserved_1; + int_T consecutiveZCsError; + boolean_T CTOutputIncnstWithState; + boolean_T isComputingJacobian; + slJmBdControl solverJacobianMethodControl; + int_T ignoredZcDiagnostic; + int_T maskedZcDiagnostic; + boolean_T isOutputMethodComputed; + int_T maxZcBracketingIterations; + boolean_T isMinorTimeStepWithModeChange; + int_T maxZcPerStep; + real_T** zcSignalPtr; +} ssSolverInfo; + +/* Support old name RTWSolverInfo */ +typedef ssSolverInfo RTWSolverInfo; + +#define rtsiSetRTModelPtr(S, rtmp) ((S)->rtModelPtr = (rtmp)) +#define rtsiGetRTModelPtr(S) (S)->rtModelPtr + +#define rtsiSetSimTimeStepPtr(S, stp) ((S)->simTimeStepPtr = (stp)) +#define rtsiGetSimTimeStepPtr(S) ((S)->simTimeStepPtr) +#define rtsiGetSimTimeStep(S) *((S)->simTimeStepPtr) +#define rtsiSetSimTimeStep(S, st) (*((S)->simTimeStepPtr) = (st)) + +#define rtsiSetSolverData(S, sd) ((S)->solverData = (sd)) +#define rtsiGetSolverData(S) (S)->solverData + +#define rtsiSetSolverName(S, sn) ((S)->solverName = (sn)) +#define rtsiGetSolverName(S) (S)->solverName + +#define rtsiSetVariableStepSolver(S, vs) ((S)->isVariableStepSolver = (vs)) +#define rtsiIsVariableStepSolver(S) (S)->isVariableStepSolver + +#define rtsiSetSolverNeedsReset(S, sn) ((S)->solverNeedsReset = (sn)) +#define rtsiGetSolverNeedsReset(S) (S)->solverNeedsReset + +#define rtsiSetContTimeOutputInconsistentWithStateAtMajorStep(S, sn) \ + ((S)->CTOutputIncnstWithState = (sn)) +#define rtsiGetContTimeOutputInconsistentWithStateAtMajorStep(S) (S)->CTOutputIncnstWithState + +#define rtsiSetBlkStateChange(S, sn) ((S)->CTOutputIncnstWithState = (sn)) +#define rtsiGetBlkStateChange(S) (S)->CTOutputIncnstWithState + +#define rtsiSetBlockStateForSolverChangedAtMajorStep(S, sn) ((S)->solverNeedsReset = (sn)) +#define rtsiGetBlockStateForSolverChangedAtMajorStep(S) (S)->solverNeedsReset + +#define rtsiSetSolverMode(S, sm) ((S)->solverMode = (sm)) +#define rtsiGetSolverMode(S) (S)->solverMode + +#define rtsiSetSolverStopTime(S, st) ((S)->solverStopTime = (st)) +#define rtsiGetSolverStopTime(S) (S)->solverStopTime + +#define rtsiSetStepSizePtr(S, ssp) ((S)->stepSizePtr = (ssp)) +#define rtsiSetStepSize(S, ss) (*((S)->stepSizePtr) = (ss)) +#define rtsiGetStepSize(S) *((S)->stepSizePtr) + +#define rtsiSetMinStepSize(S, ss) (((S)->minStepSize = (ss))) +#define rtsiGetMinStepSize(S) (S)->minStepSize + +#define rtsiSetMaxStepSize(S, ss) ((S)->maxStepSize = (ss)) +#define rtsiGetMaxStepSize(S) (S)->maxStepSize + +#define rtsiSetFixedStepSize(S, ss) ((S)->fixedStepSize = (ss)) +#define rtsiGetFixedStepSize(S) (S)->fixedStepSize + +#define rtsiSetMaxNumMinSteps(S, mns) ((S)->maxNumMinSteps = (mns)) +#define rtsiGetMaxNumMinSteps(S) (S)->maxNumMinSteps + +#define rtsiSetSolverMaxOrder(S, smo) ((S)->solverMaxOrder = (smo)) +#define rtsiGetSolverMaxOrder(S) (S)->solverMaxOrder + +#define rtsiSetSolverJacobianMethodControl(S, smcm) \ + (ssGetSolverInfo(S)->solverJacobianMethodControl = (smcm)) +#define rtsiGetSolverJacobianMethodControl(S) ssGetSolverInfo(S)->solverJacobianMethodControl + +#define rtsiSetSolverShapePreserveControl(S, smcm) \ + (ssGetSolverInfo(S)->solverShapePreserveControl = (smcm)) +#define rtsiGetSolverShapePreserveControl(S) ssGetSolverInfo(S)->solverShapePreserveControl + +#define rtsiSetSolverConsecutiveZCsStepRelTol(S, scr) \ + (ssGetSolverInfo(S)->solverConsecutiveZCsStepRelTol = (scr)) +#define rtsiGetSolverConsecutiveZCsStepRelTol(S) ssGetSolverInfo(S)->solverConsecutiveZCsStepRelTol + +#define rtsiSetSolverMaxConsecutiveZCs(S, smcz) \ + (ssGetSolverInfo(S)->solverMaxConsecutiveZCs = (smcz)) +#define rtsiGetSolverMaxConsecutiveZCs(S) ssGetSolverInfo(S)->solverMaxConsecutiveZCs + +#define rtsiSetSolverMaxConsecutiveMinStep(S, smcm) \ + (ssGetSolverInfo(S)->solverMaxConsecutiveMinStep = (smcm)) +#define rtsiGetSolverMaxConsecutiveMinStep(S) ssGetSolverInfo(S)->solverMaxConsecutiveMinStep + +#define rtsiSetSolverExtrapolationOrder(S, seo) ((S)->solverExtrapolationOrder = (seo)) +#define rtsiGetSolverExtrapolationOrder(S) (S)->solverExtrapolationOrder + +#define rtsiSetSolverNumberNewtonIterations(S, nni) ((S)->solverNumberNewtonIterations = (nni)) +#define rtsiGetSolverNumberNewtonIterations(S) (S)->solverNumberNewtonIterations + +#define rtsiSetSolverRefineFactor(S, smo) ((S)->solverRefineFactor = (smo)) +#define rtsiGetSolverRefineFactor(S) (S)->solverRefineFactor + +#define rtsiSetSolverRelTol(S, smo) ((S)->solverRelTol = (smo)) +#define rtsiGetSolverRelTol(S) (S)->solverRelTol + +#define rtsiSetSolverMassMatrixType(S, type) ((S)->massMatrixType = (type)) +#define rtsiGetSolverMassMatrixType(S) (S)->massMatrixType + +#define rtsiSetSolverMassMatrixNzMax(S, nzMax) ((S)->massMatrixNzMax = (nzMax)) +#define rtsiGetSolverMassMatrixNzMax(S) (S)->massMatrixNzMax + +#define rtsiSetSolverMassMatrixIr(S, ir) ((S)->massMatrixIr = (ir)) +#define rtsiGetSolverMassMatrixIr(S) (S)->massMatrixIr + +#define rtsiSetSolverMassMatrixJc(S, jc) ((S)->massMatrixJc = (jc)) +#define rtsiGetSolverMassMatrixJc(S) (S)->massMatrixJc + +#define rtsiSetSolverMassMatrixPr(S, pr) ((S)->massMatrixPr = (pr)) +#define rtsiGetSolverMassMatrixPr(S) (S)->massMatrixPr + +#define rtsiSetdXPtr(S, dxp) ((S)->dXPtr = (dxp)) +#define rtsiSetdX(S, dx) (*((S)->dXPtr) = (dx)) +#define rtsiGetdX(S) *((S)->dXPtr) + +#define rtsiSetTPtr(S, tp) ((S)->tPtr = (tp)) +#define rtsiSetT(S, t) ((*((S)->tPtr))[0] = (t)) +#define rtsiGetT(S) (*((S)->tPtr))[0] + +#define rtsiSetContStatesPtr(S, cp) ((S)->contStatesPtr = (cp)) +#define rtsiGetContStates(S) *((S)->contStatesPtr) + +#define rtsiSetNumContStatesPtr(S, cp) ((S)->numContStatesPtr = (cp)) +#define rtsiGetNumContStates(S) *((S)->numContStatesPtr) + +#define rtsiSetNumPeriodicContStatesPtr(S, cp) ((S)->numPeriodicContStatesPtr = (cp)) +#define rtsiGetNumPeriodicContStates(S) *((S)->numPeriodicContStatesPtr) + +#define rtsiSetPeriodicContStateIndicesPtr(S, cp) ((S)->periodicContStateIndicesPtr = (cp)) +#define rtsiGetPeriodicContStateIndices(S) *((S)->periodicContStateIndicesPtr) + +#define rtsiSetPeriodicContStateRangesPtr(S, cp) ((S)->periodicContStateRangesPtr = (cp)) +#define rtsiGetPeriodicContStateRanges(S) *((S)->periodicContStateRangesPtr) + +#define rtsiSetErrorStatusPtr(S, esp) ((S)->errStatusPtr = (esp)) +#define rtsiSetErrorStatus(S, es) (*((S)->errStatusPtr) = (es)) +#define rtsiGetErrorStatus(S) *((S)->errStatusPtr) + +#define rtsiSetModelMethodsPtr(S, mmp) ((S)->modelMethodsPtr = (mmp)) +#define rtsiGetModelMethodsPtr(S) (S)->modelMethodsPtr + +#define rtsiSetSolverComputingJacobian(S, val) ((S)->isComputingJacobian = (val)) +#define rtsiIsSolverComputingJacobian(S) (S)->isComputingJacobian + +#define rtsiSetSolverOutputComputed(S, val) ((S)->isOutputMethodComputed = (val)) +#define rtsiIsSolverOutputComputed(S) (S)->isOutputMethodComputed + +#define rtsiSetIsMinorTimeStepWithModeChange(S, sn) ((S)->isMinorTimeStepWithModeChange = (sn)) +#define rtsiGetIsMinorTimeStepWithModeChange(S) (S)->isMinorTimeStepWithModeChange + +#define rtsiIsModeUpdateTimeStep(S) \ + (rtsiGetSimTimeStep(S) == MAJOR_TIME_STEP || rtsiGetIsMinorTimeStepWithModeChange(S)) + +#define rtsiSetSolverZcSignalPtr(S, zcp) ((S)->zcSignalPtr = (zcp)) +#define rtsiSetSolverZcSignalVector(S, zcp) (*((S)->zcSignalPtr) = (zcp)) +#define rtsiGetSolverZcSignalVector(S) *((S)->zcSignalPtr) + + +#define rtsiSetSolverZcEventsVector(S, ptr) ((S)->zcEventsVector = (ptr)) +#define rtsiGetSolverZcEventsVector(S) ((S)->zcEventsVector) + +#define rtsiSetSolverZcSignalAttrib(S, ptr) ((S)->zcSignalAttrib = (ptr)) +#define rtsiGetSolverZcSignalAttrib(S) ((S)->zcSignalAttrib) + +#define rtsiSetSolverZcSignalVectorLength(S, n) ((S)->zcSignalVectorLength = (n)) +#define rtsiGetSolverZcSignalVectorLength(S) ((S)->zcSignalVectorLength) + +#define rtsiSetSolverFoundContZcEvents(S, val) ((S)->foundContZcEvents = (val)) +#define rtsiGetSolverFoundContZcEvents(S) ((S)->foundContZcEvents) + +#endif /* !NO_FLOATS */ + +#endif /* RTW_SOLVER_H__ */ -- GitLab