From 00f8e9a751c0136b7ea4d229c0c9504501826507 Mon Sep 17 00:00:00 2001 From: Uwe Jakobeit Date: Mon, 30 Mar 2026 09:41:19 +0200 Subject: [PATCH] initial commit --- .gitignore | 4 + .qtcreator/CMakeLists.txt.user.fc8d3b1 | 517 ++++ CMakeLists.txt | 27 + Jenkinsfile | 2 +- Testing/Temporary/CTestCostData.txt | 1 + Testing/Temporary/LastTest.log | 3 + app/CMakeLists.txt | 29 + app/Controller.cpp | 224 ++ app/Controller.hpp | 2530 +++++++++++++++++ app/climate-algorithm.cpp | 1 + app/climate-algorithm.h | 22 + app/datamodel.cpp | 29 + app/datamodel.h | 64 + app/dataset.cpp | 60 + app/dataset.h | 69 + app/filter.cpp | 20 + app/filter.h | 20 + app/main.cpp | 30 + app/pid.cpp | 9 + app/pid.h | 12 + app/pwm.cpp | 18 + app/pwm.h | 20 + app/text-templates.h | 19 + config/CMakeLists.txt | 38 + ks/CMakeLists.txt | 25 + ks/Models/FP56/Model.slx | Bin 0 -> 33044 bytes ks/Models/FP56/Model.slx.autosave | Bin 0 -> 22141 bytes ks/Models/FP56/Model.slxc | Bin 0 -> 196335 bytes ks/Models/FP56/Model_grt_rtw/Model.bat | 16 + ks/Models/FP56/Model_grt_rtw/Model.cpp | 358 +++ ks/Models/FP56/Model_grt_rtw/Model.h | 408 +++ ks/Models/FP56/Model_grt_rtw/Model.mk | 426 +++ ks/Models/FP56/Model_grt_rtw/Model.rsp | 7 + ks/Models/FP56/Model_grt_rtw/Model_comp.rsp | 6 + ks/Models/FP56/Model_grt_rtw/Model_data.cpp | 103 + ks/Models/FP56/Model_grt_rtw/Model_private.h | 43 + ks/Models/FP56/Model_grt_rtw/Model_ref.rsp | 1 + ks/Models/FP56/Model_grt_rtw/Model_types.h | 28 + ks/Models/FP56/Model_grt_rtw/buildInfo.mat | Bin 0 -> 12872 bytes .../FP56/Model_grt_rtw/builtin_typeid_types.h | 52 + ks/Models/FP56/Model_grt_rtw/codeInfo.mat | Bin 0 -> 10092 bytes .../FP56/Model_grt_rtw/codedescriptor.dmr | Bin 0 -> 616448 bytes ks/Models/FP56/Model_grt_rtw/compileInfo.mat | Bin 0 -> 3035 bytes .../FP56/Model_grt_rtw/multiword_types.h | 1169 ++++++++ ks/Models/FP56/Model_grt_rtw/rtGetInf.cpp | 163 ++ ks/Models/FP56/Model_grt_rtw/rtGetInf.h | 36 + ks/Models/FP56/Model_grt_rtw/rtGetNaN.cpp | 120 + ks/Models/FP56/Model_grt_rtw/rtGetNaN.h | 34 + ks/Models/FP56/Model_grt_rtw/rt_logging.h | 0 ks/Models/FP56/Model_grt_rtw/rt_nonfinite.cpp | 109 + ks/Models/FP56/Model_grt_rtw/rt_nonfinite.h | 64 + ks/Models/FP56/Model_grt_rtw/rtmodel.h | 21 + ks/Models/FP56/Model_grt_rtw/rtw_continuous.h | 0 ks/Models/FP56/Model_grt_rtw/rtw_proj.tmw | 4 + ks/Models/FP56/Model_grt_rtw/rtw_solver.h | 0 ks/Models/FP56/Model_grt_rtw/rtwtypes.h | 37 + .../FP56/Model_grt_rtw/rtwtypeschksum.mat | Bin 0 -> 1538 bytes ks/Models/FP56/Model_grt_rtw/setup_msvc.bat | 2 + .../tmwinternal/simulink_cache.xml | 6 + ks/Models/FP56/Model_grt_rtw/tmwtypes.h | 888 ++++++ ks/Models/FP56/Modell.slxc | Bin 0 -> 5264 bytes .../grt/Model/tmwinternal/BlockTraceInfo.mat | Bin 0 -> 567 bytes .../grt/Model/tmwinternal/CompileInfo.xml | 392 +++ .../slprj/grt/Model/tmwinternal/binfo.mat | Bin 0 -> 19267 bytes .../slprj/grt/Model/tmwinternal/minfo.mat | Bin 0 -> 2471 bytes .../slprj/grt/_sharedutils/shared_file.dmr | Bin 0 -> 122880 bytes .../Model/1/ModelAdvisorData | Bin 0 -> 109568 bytes .../sim/varcache/Model/checksumOfCache.mat | Bin 0 -> 392 bytes .../FP56/slprj/sim/varcache/Model/varInfo.mat | Bin 0 -> 5528 bytes .../sim/varcache/Modell/checksumOfCache.mat | Bin 0 -> 392 bytes .../Modell/tmwinternal/simulink_cache.xml | 6 + .../slprj/sim/varcache/Modell/varInfo.mat | Bin 0 -> 5528 bytes ks/Models/FP56/slprj/sl_proj.tmw | 2 + ks/main.cpp | 15 + tests/CMakeLists.txt | 7 + tests/filter-test.cpp | 26 + 76 files changed, 8341 insertions(+), 1 deletion(-) create mode 100644 .gitignore create mode 100644 .qtcreator/CMakeLists.txt.user.fc8d3b1 create mode 100644 CMakeLists.txt create mode 100644 Testing/Temporary/CTestCostData.txt create mode 100644 Testing/Temporary/LastTest.log create mode 100644 app/CMakeLists.txt create mode 100644 app/Controller.cpp create mode 100644 app/Controller.hpp create mode 100644 app/climate-algorithm.cpp create mode 100644 app/climate-algorithm.h create mode 100644 app/datamodel.cpp create mode 100644 app/datamodel.h create mode 100644 app/dataset.cpp create mode 100644 app/dataset.h create mode 100644 app/filter.cpp create mode 100644 app/filter.h create mode 100644 app/main.cpp create mode 100644 app/pid.cpp create mode 100644 app/pid.h create mode 100644 app/pwm.cpp create mode 100644 app/pwm.h create mode 100644 app/text-templates.h create mode 100644 config/CMakeLists.txt create mode 100644 ks/CMakeLists.txt create mode 100755 ks/Models/FP56/Model.slx create mode 100755 ks/Models/FP56/Model.slx.autosave create mode 100755 ks/Models/FP56/Model.slxc create mode 100755 ks/Models/FP56/Model_grt_rtw/Model.bat create mode 100755 ks/Models/FP56/Model_grt_rtw/Model.cpp create mode 100644 ks/Models/FP56/Model_grt_rtw/Model.h create mode 100755 ks/Models/FP56/Model_grt_rtw/Model.mk create mode 100755 ks/Models/FP56/Model_grt_rtw/Model.rsp create mode 100755 ks/Models/FP56/Model_grt_rtw/Model_comp.rsp create mode 100755 ks/Models/FP56/Model_grt_rtw/Model_data.cpp create mode 100644 ks/Models/FP56/Model_grt_rtw/Model_private.h create mode 100755 ks/Models/FP56/Model_grt_rtw/Model_ref.rsp create mode 100644 ks/Models/FP56/Model_grt_rtw/Model_types.h create mode 100755 ks/Models/FP56/Model_grt_rtw/buildInfo.mat create mode 100644 ks/Models/FP56/Model_grt_rtw/builtin_typeid_types.h create mode 100755 ks/Models/FP56/Model_grt_rtw/codeInfo.mat create mode 100755 ks/Models/FP56/Model_grt_rtw/codedescriptor.dmr create mode 100755 ks/Models/FP56/Model_grt_rtw/compileInfo.mat create mode 100644 ks/Models/FP56/Model_grt_rtw/multiword_types.h create mode 100755 ks/Models/FP56/Model_grt_rtw/rtGetInf.cpp create mode 100644 ks/Models/FP56/Model_grt_rtw/rtGetInf.h create mode 100755 ks/Models/FP56/Model_grt_rtw/rtGetNaN.cpp create mode 100644 ks/Models/FP56/Model_grt_rtw/rtGetNaN.h create mode 100644 ks/Models/FP56/Model_grt_rtw/rt_logging.h create mode 100755 ks/Models/FP56/Model_grt_rtw/rt_nonfinite.cpp create mode 100644 ks/Models/FP56/Model_grt_rtw/rt_nonfinite.h create mode 100644 ks/Models/FP56/Model_grt_rtw/rtmodel.h create mode 100644 ks/Models/FP56/Model_grt_rtw/rtw_continuous.h create mode 100755 ks/Models/FP56/Model_grt_rtw/rtw_proj.tmw create mode 100644 ks/Models/FP56/Model_grt_rtw/rtw_solver.h create mode 100644 ks/Models/FP56/Model_grt_rtw/rtwtypes.h create mode 100755 ks/Models/FP56/Model_grt_rtw/rtwtypeschksum.mat create mode 100755 ks/Models/FP56/Model_grt_rtw/setup_msvc.bat create mode 100755 ks/Models/FP56/Model_grt_rtw/tmwinternal/simulink_cache.xml create mode 100755 ks/Models/FP56/Model_grt_rtw/tmwtypes.h create mode 100755 ks/Models/FP56/Modell.slxc create mode 100755 ks/Models/FP56/slprj/grt/Model/tmwinternal/BlockTraceInfo.mat create mode 100755 ks/Models/FP56/slprj/grt/Model/tmwinternal/CompileInfo.xml create mode 100755 ks/Models/FP56/slprj/grt/Model/tmwinternal/binfo.mat create mode 100755 ks/Models/FP56/slprj/grt/Model/tmwinternal/minfo.mat create mode 100755 ks/Models/FP56/slprj/grt/_sharedutils/shared_file.dmr create mode 100755 ks/Models/FP56/slprj/modeladvisor/com_2emathworks_2ecgo_2egroup_/Model/1/ModelAdvisorData create mode 100755 ks/Models/FP56/slprj/sim/varcache/Model/checksumOfCache.mat create mode 100755 ks/Models/FP56/slprj/sim/varcache/Model/varInfo.mat create mode 100755 ks/Models/FP56/slprj/sim/varcache/Modell/checksumOfCache.mat create mode 100755 ks/Models/FP56/slprj/sim/varcache/Modell/tmwinternal/simulink_cache.xml create mode 100755 ks/Models/FP56/slprj/sim/varcache/Modell/varInfo.mat create mode 100755 ks/Models/FP56/slprj/sl_proj.tmw create mode 100644 ks/main.cpp create mode 100644 tests/CMakeLists.txt create mode 100644 tests/filter-test.cpp diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..85a65d3 --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +build +*.zip +*.user +app/.qtcreator/CMakeLists.txt.user diff --git a/.qtcreator/CMakeLists.txt.user.fc8d3b1 b/.qtcreator/CMakeLists.txt.user.fc8d3b1 new file mode 100644 index 0000000..eecc273 --- /dev/null +++ b/.qtcreator/CMakeLists.txt.user.fc8d3b1 @@ -0,0 +1,517 @@ + + + + + + EnvironmentId + {fc8d3b14-ba13-41ed-9488-a8a57abc777a} + + + ProjectExplorer.Project.ActiveTarget + 0 + + + ProjectExplorer.Project.EditorSettings + + true + true + true + + Cpp + + CppGlobal + + + + QmlJS + + QmlJSGlobal + + + 2 + UTF-8 + false + 4 + false + 0 + 80 + true + true + 1 + 0 + false + true + false + 2 + true + true + 0 + 8 + true + false + 1 + false + true + true + *.md, *.MD, Makefile + false + true + true + + + + ProjectExplorer.Project.PluginSettings + + + true + false + true + true + true + true + + false + + + 0 + true + + true + true + Builtin.DefaultTidyAndClazy + 8 + true + + /home/yoct/evaluation/cli/tmp-bbr-algo/bbr-algo/CMakeLists.txt + + + + true + + 0 + + + + ProjectExplorer.Project.Target.0 + + Desktop + true + Desktop Qt 6.10.2 + Desktop Qt 6.10.2 + qt.qt6.6102.linux_gcc_64_kit + 0 + 0 + 0 + + Debug + 2 + false + + -DCMAKE_BUILD_TYPE:STRING=Debug +-DCMAKE_COLOR_DIAGNOSTICS:BOOL=ON +-DCMAKE_CXX_COMPILER:FILEPATH=%{Compiler:Executable:Cxx} +-DCMAKE_C_COMPILER:FILEPATH=%{Compiler:Executable:C} +-DCMAKE_GENERATOR:STRING=Ninja +-DCMAKE_MAKE_PROGRAM:STRING=/usr/bin/ninja +-DCMAKE_PREFIX_PATH:PATH=%{Qt:QT_INSTALL_PREFIX} +-DCMAKE_PROJECT_INCLUDE_BEFORE:FILEPATH=%{BuildConfig:BuildDirectory:NativeFilePath}/.qtcreator/cmake-helper/qtcreator-project.cmake +-DQT_CREATOR_ENABLE_MAINTENANCE_TOOL_PROVIDER:BOOL=ON +-DQT_ENABLE_QML_DEBUG:BOOL=%{Qt:QT_ENABLE_QML_DEBUG} +-DQT_QMAKE_EXECUTABLE:FILEPATH=%{Qt:qmakeExecutable} + 0 + ./build/%{Asciify:%{Kit:FileSystemName}-%{BuildConfig:Name}} + + + + + all + + false + + true + Erstellen + CMakeProjectManager.MakeStep + + 1 + Erstellen + Erstellen + ProjectExplorer.BuildSteps.Build + + + + + + clean + + false + + true + Erstellen + CMakeProjectManager.MakeStep + + 1 + Bereinigen + Bereinigen + ProjectExplorer.BuildSteps.Clean + + 2 + false + + false + + Debug + CMakeProjectManager.CMakeBuildConfiguration + 0 + 0 + + + 0 + Deployment + Deployment + ProjectExplorer.BuildSteps.Deploy + + 1 + + false + ProjectExplorer.DefaultDeployConfiguration + + + + + + + + + false + + true + ApplicationManagerPlugin.Deploy.CMakePackageStep + + + install-package --acknowledge + true + Application Manager-Paket installieren + ApplicationManagerPlugin.Deploy.InstallPackageStep + + + + + + + + 2 + Deployment + Deployment + ProjectExplorer.BuildSteps.Deploy + + 1 + + false + ApplicationManagerPlugin.Deploy.Configuration + + 2 + + false + + false + + + true + true + 0 + true + + + 2 + + false + -e cpu-cycles --call-graph dwarf,4096 -F 250 + + CMakeProjectManager.CMakeRunConfiguration. + app + false + + true + true + true + %{RunConfig:Executable:Path} + + + true + true + 0 + true + + + 2 + + false + -e cpu-cycles --call-graph dwarf,4096 -F 250 + + CMakeProjectManager.CMakeRunConfiguration. + tests + false + + true + true + true + %{RunConfig:Executable:Path} + + 2 + + + Release + 2 + false + + -DCMAKE_BUILD_TYPE:STRING=Release +-DCMAKE_COLOR_DIAGNOSTICS:BOOL=ON +-DCMAKE_CXX_COMPILER:FILEPATH=%{Compiler:Executable:Cxx} +-DCMAKE_C_COMPILER:FILEPATH=%{Compiler:Executable:C} +-DCMAKE_GENERATOR:STRING=Ninja +-DCMAKE_MAKE_PROGRAM:STRING=/usr/bin/ninja +-DCMAKE_PREFIX_PATH:PATH=%{Qt:QT_INSTALL_PREFIX} +-DCMAKE_PROJECT_INCLUDE_BEFORE:FILEPATH=%{BuildConfig:BuildDirectory:NativeFilePath}/.qtcreator/cmake-helper/qtcreator-project.cmake +-DQT_CREATOR_ENABLE_MAINTENANCE_TOOL_PROVIDER:BOOL=ON +-DQT_ENABLE_QML_DEBUG:BOOL=%{Qt:QT_ENABLE_QML_DEBUG} +-DQT_QMAKE_EXECUTABLE:FILEPATH=%{Qt:qmakeExecutable} + ./build/%{Asciify:%{Kit:FileSystemName}-%{BuildConfig:Name}} + + + + + all + + false + + true + CMakeProjectManager.MakeStep + + 1 + Erstellen + Erstellen + ProjectExplorer.BuildSteps.Build + + + + + + clean + + false + + true + CMakeProjectManager.MakeStep + + 1 + Bereinigen + Bereinigen + ProjectExplorer.BuildSteps.Clean + + 2 + false + + false + + Release + CMakeProjectManager.CMakeBuildConfiguration + 1 + 0 + + + 0 + Deployment + Deployment + ProjectExplorer.BuildSteps.Deploy + + 1 + + false + ProjectExplorer.DefaultDeployConfiguration + + + + + + + + + false + + true + ApplicationManagerPlugin.Deploy.CMakePackageStep + + + install-package --acknowledge + true + Application Manager-Paket installieren + ApplicationManagerPlugin.Deploy.InstallPackageStep + + + + + + + + 2 + Deployment + Deployment + ProjectExplorer.BuildSteps.Deploy + + 1 + + false + ApplicationManagerPlugin.Deploy.Configuration + + 2 + + false + + false + + + true + true + 0 + true + + + 2 + + false + -e cpu-cycles --call-graph dwarf,4096 -F 250 + + CMakeProjectManager.CMakeRunConfiguration. + app + false + + true + true + true + %{RunConfig:Executable:Path} + + + true + true + 0 + true + + + 2 + + false + -e cpu-cycles --call-graph dwarf,4096 -F 250 + + CMakeProjectManager.CMakeRunConfiguration. + tests + false + + true + true + true + %{RunConfig:Executable:Path} + + 2 + + 2 + + + 0 + Deployment + Deployment + ProjectExplorer.BuildSteps.Deploy + + 1 + + false + ProjectExplorer.DefaultDeployConfiguration + + + + + + + + + false + + true + ApplicationManagerPlugin.Deploy.CMakePackageStep + + + install-package --acknowledge + true + Application Manager-Paket installieren + ApplicationManagerPlugin.Deploy.InstallPackageStep + + + + + + + + 2 + Deployment + Deployment + ProjectExplorer.BuildSteps.Deploy + + 1 + + false + ApplicationManagerPlugin.Deploy.Configuration + + 2 + + true + true + 0 + true + + + 2 + + false + -e cpu-cycles --call-graph dwarf,4096 -F 250 + + CMakeProjectManager.CMakeRunConfiguration. + app + false + + true + true + true + %{RunConfig:Executable:Path} + + + true + true + 0 + true + + + 2 + + false + -e cpu-cycles --call-graph dwarf,4096 -F 250 + + CMakeProjectManager.CMakeRunConfiguration. + tests + false + + true + true + true + %{RunConfig:Executable:Path} + + 2 + + + + ProjectExplorer.Project.TargetCount + 1 + + + Version + 22 + + diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..01b6493 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,27 @@ +cmake_minimum_required(VERSION 3.19) +project(bbr-algo LANGUAGES CXX) + +set(CMAKE_POSITION_INDEPENDENT_CODE ON) + +find_package(Qt6 REQUIRED COMPONENTS Core) + +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED ON) + + + +option(BUILD_TARGET_SOM "TARGET_SOM" OFF) + + +include_directories(app) +add_subdirectory(app) + +# Ks the 'plant' of the regulatroy system +# commented as long as 'MATLAB/extern/include' not avaliable +# include_directories(ks) +# add_subdirectory(ks) + +# add_subdirectory(config) + +enable_testing() +add_subdirectory(tests) diff --git a/Jenkinsfile b/Jenkinsfile index 3275b5b..91749cc 100644 --- a/Jenkinsfile +++ b/Jenkinsfile @@ -10,7 +10,7 @@ pipeline { stage('Clean-Jenkinsfile') { steps { //sh 'rm -rf build' - echo "Building branch ${env.BRANCH_NAME}" + echo "Cleaning branch ${env.BRANCH_NAME}" } } stage('Configure') { diff --git a/Testing/Temporary/CTestCostData.txt b/Testing/Temporary/CTestCostData.txt new file mode 100644 index 0000000..ed97d53 --- /dev/null +++ b/Testing/Temporary/CTestCostData.txt @@ -0,0 +1 @@ +--- diff --git a/Testing/Temporary/LastTest.log b/Testing/Temporary/LastTest.log new file mode 100644 index 0000000..db26a29 --- /dev/null +++ b/Testing/Temporary/LastTest.log @@ -0,0 +1,3 @@ +Start testing: Mar 19 16:16 CET +---------------------------------------------------------- +End testing: Mar 19 16:16 CET diff --git a/app/CMakeLists.txt b/app/CMakeLists.txt new file mode 100644 index 0000000..15c8f84 --- /dev/null +++ b/app/CMakeLists.txt @@ -0,0 +1,29 @@ + + + +qt_standard_project_setup() + +qt_add_executable(app main.cpp + ) + +qt_add_library(app_lib STATIC + filter.h main.cpp filter.cpp + Controller.hpp main.cpp Controller.cpp + pwm.h pwm.cpp + climate-algorithm.h climate-algorithm.cpp + pid.h pid.cpp + datamodel.h datamodel.cpp + dataset.h dataset.cpp + + text-templates.h + + ) + +target_include_directories(app_lib PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}) +target_include_directories(app_lib PRIVATE ${Qt6Core_INCLUDE_DIRS}) + +# add_executable(app main.cpp filter.cpp) +target_link_libraries(app PRIVATE + app_lib + Qt::Core +) diff --git a/app/Controller.cpp b/app/Controller.cpp new file mode 100644 index 0000000..7dad55e --- /dev/null +++ b/app/Controller.cpp @@ -0,0 +1,224 @@ +#include "Controller.hpp" + + +#ifdef BUILD_TARGET_SOM +#include "application/AppLogic.hpp" +#include "application/Environment.hpp" +#include "application/EventLogger.hpp" +#include "deviceConfig/model/DeviceConfiguration.hpp" +#include "deviceConfig/model/state/GuardedAnalogConfiguration.hpp" +#include "state/DeviceState.hpp" + + + +bool Controller::initialize(const char *configFilePath, appengine::IAppLogic *appLogic) { + appLogic_ = appLogic; + auto deviceState = appLogic->deviceState(); + + + + + // Beispiel: + SV_Temperatur_Variable_ = deviceState.getVariableByKey("Temperatur_Innenraum"); + SV_Feuchte_Variable_ = deviceState.getVariableByKey("Humidity"); + SV_Tuer_Variable_ = deviceState.getVariableByKey("Temperatur_Tuer"); + Wasserstand_Oben_Config_ = deviceState.getVariableByKey("Wasserstand_Hoch"); + Wasserstand_Unten_Config_ = deviceState.getVariableByKey("Wasserstand_Tief"); + Fuellstand_Config_ = deviceState.getVariableByKey("Fuellstand"); + Heizung_Bef_Config_ = deviceState.getVariableByKey("Heizung_Bef"); + MV_Kuehlung_Config_ = deviceState.getVariableByKey("MV_Kuehlung"); + Abschlaemmen_Config_ = deviceState.getVariableByKey("Abschlaemmen"); + Entleerpumpe_Config_ = deviceState.getVariableByKey("Entleerpumpe"); + Heizung_Kesselrand_Config_ = deviceState.getVariableByKey("Heizung_Kesselrand"); + Freigabe_Verfluessigerluefter_Config_ = deviceState.getVariableByKey("Freigabe_Verfluessigerluefter"); + Heizung_Innenraum_Config_ = deviceState.getVariableByKey("Heizung_Innenraum"); + Heizung_Tuer_Config_ = deviceState.getVariableByKey("Heizung_Tuer"); + Uebertemperatur_Config_ = deviceState.getVariableByKey("Uebertemperatur"); + MV_Entfeuchtung_Config_ = deviceState.getVariableByKey("MV_Entfeuchtung"); + MV_Druckluft_Config_ = deviceState.getVariableByKey("MV_Druckluft"); + Ansteuerung_Wassereinlass_Config_ = deviceState.getVariableByKey("Ansteuerung_Wassereinlass"); + Ansteuerung_Verdichter_Config_ = deviceState.getVariableByKey("Ansteuerung_Verdichter"); + Luefter_Innenraum_Config_ = deviceState.getVariableByKey("Luefter_Innenraum"); + SV_Verdampferausgang_ = deviceState.getVariableByKey("Temperatur_Verdampferausgang"); + SV_Befeuchtungsmodul_ = deviceState.getVariableByKey("Temperatur_Befeuchtungsmodul"); + const_duty_cycle_ = deviceState.getVariableByKey("steady_duty"); + const_freq_ = deviceState.getVariableByKey("steady_freq"); + Verdichter_Duty_Config = deviceState.getVariableByKey("Ansteuerung_Verdichter_duty"); + SV_Stellgrad_Heizung = deviceState.getVariableByKey("Stellgrad_Heizung"); + SV_Stellgrad_Kuehlung = deviceState.getVariableByKey("Stellgrad_Kuehlung"); + SV_Stellgrad_Befeuchtung = deviceState.getVariableByKey("Stellgrad_Befeuchtung"); + SV_Stellgrad_Entfeuchtung = deviceState.getVariableByKey("Stellgrad_Entfeuchtung"); + SV_Verdichter_on_ = deviceState.getVariableByKey("Verdichter_on"); + Startup_ = deviceState.getVariableByKey("Startup_finished"); + CounterTuer_ = deviceState.getVariableByKey("Counter_Tuer"); + + const_duty_cycle_ ->setValue(1000.0); + const_freq_->setValue(1000.0); + + auto TempConfig = dynamic_cast(SV_Temperatur_Variable_->configuration()); + auto FeuchteConfig = dynamic_cast(SV_Feuchte_Variable_->configuration()); + + + auto Sollwert_Temp_Config = TempConfig.setPointConfiguration(); + auto Sollwert_Feuchte_Config = FeuchteConfig.setPointConfiguration(); + SV_Sollwert_Temperatur_ = deviceState.getVariableByKey(Sollwert_Temp_Config->name()); + SV_Sollwert_Feuchte_ = deviceState.getVariableByKey(Sollwert_Feuchte_Config->name()); + + + + + + +// std::vector subscriptions_{}; +// std::shared_ptr Heizung_Bef_; +// std::shared_ptr MV_Kuehlung_; +// std::shared_ptr Abschlaemmen_; +// std::shared_ptr Entleerpumpe_; +// std::shared_ptr Heizung_Kesselrand; +// std::shared_ptr Freigabe_Verfluessigerluefter; +// std::shared_ptr Heizung_Innenraum; +// std::shared_ptr Heizung_Tuer; +// std::shared_ptr Uebertemperatur; +// std::shared_ptr MV_Entfeuchtung; +// std::shared_ptr MV_Druckluft; +// std::shared_ptr Ansteuerung_Wassereinlass; +// std::shared_ptr Wasserstand_oben_Config_; +// std::shared_ptr Wasserstand_oben_Config_; +// std::shared_ptr Ansteuerung_Verdichter; +// std::shared_ptr Luefter_Innenraum; +// std::shared_ptr heatingPower_Freq_; +// std::vector subscriptions_{}; +// std::shared_ptr SV_Sollwert_Temperatur_; +// std::shared_ptr SV_Temperatur_Variable_; +// std::shared_ptr SV_Sollwert_Feuchte_; +// std::shared_ptr SV_Feuchte_Variable_; +// std::shared_ptr SV_Tuer_Variable_; + + // tempSetPointVariable_ = deviceState.getVariableByKey("Temperature_Setpoint"); + + // TODO: alle bool_inXX/real_inXX und bool_outXX/real_outXX/alarm_XX Variablen hier holen. +// struct Inputs { +// // Eingangswerte aus bool_inXX / real_inXX / reset_flag +// bool reset_flag{}; +// bool Sammelalarm_quittiert{}; +// bool Tuer_offen{}; +// bool Sollwert_Feuchte_aktiv{}; +// bool Steuerkontakt_Standby{}; +// bool Steuerkontakt_Befeuchtung_aus{}; +// bool Steuerkontakt_Entfeuchtung_aus{}; +// bool Entleerbehaelter_Oben{}; +// bool Wasserkanister_leer{}; +// bool Entleerbehaelter_Unten{}; +// bool Sammelalarm{}; + +// double Istwert_Temperatur{}; +// double Sollwert_Temperatur{}; +// double Temperaturband{}; +// double Istwert_Ueberwachungsregler{}; +// double Klasse_Ueberwachungsregler{}; +// double Grenzwert_Untertemperatur{}; +// double Istwert_Feuchte{}; +// double Sollwert_Feuchte{}; +// double Feuchteband{}; +// double Sollwert_Luefter{}; +// double Istwert_Temperatur_Tuer{}; +// double Istwert_Temperatur_Verdampferausgang{}; +// double Temperatur_Feuchtemodul{}; +// double Bandalarm_nach{}; +// double Betauungsschutz{}; +// double real_in11{}; // du nutzt real_in11 später direkt in alarm_15 +// }; + + //Initialize PT1 Filter + + FILTERED_TEMP.initialize(0.25,1); + FILTER_TUER.initialize(0.25,1); + return true; +} + +#endif + + + +void Controller::step() { +#ifdef BUILD_TARGET_SOM + ClimateAlgorithm::Inputs in{}; + in.Istwert_Temperatur = FILTERED_TEMP.step(SV_Temperatur_Variable_->toType()); + in.Sollwert_Temperatur = SV_Sollwert_Temperatur_ ->toType(); + in.Entleerbehaelter_Oben = Wasserstand_Oben_Config_->toType(); + in.Entleerbehaelter_Unten = Wasserstand_Unten_Config_->toType(); + in.Istwert_Feuchte = SV_Feuchte_Variable_->toType(); + in.Sollwert_Feuchte = SV_Sollwert_Feuchte_->toType(); + in.Istwert_Temperatur_Tuer = FILTER_TUER.step(SV_Tuer_Variable_->toType()); + in.Betauungsschutz = 50.0; + in.Grenzwert_Untertemperatur = -80.0; + in.Feuchteband=10.0; + in.Istwert_Temperatur_Verdampferausgang = SV_Verdampferausgang_->toType(); + in.Sollwert_Feuchte = SV_Sollwert_Feuchte_->toType(); + in.Istwert_Ueberwachungsregler=in.Istwert_Temperatur; + in.Klasse_Ueberwachungsregler = 3.0; + in.reset_flag =false; + in.Sammelalarm = false; + in.Sollwert_Feuchte_aktiv = true; + in.Temperaturband = 5.0; + in.Temperatur_Feuchtemodul = SV_Befeuchtungsmodul_->toType(); + in.Wasserkanister_leer = false; + in.Tuer_offen = false; + + + // TODO: reset_flag und bool_inXX lesen: + // in.reset_flag = deviceState.getVariableByKey("reset_flag")->toType(); + // in.Sammelalarm_quittiert = ... bool_in01 + // ... + // in.Istwert_Temperatur = real_in01 + // ... + + // Minimal-Beispiel (falls du erstmal nur Temperatur/Setpoint testest): + //in.Istwert_Temperatur = tempVariable_ ? tempVariable_->toType() : 0.0; + //in.Sollwert_Temperatur = tempSetPointVariable_ ? tempSetPointVariable_->toType() : 25.0; + + auto out = algo_.step(in); + + Heizung_Bef_Config_ -> setValue(out.bool_out17); + MV_Kuehlung_Config_ ->setValue(out.bool_out18); + Abschlaemmen_Config_->setValue(out.bool_out20); + Entleerpumpe_Config_->setValue(out.bool_out16); + Heizung_Kesselrand_Config_->setValue(out.bool_out12); + Freigabe_Verfluessigerluefter_Config_->setValue(out.bool_out13); + Heizung_Innenraum_Config_->setValue(out.bool_out09); + Heizung_Tuer_Config_->setValue(out.bool_out11); + Uebertemperatur_Config_->setValue(true); + MV_Entfeuchtung_Config_->setValue(out.bool_out19); + MV_Druckluft_Config_->setValue(false); + + Ansteuerung_Wassereinlass_Config_->setValue(out.bool_out14); + //Ansteuerung_Verdichter_Config_->setValue(out.real_out21*20.0); + SV_Verdichter_on_->setValue(1); + Ansteuerung_Verdichter_Config_->setValue(static_cast (out.real_out21*10.0)); + Verdichter_Duty_Config->setValue(500); + + SV_Stellgrad_Heizung->setValue(out.Stellgrad_Heizung); + SV_Stellgrad_Kuehlung->setValue(out.Stellgrad_Kuehlung); + SV_Stellgrad_Befeuchtung ->setValue(out.Stellgrad_Befeuchtung); + SV_Stellgrad_Entfeuchtung->setValue(out.Stellgrad_Entfeuchtung); + Startup_->setValue(out.Startup); + CounterTuer_->setValue(out.Counter_Tuer); + + // TODO: bool_outXX / real_outXX / alarm_XX setzen: + // deviceState.getVariableByKey("bool_out01")->set(out.bool_out01); + // deviceState.getVariableByKey("real_out09")->set(out.real_out09); +#endif +} + +void Controller::terminate() { +#ifdef BUILD_TARGET_SOM + subscriptions_.clear(); +#endif +} + +#ifdef BUILD_TARGET_SOM +ControllerBase *create() { + + return new Controller; +} +#endif diff --git a/app/Controller.hpp b/app/Controller.hpp new file mode 100644 index 0000000..e1ac976 --- /dev/null +++ b/app/Controller.hpp @@ -0,0 +1,2530 @@ +#pragma once + +#ifdef BUILD_TARGET_SOM + +#if defined(_WIN32) +#define BINDER_SIMULINK_API_EXPORT __declspec(dllexport) +#else +#define BINDER_SIMULINK_API_EXPORT __attribute__((visibility("default"))) +#endif +#include "algorithm/ControllerBase.hpp" +#include "asio/SignalConnection.hpp" + +#endif + +#include +#include +#include +#include +#include +#include +#include + +const double PI_CONST = 3.14159265358979323846; + +#define MAX std::max +#define MIN std::min + +namespace UTILITY_FUNCTIONS { + +inline double limit(double x, double lo, double hi) { + return (x < lo) ? lo : (x > hi) ? hi : x; +} + +inline double max3(double a, double b, double c) { + return std::max(a, std::max(b, c)); +} +inline double min3(double a, double b, double c) { + return std::min(a, std::min(b, c)); +} + +inline bool is_valid(double x) { return std::isfinite(x); } + +// ST: REAL_TO_INT(x) i.d.R. trunc Richtung 0. Bei Siemens oft ROUND? Du nutzt +// häufig +0.5. +inline int real_to_int(double x) { return static_cast(x); } + +// Platzhalter für GET_VALUE_* (kommt vermutlich aus Parameter-/Recipe-System) +inline std::int32_t GET_VALUE_DINT(int /*a*/, int /*b*/, int /*c*/, int /*d*/) { + // TODO: an dein Parameter-System anbinden + return 0; +} +inline double GET_VALUE_REAL(int /*a*/, int /*b*/, int /*c*/, int /*d*/) { + // TODO: an dein Parameter-System anbinden + return 0.0; +} + +} // namespace UTILITY_FUNCTIONS + +// ------------------------- +// Regelkern (ST -> C++) +// ------------------------- + +class PWM { +public: + PWM(double zyklus_min, double zyklus_max, double initial_zykluszeit = -1.0) { + Zykluszeit = 0.0; + Ausgabe = 0.0; + Zyklus_MAX = zyklus_max; + Zyklus_MIN = zyklus_min; + } + /*(* Puls Pause Generierung Kühlung *) + Zyklus_Kuehlventil := Zyklus_Kuehlventil + sampling_time; + + IF Ausgabe_Kuehlventil > 0.0 THEN + Kuehlventil := NOT Status_Untertemperatur; + Ausgabe_Kuehlventil := Ausgabe_Kuehlventil - sampling_time; + IF Ausgabe_Kuehlventil < 0.0 THEN + Zykluszeit_Kuehlventil := Zykluszeit_Kuehlventil - + Ausgabe_Kuehlventil * 100.0 / MAX(Stellgrad_Kuehlventil, sampling_time / + Zykluszeit_Kuehlventil_MAX * 100.0); Ausgabe_Kuehlventil := 0.0; END_IF; ELSE + Kuehlventil := FALSE; + END_IF; + + IF Stellgrad_Kuehlventil > sampling_time / Zykluszeit_Kuehlventil_MAX * 100.0 + THEN IF Zyklus_Kuehlventil >= Zykluszeit_Kuehlventil OR Zyklus_Kuehlventil >= + MAX(2.0 * Zykluszeit_Kuehlventil_MIN, sampling_time * 100.0 / + Stellgrad_Kuehlventil) THEN Ausgabe_Kuehlventil := MIN(Ausgabe_Kuehlventil + + Stellgrad_Kuehlventil / 100.0 * Zykluszeit_Kuehlventil_MIN, + Zykluszeit_Kuehlventil); Zykluszeit_Kuehlventil := Zykluszeit_Kuehlventil_MIN; + Zyklus_Kuehlventil := 0.0; + END_IF; + END_IF;*/ + + bool step(double Stellgrad, double samplingTime) { + Zyklus += samplingTime; + bool output_bool; + if (Ausgabe > 0.0) { + output_bool = true; + Ausgabe -= samplingTime; + if (Ausgabe < 0.0) { + Zykluszeit -= + Ausgabe * 100 / MAX(Stellgrad, samplingTime / Zyklus_MAX * 100.0); + Ausgabe = 0.0; + } + + } else { + output_bool = false; + } + if (Stellgrad > samplingTime / Zyklus_MAX * 100.0) { + if (Zyklus >= Zykluszeit || + Zyklus >= MAX(2.0 * Zyklus_MIN, samplingTime * 100.0 / Stellgrad)) { + Ausgabe = MIN(Ausgabe + Stellgrad / 100.0 * Zyklus_MIN, Zyklus); + Zykluszeit = Zyklus_MIN; + Zyklus = 0.0; + } + } + return output_bool; + } + +private: + double Zyklus = 0.0; + double Ausgabe = 0.0; + double Zykluszeit = 0.0; + double Zyklus_MAX = 0.0; + double Zyklus_MIN = 0.0; +}; + +class ClimateAlgorithm { +public: + struct BinInputs { + // Eingangswerte aus bool_inXX / real_inXX / reset_flag + bool reset_flag{}; + bool Sammelalarm_quittiert{}; + bool Tuer_offen{}; + bool Sollwert_Feuchte_aktiv{}; + bool Steuerkontakt_Standby{}; + bool Steuerkontakt_Befeuchtung_aus{}; + bool Steuerkontakt_Entfeuchtung_aus{}; + bool Entleerbehaelter_Oben{}; + bool Wasserkanister_leer{}; + bool Entleerbehaelter_Unten{}; + bool Sammelalarm{}; + } binInput; + + struct AnalogInputs { + double Istwert_Temperatur{}; + double Sollwert_Temperatur{}; + double Temperaturband{}; + double Istwert_Ueberwachungsregler{}; + double Klasse_Ueberwachungsregler{}; + double Grenzwert_Untertemperatur{}; + double Istwert_Feuchte{}; + double Sollwert_Feuchte{}; + double Feuchteband{}; + double Sollwert_Luefter{}; + double Istwert_Temperatur_Tuer{}; + double Istwert_Temperatur_Verdampferausgang{}; + double Temperatur_Feuchtemodul{}; + double Bandalarm_nach{}; + double Betauungsschutz{}; + double real_in11{}; // du nutzt real_in11 später direkt in alarm_15 + } analogInput; + + struct BinOutputs { + // bool_outXX + bool bool_out01{}; + bool bool_out02{}; + bool bool_out03{}; + bool bool_out07{}; + bool bool_out09{}; + bool bool_out11{}; + bool bool_out12{}; + bool bool_out13{}; + bool bool_out14{}; + bool bool_out16{}; + bool bool_out17{}; + bool bool_out18{}; + bool bool_out19{}; + bool bool_out20{}; + bool bool_out21{}; + bool bool_out23{}; + } binOut; + + struct AnalogOutputs { + // real_outXX (nur die, die du im ST setzt) + double real_out01{}; + double real_out02{}; + double real_out04{}; + double real_out05{}; + double real_out06{}; + double real_out07{}; + double real_out08{}; + double real_out09{}; + double real_out10{}; + double real_out11{}; + double real_out12{}; + double real_out13{}; + double real_out14{}; + double real_out16{}; + double Stellgrad_Feuchtemodul{}; // ...out17 + double real_out18{}; + double real_out19{}; + double real_out20{}; + double real_out21{}; + double real_out25{}; + double real_out26{}; + double Stellgrad_Heizung{}; + double Stellgrad_Kuehlung{}; + double Stellgrad_Befeuchtung{}; + double Stellgrad_Entfeuchtung{}; + double Counter_Tuer{}; + } analogOut; + + struct Alarm { + // alarm_01..alarm_15 + bool Startup{}; + bool alarm_01{}; + bool alarm_02{}; + bool alarm_03{}; + bool alarm_04{}; + bool alarm_05{}; + bool alarm_06{}; + bool alarm_07{}; + bool alarm_08{}; + bool alarm_09{}; + bool alarm_10{}; + bool alarm_11{}; + bool alarm_12{}; + bool alarm_13{}; + bool alarm_14{}; + bool alarm_15{}; + } alarmOut; + + ClimateAlgorithm() = default; + + void Step(void) { + using UTILITY_FUNCTIONS::is_valid; + using UTILITY_FUNCTIONS::limit; + + // --------------------------- + // Eingangswerte (ST Zuweisungen) + // --------------------------- + Sammelalarm_quittiert = binInput.Sammelalarm_quittiert; + Tuer_offen = binInput.Tuer_offen; + Sollwert_Feuchte_aktiv = true; + Steuerkontakt_Standby = false; + Steuerkontakt_Befeuchtung_aus = false; + Steuerkontakt_Entfeuchtung_aus = false; + Entleerbehaelter_Oben = binInput.Entleerbehaelter_Oben; + bool Wasserkanister_leer = false; + Entleerbehaelter_Unten = binInput.Entleerbehaelter_Unten; + Sammelalarm = false; + Istwert_Temperatur = analogInput.Istwert_Temperatur; + Istwert_Ueberwachungsregler = Istwert_Temperatur; + Sollwert_Temperatur = analogInput.Sollwert_Temperatur; + Istwert_Feuchte = analogInput.Istwert_Feuchte; + Sollwert_Feuchte = analogInput.Sollwert_Feuchte; + // uj - not needed double Sollwert_Luefter = analogInput.Sollwert_Luefter; + Istwert_Temperatur_Tuer = analogInput.Istwert_Temperatur_Tuer; + double Istwert_Temperatur_Verdampferausgang = analogInput.Istwert_Temperatur_Verdampferausgang; + Temperatur_Feuchtemodul = analogInput.Temperatur_Feuchtemodul; + double Betauungsschutz = 50.0; + double Feuchteband = 10; + double Temperaturband = 5; + bool reset_flag = binInput.reset_flag; + + // Zähler reset_flag + // ----------------- + if (reset_flag) { + Counter_reset_flag = 0; + } else { + Counter_reset_flag += 1; + } + Startup_finished = + (Counter_reset_flag > static_cast(10 * 4)); + + // ------------------------------------------ + // Verzögerte Abschaltung Regelung bei Türöffnung + // ------------------------------------------ + // f_PostDoorOpeningCutOffDelaed(...) + if (Tuer_offen || Steuerkontakt_Standby) { + Counter_Regelung_AUS += sampling_time; + } else { + Counter_Regelung_AUS = 0.0; + } + Regelung_AUS = (Counter_Regelung_AUS > 60.0); + + // ------------------- + // Nachlauf Türöffnung + // ------------------- + // f_PostDoorOpening(..) + if (!Startup_finished) { + Counter_Tuer_offen = 0.0; + Counter_Tuer_geschlossen = 600.0; + } else if (Tuer_offen) { + Counter_Tuer_offen += sampling_time; + Counter_Tuer_geschlossen = 0.0; + } else { + Counter_Tuer_offen = 0.0; + Counter_Tuer_geschlossen += sampling_time; + } + + Sollwert_Temperatur_MIN = -5.0; + Sollwert_Temperatur_MAX = 100.0; + + // ------------------------------------------ + // Sollwert Feuchte (Limit-Kennfeld) + // ------------------------------------------ + // f_HumiditySetValueByVector(...) + Index_Sollwert_Feuchte_Limit = 1; + while (Kennfeld_Sollwert_Feuchte_Limit[0][Index_Sollwert_Feuchte_Limit] < + Sollwert_Temperatur && + Index_Sollwert_Feuchte_Limit < 10) { + Index_Sollwert_Feuchte_Limit++; + } + + Interpolation_Sollwert_Feuchte_Limit = limit( + (Kennfeld_Sollwert_Feuchte_Limit[0][Index_Sollwert_Feuchte_Limit - 1] - + Sollwert_Temperatur) / + (Kennfeld_Sollwert_Feuchte_Limit[0] + [Index_Sollwert_Feuchte_Limit - 1] - + Kennfeld_Sollwert_Feuchte_Limit[0][Index_Sollwert_Feuchte_Limit]), + 0.0, 1.0); + + Sollwert_Feuchte_Max = + Kennfeld_Sollwert_Feuchte_Limit[1][Index_Sollwert_Feuchte_Limit] * + Interpolation_Sollwert_Feuchte_Limit + + Kennfeld_Sollwert_Feuchte_Limit[1][Index_Sollwert_Feuchte_Limit - 1] * + (1.0 - Interpolation_Sollwert_Feuchte_Limit); + + Sollwert_Feuchte_Min = + Kennfeld_Sollwert_Feuchte_Limit[2][Index_Sollwert_Feuchte_Limit] * + Interpolation_Sollwert_Feuchte_Limit + + Kennfeld_Sollwert_Feuchte_Limit[2][Index_Sollwert_Feuchte_Limit - 1] * + (1.0 - Interpolation_Sollwert_Feuchte_Limit); + + Sollwert_Feuchte = + limit(Sollwert_Feuchte, Sollwert_Feuchte_Min, Sollwert_Feuchte_Max); + + + + // Abschaltung Feuchteregelung + // f_CutOffHumidityControl(...) + Befeuchtung_aus = + (!Sollwert_Feuchte_aktiv) || Steuerkontakt_Befeuchtung_aus || + (Sollwert_Temperatur > 95.0) || (Sollwert_Temperatur < 5.0); + Entfeuchtung_aus = + (!Sollwert_Feuchte_aktiv) || Steuerkontakt_Entfeuchtung_aus || + (Sollwert_Temperatur > 95.0) || (Sollwert_Temperatur < 5.0); + + // (p_H2Omax, Taupunkt etc.) + p_H2Omax_Sollwert = 6.112 * std::exp(17.62 * Sollwert_Temperatur / + (243.12 + Sollwert_Temperatur)); + p_H2Omax_Istwert = 6.112 * std::exp(17.62 * Istwert_Temperatur / + (243.12 + Istwert_Temperatur)); + + Taupunkt_Istwert = + (241.2 * std::log(std::max(Istwert_Feuchte, 0.001) / 100.0) + + (4222.03716 * Istwert_Temperatur) / (241.2 + Istwert_Temperatur)) / + (17.5043 - std::log(std::max(Istwert_Feuchte, 0.001) / 100.0) - + (17.5043 * Istwert_Temperatur) / (241.2 + Istwert_Temperatur)); + + if (Temperatursprung) { + Sollwert_Feuchte_Absolut = + limit(Sollwert_Feuchte * p_H2Omax_Sollwert / p_H2Omax_Istwert, 0.0, + Sollwert_Feuchte); + } else { + Sollwert_Feuchte_Absolut = Sollwert_Feuchte; + } + if (!is_valid(Sollwert_Feuchte_Absolut)) { + Sollwert_Feuchte_Absolut = Sollwert_Feuchte; + } + + // ------------------ + // Überwachungsregler + // ------------------ + // f_SuperVisor + + /* + Modus_Ueberwachungsregler = + static_cast(UTILITY_FUNCTIONS::GET_VALUE_DINT(71,0,3,0)); + Grenzwert_Uebertemperatur = UTILITY_FUNCTIONS::GET_VALUE_REAL(71,0,4,0); + Offset_Ueberwachungsregler = UTILITY_FUNCTIONS::GET_VALUE_REAL(71,0,5,0); + + if (Modus_Ueberwachungsregler > 0) { + Schaltwert_Uebertemperatur = limit(Sollwert_Temperatur + + Offset_Ueberwachungsregler, -30.0, 110.0); Schaltwert_Untertemperatur = + limit(Sollwert_Temperatur - Offset_Ueberwachungsregler, -30.0, 110.0); } + else { Schaltwert_Uebertemperatur = Grenzwert_Uebertemperatur; + Schaltwert_Untertemperatur = Grenzwert_Untertemperatur; + } + + const double maxUeberw = std::max(Istwert_Ueberwachungsregler, + Istwert_Temperatur); const double minUeberw = + std::min(Istwert_Ueberwachungsregler, Istwert_Temperatur); + + if ( (maxUeberw > Schaltwert_Uebertemperatur) || + (Status_Uebertemperatur && (maxUeberw > Schaltwert_Uebertemperatur + - 1.0)) || (StatusQuittierung_Uebertemperatur && (Klasse_Ueberwachungsregler + < 3.0)) ) { Counter_Status_Uebertemperatur += 1; } else { + Counter_Status_Uebertemperatur = 0; + } + + Status_Uebertemperatur = (Counter_Status_Uebertemperatur >= + static_cast(10 * 4)); StatusQuittierung_Uebertemperatur = + (Status_Uebertemperatur && Counter_Status_Uebertemperatur < + static_cast(11 * 4)) || (StatusQuittierung_Uebertemperatur && + Sammelalarm_quittiert); + + if ( ((minUeberw < Schaltwert_Untertemperatur) || + (Status_Untertemperatur && (minUeberw < Schaltwert_Untertemperatur + + 1.0))) && (Klasse_Ueberwachungsregler >= 3.0) ) { + Counter_Status_Untertemperatur += 1; + } else { + Counter_Status_Untertemperatur = 0; + } + + Status_Untertemperatur = (Counter_Status_Untertemperatur >= + static_cast(10 * 4)); StatusQuittierung_Untertemperatur = + (Status_Untertemperatur && Counter_Status_Untertemperatur < + static_cast(11 * 4)) || (StatusQuittierung_Untertemperatur && + Sammelalarm_quittiert); + + if (Status_Untertemperatur || StatusQuittierung_Untertemperatur) { + Sollwert_Temperatur = std::max(Sollwert_Temperatur, + Schaltwert_Untertemperatur); + } + if (Status_Uebertemperatur || StatusQuittierung_Uebertemperatur) { + Sollwert_Temperatur = std::min(Sollwert_Temperatur, + Schaltwert_Uebertemperatur); + }*/ + + // ------------------------ + // Parametersatzumschaltung + // ------------------------ + // f_SwitchParameterSet(...) + Index_Feuchte = static_cast( + 8 - + UTILITY_FUNCTIONS::real_to_int( + limit((Sollwert_Feuchte - 10.0) / (90.0 - 10.0) * 8.0, 0.0, 8.0) + + 0.5)); + Index_Temperatur = + static_cast(UTILITY_FUNCTIONS::real_to_int( + limit((Sollwert_Temperatur - 10.0) / (90.0 - 10.0) * 8.0, 0.0, + 8.0) + + 0.5)); + Index_Temperatur_ohne_Feuchte = + static_cast(UTILITY_FUNCTIONS::real_to_int( + limit((Sollwert_Temperatur - (-20.0)) / (100.0 - (-20.0)) * 12.0, + 0.0, 12.0) + + 0.5)); + + Regler_Heizung_Xp = F_Xp_Heizung * Kennfeld_Regler_Heizung_Xp[Index_Temperatur_ohne_Feuchte]; + Regler_Kuehlung_Xp = F_Xp_Kuehlung * + Kennfeld_Regler_Kuehlung_Xp[Index_Temperatur_ohne_Feuchte]; + Regler_Befeuchtung_Xp = + F_Xp_Befeuchtung_BINDER * + Kennfeld_Regler_Befeuchtung_Xp[Index_Feuchte][Index_Temperatur]; + Regler_Entfeuchtung_Xp = + F_Xp_Entfeuchtung * + Kennfeld_Regler_Entfeuchtung_Xp[Index_Feuchte][Index_Temperatur]; + Regler_Tuer_Xp = F_Xp_Tuer; + + // --------------------- + // PID Regler Temperatur + // --------------------- + // F_PID PID_Temperature(...) + Regelabweichung_Temperatur = Sollwert_Temperatur - Istwert_Temperatur; + + // Zykluszeit Regelabweichung Temperatur + if (!Startup_finished || !is_valid(Standardregelabweichung_Temperatur) || + !is_valid(Standardgradient_Regelabweichung_Temperatur) || + Standardgradient_Regelabweichung_Temperatur <= 0.0) { + Zykluszeit_Regelabweichung_Temperatur = 600.0; + } else { + Zykluszeit_Regelabweichung_Temperatur = + limit(2.0 * 3.1415 * Standardregelabweichung_Temperatur / + Standardgradient_Regelabweichung_Temperatur * 60.0, + 120.0, 1200.0); + } + Zykluszeit_Regelabweichung_Heizung = + std::min(Zykluszeit_Regelabweichung_Temperatur, 300.0); + Zykluszeit_Regelabweichung_Kuehlung = + std::max(Zykluszeit_Regelabweichung_Temperatur, 600.0); + + Amplitude_Regelabweichung_Temperatur = + 1.4142 * Standardregelabweichung_Temperatur; + + // Mittelwert Regelabweichung Temperatur + if (!Startup_finished || !is_valid(Regelabweichung_Temperatur_Mittelwert) || + Temperatursprung) { + Regelabweichung_Temperatur_Mittelwert = 0.0; + } else if (is_valid(Regelabweichung_Temperatur)) { + const double alpha = + (Zykluszeit_Regelabweichung_Temperatur / sampling_time); + Regelabweichung_Temperatur_Mittelwert = limit( + Regelabweichung_Temperatur_Mittelwert + + (Regelabweichung_Temperatur - + Regelabweichung_Temperatur_Mittelwert) / + alpha, + Regelabweichung_Temperatur - 1.0, Regelabweichung_Temperatur + 1.0); + } + + // Standardregelabweichung Temperatur + if (!Startup_finished || !is_valid(Standardregelabweichung_Temperatur) || + Temperatursprung) { + Standardregelabweichung_Temperatur = 0.0; + } else if (is_valid(Regelabweichung_Temperatur)) { + const double n = (Zykluszeit_Regelabweichung_Temperatur / sampling_time); + Standardregelabweichung_Temperatur = std::min( + std::sqrt(((Regelabweichung_Temperatur - + Regelabweichung_Temperatur_Mittelwert) * + (Regelabweichung_Temperatur - + Regelabweichung_Temperatur_Mittelwert) + + Standardregelabweichung_Temperatur * + Standardregelabweichung_Temperatur * (n - 1.0)) / + n), + 1.0); + } + + // Gradient Regelabweichung Temperatur + // f_PID_Temperaure.GradientDifference(...) + if (!Startup_finished || !is_valid(Regelabweichung_Temperatur_Gradient)) { + Regelabweichung_Temperatur_Gradient = 0.0; + } else if (is_valid(Regelabweichung_Temperatur) && + is_valid(Regelabweichung_Temperatur_alt)) { + Regelabweichung_Temperatur_Gradient = limit( + Regelabweichung_Temperatur_Gradient + + ((Regelabweichung_Temperatur - Regelabweichung_Temperatur_alt) * + (60.0 / sampling_time) - + Regelabweichung_Temperatur_Gradient) / + (10.0 / sampling_time), + -4.0, 2.0); + } + + // Standardgradient Temperatur + // f_PID_Temperaure.StandardGradient(...) + if (!Startup_finished || + !is_valid(Standardgradient_Regelabweichung_Temperatur) || + Temperatursprung) { + Standardgradient_Regelabweichung_Temperatur = 0.0; + } else if (is_valid(Regelabweichung_Temperatur)) { + const double n = (Zykluszeit_Regelabweichung_Temperatur / sampling_time); + Standardgradient_Regelabweichung_Temperatur = + limit(std::sqrt((Regelabweichung_Temperatur_Gradient * + Regelabweichung_Temperatur_Gradient + + Standardgradient_Regelabweichung_Temperatur * + Standardgradient_Regelabweichung_Temperatur * + (n - 1.0)) / + n), + 0.01, 1.0); + } + + // Temperatursprung + // f_TemperatureJumpHandler(...) + if (!Startup_finished) { + Counter_Temperatursprung = 0.0; + } else if (((Sollwert_Temperatur != Sollwert_Temperatur_alt) && + (std::abs(Regelabweichung_Temperatur) > 1.0)) || + Tuer_offen) { + Counter_Temperatursprung = + std::max(Counter_Temperatursprung + sampling_time, 0.0); + } else if (Regelabweichung_Temperatur < + std::max(0.2, Amplitude_Regelabweichung_Temperatur) && + Regelabweichung_Temperatur > + -std::max(0.2, Amplitude_Regelabweichung_Temperatur)) { + Counter_Temperatursprung = + std::min(Counter_Temperatursprung - sampling_time, 0.0); + } else if (Regelabweichung_Temperatur > + std::max(0.5, 2.0 * Amplitude_Regelabweichung_Temperatur) || + Regelabweichung_Temperatur < + -std::max(0.5, 2.0 * Amplitude_Regelabweichung_Temperatur)) { + Counter_Temperatursprung = + std::max(Counter_Temperatursprung + sampling_time, -120.0); + } + Temperatursprung = (Counter_Temperatursprung > 0.0) || + (Temperatursprung && Counter_Temperatursprung > -60.0); + + // Anti-wind-up Heizung (dynamisches Clamping) + // ------ F_PID_Temperatuer.AntiWindUpHeater(...) + if ((Counter_Tuer_geschlossen < 180.0) || (Counter_Tuer_offen > 0.0)) { + Regler_Heizung_MIN = 0.0; + Regler_Heizung_I_Anteil_MIN = 0.0; + Regler_Heizung_MAX = 100.0; + Regler_Heizung_I_Anteil_MAX = + limit(100.0 - P_Anteil_Heizung, Regler_Heizung_I_Anteil_MIN, + Stellgrad_Heizung_Mittelwert); + } else { + Regler_Heizung_MIN = 0.0; + Regler_Heizung_I_Anteil_MIN = 0.0; + Regler_Heizung_MAX = 100.0; + if (Temperatursprung) { + Regler_Heizung_I_Anteil_MAX = + limit(100.0 - P_Anteil_Heizung, Regler_Heizung_I_Anteil_MIN, + Regler_Heizung_MAX); + } else { + Regler_Heizung_I_Anteil_MAX = 100.0; + } + } + //---------------------- + + // Anpassung Xp Heizung + // // ------------F_PID_Temperatuer.AdaptXp(...) + if (Regelabweichung_Temperatur > Amplitude_Regelabweichung_Temperatur && + Regelabweichung_Temperatur_Mittelwert > 0.05 && !Temperatursprung) { + Regler_Heizung_Xp /= 2.0; + } + // Achtung: du referenzierst hier Zykluszeit_Regelabweichung_Feuchte später + // – steht unten. Wir setzen default, falls noch uninitialisiert: + if (!is_valid(Zykluszeit_Regelabweichung_Feuchte) || + Zykluszeit_Regelabweichung_Feuchte <= 0.0) { + Zykluszeit_Regelabweichung_Feuchte = 600.0; + } + + Regler_Heizung_Xp = + Regler_Heizung_Xp * + limit(Zykluszeit_Regelabweichung_Feuchte / 300.0, 1.0, 2.0) * + limit(1.0 + Amplitude_Regelabweichung_Temperatur / 0.5 + + Stellgrad_Kuehlung_Mittelwert / -100.0, + 1.0, 2.0); +//-----------// ------------F_PID_Temperatuer.AdaptXp(...)--------------------------------------------------- + + // P/I/D Heizung + //----------------- F_PID_Temperature.step(...) + if (!Startup_finished || !is_valid(Regelabweichung_Temperatur)) { + P_Anteil_Heizung = 0.0; + } else { + P_Anteil_Heizung = 100.0 / Regler_Heizung_Xp * Regelabweichung_Temperatur; + } + + if (!Startup_finished || !is_valid(I_Anteil_Heizung)) { + I_Anteil_Heizung = 0.0; + } else if (!Regelung_AUS && is_valid(Regelabweichung_Temperatur) && + Counter_Tuer_geschlossen > 60.0) { + I_Anteil_Heizung = limit( + I_Anteil_Heizung + 100.0 / Regler_Heizung_Xp / + (1.0 * Zykluszeit_Regelabweichung_Heizung) * + sampling_time * Regelabweichung_Temperatur, + Regler_Heizung_I_Anteil_MIN, Regler_Heizung_I_Anteil_MAX); + } + + if (!Startup_finished || !is_valid(D_Anteil_Heizung)) { + D_Anteil_Heizung = 0.0; + } else if (is_valid(Regelabweichung_Temperatur) && + is_valid(Regelabweichung_Temperatur_alt) && + Counter_Tuer_geschlossen > 0.0) { + D_Anteil_Heizung = + D_Anteil_Heizung + + (100.0 / Regler_Heizung_Xp * + (0.1 * Zykluszeit_Regelabweichung_Heizung) * + (Regelabweichung_Temperatur - Regelabweichung_Temperatur_alt) / + sampling_time - + D_Anteil_Heizung) / + (Tau_Heizung_Tv / sampling_time); + } + + if (Counter_Tuer_offen > 60.0 || Regelung_AUS || !Startup_finished) { + Stellgrad_Heizung = 0.0; + } else { + Stellgrad_Heizung = + limit(P_Anteil_Heizung + I_Anteil_Heizung + D_Anteil_Heizung, + Regler_Heizung_MIN, Regler_Heizung_MAX); + } + + if (!Startup_finished || !is_valid(Stellgrad_Heizung_Mittelwert)) { + Stellgrad_Heizung_Mittelwert = 0.0; + } else if (Temperatursprung) { + Stellgrad_Heizung_Mittelwert = Stellgrad_Heizung; + } else if (is_valid(Stellgrad_Heizung)) { + Stellgrad_Heizung_Mittelwert = + Stellgrad_Heizung_Mittelwert + + (Stellgrad_Heizung - Stellgrad_Heizung_Mittelwert) / + (Zykluszeit_Regelabweichung_Temperatur / sampling_time); + } + + + // ------------ F_PID_Temperature.step(...) !!!!! todo uj umbenennen in Heizung !!!!!!!!!!!!!!!!!!! + + + // ---------------------------------------------------- + // Ab hier: Kühlung + Feuchte-PIDs + Tür-PID + Aktorlogik + // ---------------------------------------------------- + // => in gleicher Art übersetzen (Muster ist identisch). + // + // Für dieses Snippet: wir übernehmen für die Outputs zumindest die Werte, + // die schon berechnet sind, und lassen Stellgrade der restlichen Aktoren, + // falls nicht berechnet, auf gültigen Default stehen. + + // Regelabweichung Kühlung + // F_ PID PID_Cooling() + double Regelabweichung_Kuehlung = Regelabweichung_Temperatur; + + // Gradient Regelabweichgun Kuehlung + + if (!Startup_finished) { + Regelabweichung_Kuehlung_Gradient = 0.0; + + } else { + Regelabweichung_Kuehlung_Gradient = + limit((Regelabweichung_Kuehlung - Regelabweichung_Kuehlung_alt) * + 60.0 / sampling_time - + Regelabweichung_Kuehlung_Gradient, + -4.0, 2.0); + } + + // Faktor Kuehlung + + if (!Startup_finished || Temperatursprung) { + Faktor_Kuehlung = 5.0; + } else if (Regelabweichung_Kuehlung < -0.1) { + Faktor_Kuehlung = std::min(Faktor_Kuehlung + sampling_time, 5.0); + } else { + Faktor_Kuehlung = std::max(Faktor_Kuehlung - sampling_time / 60.0, 0.2); + } + + // --------------------------- Gegenheizen Band !!! Überwacher !!!!! + double Regelabweichung_Entfeuchtung = Regelabweichung_Feuchte; + if (!Startup_finished || Temperatursprung || + (Counter_Temperatursprung > -600.0 && + Faktor_Gegenheizen_Band == 10.0)) { + Faktor_Gegenheizen_Band = 10.0; + + } else if (Stellgrad_Heizung_Mittelwert - Sollwert_Gegenheizen < -1.0) { + if (Regelabweichung_Entfeuchtung > 0.5) { + Faktor_Gegenheizen_Band = + std::max(Faktor_Gegenheizen_Band - sampling_time / 10.0, 0.0); + } else { + Faktor_Gegenheizen_Band = + std::min(Faktor_Gegenheizen_Band + sampling_time / 60.0, 10.0); + } + + } else if (Stellgrad_Heizung_Mittelwert - Sollwert_Gegenheizen > 1.0 && + Stellgrad_Kuehlung_Mittelwert < -5.0) { + if (Regelabweichung_Entfeuchtung < -0.5) { + Faktor_Gegenheizen_Band = + std::max(Faktor_Gegenheizen_Band - sampling_time / 10.0, 0.0); + } else { + Faktor_Gegenheizen_Band = + std::min(Faktor_Gegenheizen_Band + sampling_time / 600.0, 5.0); + } + } + else { + Faktor_Gegenheizen_Band = + std::max(Faktor_Gegenheizen_Band - sampling_time / 60.0, 0.1); + } + // --------------------------- Gegenheizen Band + + // -----------------------Sollwert Gegenheizen für I-Anteilverschiebung + + double Faktor_Entfeuchtung_Kuehlung = 0.0; + double Offset_Kuehlung = Faktor_Entfeuchtung_Kuehlung; + Offset_Kuehlung = + Faktor_Entfeuchtung_Kuehlung * Stellgrad_Entfeuchtung_Mittelwert * + std::max((50.0 - Stellgrad_Heizung_Mittelwert) / (50 - 0.0), 0.0) * + (8.0 - Stellgrad_Befeuchtung_Standby) / (8.0 - 2.0); +//------------------------------------------------------------ + + + // P-Anteil Kühlung + // f_PID_Cooling.SetP + double P_Anteil_Kuehlung = 0.0; + if (!Startup_finished) { + P_Anteil_Kuehlung = 0.0; + } else { + P_Anteil_Kuehlung = 100.0 / Regler_Kuehlung_Xp * Faktor_Kuehlung * + Regelabweichung_Kuehlung; + } + + // Begrenzung I-Anteil Kühlung bei Türöffnung + // f_PID_Cooling.Limit_I_PostDoorOpening(...) + double Regler_Kuehlung_MAX = 0; + double Regler_Kuehlung_MIN = 0; + double Regler_Kuehlung_I_Anteil_MAX = 0; + double Regler_Kuehlung_I_Anteil_MIN = 0; + + if ((Counter_Tuer_geschlossen < 180.0) || (Counter_Tuer_offen > 0.0)) { + Regler_Kuehlung_MAX = I_Anteil_Kuehlung; + Regler_Kuehlung_MIN = -100.0; + Regler_Kuehlung_I_Anteil_MAX = I_Anteil_Kuehlung; + Regler_Kuehlung_I_Anteil_MIN = limit( -100.0 - P_Anteil_Kuehlung, Regler_Kuehlung_MIN, Regler_Kuehlung_MAX); + } else { + Regler_Kuehlung_MAX = 0.0; + Regler_Kuehlung_MIN = -100.0; + Regler_Kuehlung_I_Anteil_MAX = 0.1 / Regler_Kuehlung_Xp * 100.0; + Regler_Kuehlung_I_Anteil_MIN = limit( -100.0 - P_Anteil_Kuehlung + Regelabweichung_Kuehlung_Gradient / 0.5 * 100.0, + Regler_Kuehlung_MIN, + Regler_Kuehlung_MAX); + } + + // f_PID_Cooling.Step(...) + // I Anteil Kühlung + if (!Startup_finished) { + I_Anteil_Kuehlung = 0.0; + } else if (Counter_Tuer_geschlossen > 60.0) { + I_Anteil_Kuehlung = + limit(I_Anteil_Kuehlung + + 100.0 / Regler_Kuehlung_Tn * sampling_time * + (Regelabweichung_Kuehlung + + (Stellgrad_Heizung - Sollwert_Gegenheizen) / 100.0 * + Regler_Heizung_Xp * Theta_I_Kuehlung * + Faktor_Gegenheizen_Band), + Regler_Kuehlung_I_Anteil_MIN, Regler_Kuehlung_I_Anteil_MAX); + } + + // D-Anteil Kühlung + + if (!Startup_finished) { + D_Anteil_Kuehlung = 0.0; + } else if (Counter_Tuer_geschlossen > 0.0) { + D_Anteil_Kuehlung += + (100.0 / Regler_Kuehlung_Xp * Regler_Kuehlung_Tv * + (Regelabweichung_Kuehlung - Regelabweichung_Kuehlung_alt) / + sampling_time - + D_Anteil_Kuehlung) / + (Tau_Kuehlung_Tv / sampling_time); + } + + // Berechnung Stellgrad Kühlung + // f_ + if (Counter_Tuer_offen > 60.0 || !Startup_finished) { + Stellgrad_Kuehlung = 0.0; + } else { + Stellgrad_Kuehlung = limit(P_Anteil_Kuehlung + I_Anteil_Kuehlung + + D_Anteil_Kuehlung + Offset_Kuehlung, + Regler_Kuehlung_MIN, Regler_Kuehlung_MAX); + } + + // Berechnung Stellgrad Mittelwert + + if (!Startup_finished) { + Stellgrad_Kuehlung_Mittelwert = 0.0; + } else { + Stellgrad_Kuehlung_Mittelwert = + limit(Stellgrad_Kuehlung_Mittelwert + + (Stellgrad_Kuehlung - Stellgrad_Kuehlung_Mittelwert) / + (600.0 / sampling_time), + Stellgrad_Kuehlung - 0.5 * 100.0 * Regler_Kuehlung_Xp, + Stellgrad_Kuehlung + 0.5 * 100.0 / Regler_Kuehlung_Xp); + } + // ------------------- F_ PID PID_Cooling() + + + // PID Regler Feuchte + // f_PID_Humidiy + Regelabweichung_Feuchte = Sollwert_Feuchte_Absolut - Istwert_Feuchte; + + // Berechnung Regelabweichung Feuchte Mittelwert + if (!Startup_finished) { + Regelabweichung_Feuchte_Mittelwert = 0.0; + } else { + Regelabweichung_Feuchte_Mittelwert = limit( + Regelabweichung_Feuchte_Mittelwert + + (Regelabweichung_Feuchte - Regelabweichung_Feuchte_Mittelwert) / + (60.0 / sampling_time), + Regelabweichung_Feuchte - 10.0, Regelabweichung_Feuchte + 10.0); + } + + // Feuchtesprung + // f_PID_Hunidity.HandleJump(...) + if (!Startup_finished) { + Counter_Feuchtesprung = 0.0; + } else if (Sollwert_Feuchte != Sollwert_Feuchte_alt && + std::abs(Regelabweichung_Feuchte) > 2.0) { + Counter_Feuchtesprung = + std::max(Counter_Feuchtesprung + sampling_time, 0.0); + } else if (std::abs(Regelabweichung_Feuchte) < 2.0 || + std::abs(Regelabweichung_Feuchte_Mittelwert) < 2.0) { + Counter_Feuchtesprung = + std::min(Counter_Feuchtesprung - sampling_time, 0.0); + } else if (std::abs(Regelabweichung_Feuchte_Mittelwert) > 5.0) { + Counter_Feuchtesprung = + std::max(Counter_Feuchtesprung + sampling_time, -120.0); + } + + Feuchtesprung = (Counter_Feuchtesprung > 0.0 || + (Feuchtesprung && Counter_Feuchtesprung > -120.0)); + + // Regelabweichung Befeuchtung + + double Regelabweichung_Befeuchtung = Regelabweichung_Feuchte; + + // Gradient regelabweichung Feuchte + + if (!Startup_finished) { + Regelabweichung_Befeuchtung_Gradient = 0.0; + } else { + Regelabweichung_Befeuchtung_Gradient = limit( + Regelabweichung_Befeuchtung_Gradient + + ((Regelabweichung_Befeuchtung - Regelabweichung_Befeuchtung_alt) * + 60.0 / sampling_time - + Regelabweichung_Befeuchtung_Gradient) / + 60.0 * sampling_time, + -20.0, 5.0); + } + + // Begrenzung I-Anteil bei Türöffnung + double Regler_Befeuchtung_MIN = 0.0; + double Regler_Befeuchtung_MAX = 0.0; + double Regler_Befeuchtung_I_Anteil_MIN = 0.0; + double Regler_Befeuchtung_I_Anteil_MAX = 0.0; + + if ((Counter_Tuer_geschlossen < 180.0) || (Counter_Tuer_offen > 0.0)) { + Regler_Befeuchtung_MIN = + std::max(Stellgrad_Befeuchtung_Standby - 2.0, Standby_Feuchtemodul); + Regler_Befeuchtung_MAX = std::min(100.0, Stellgrad_Feuchtemodul_MAX); + Regler_Befeuchtung_I_Anteil_MIN = 0.0; + Regler_Befeuchtung_I_Anteil_MAX = + limit(100.0 - P_Anteil_Befeuchtung, Regler_Befeuchtung_I_Anteil_MIN, + Stellgrad_Befeuchtung_Mittelwert); + } else { + if (Feuchtesprung) { + Regler_Befeuchtung_MIN = + std::max(Stellgrad_Befeuchtung_Standby - 2.0, Standby_Feuchtemodul); + } else { + Regler_Befeuchtung_MIN = + std::max(std::min(Stellgrad_Befeuchtung_Standby + + 0.25 * P_Anteil_Befeuchtung + + D_Anteil_Befeuchtung + Z_Anteil_Befeuchtung, + Stellgrad_Befeuchtung_Standby + 2.0), + std::max(Stellgrad_Befeuchtung_Standby - 1.0, + Standby_Feuchtemodul)); + } + Regler_Befeuchtung_MAX = std::min(100.0, Stellgrad_Feuchtemodul_MAX); + Regler_Befeuchtung_I_Anteil_MIN = 0.0; + Regler_Befeuchtung_I_Anteil_MAX = + limit(100.0, Regler_Befeuchtung_I_Anteil_MIN, + Stellgrad_Befeuchtung_Mittelwert); + } + + // Anteil P-Anteil Befeuchtung bei Feuchtesprung und Türöffnung + + if (Counter_Tuer_geschlossen < 180.0 && Feuchtesprung) { + Regler_Befeuchtung_Xp = Regler_Befeuchtung_Xp * 2.0; + } else if (Counter_Tuer_geschlossen > 300.0 && Feuchtesprung) { + Regler_Befeuchtung_Xp = Regler_Befeuchtung_Xp / 2.0; + } else { + Regler_Befeuchtung_Xp = + Regler_Befeuchtung_Xp * + (1.0 + Stellgrad_Entfeuchtung_Mittelwert / -100.0); + } + + // P-Anteil Befeuchtung + + if (!Startup_finished) { + P_Anteil_Befeuchtung = 0.0; + } + + else { + P_Anteil_Befeuchtung = + 100.0 / Regler_Befeuchtung_Xp * Regelabweichung_Befeuchtung; + } + + // I-Anteil Befeuchtung + + if (!Startup_finished) { + I_Anteil_Befeuchtung = 0.0; + } else if (Counter_Tuer_geschlossen > 60.0) { + I_Anteil_Befeuchtung = limit( + I_Anteil_Befeuchtung + 100.0 / Regler_Befeuchtung_Xp / + Regler_Befeuchtung_Tn * sampling_time * + Regelabweichung_Befeuchtung, + Regler_Befeuchtung_I_Anteil_MIN, Regler_Befeuchtung_I_Anteil_MAX); + } + + // D-Anteil Befeuchtung + if (!Startup_finished) { + D_Anteil_Befeuchtung = 0.0; + } else if (Counter_Tuer_geschlossen) { + D_Anteil_Befeuchtung += + (100.0 / Regler_Befeuchtung_Xp * Regler_Befeuchtung_Tv * + (Regelabweichung_Befeuchtung - Regelabweichung_Befeuchtung_alt) / + sampling_time - + D_Anteil_Befeuchtung) / + (Tau_Befeuchtung_Tv / sampling_time); + } + + // Z-Anteil Befeuchtung + + if (!Startup_finished || Feuchtesprung) { + Z_Anteil_Befeuchtung = 0.0; + } else if (Counter_Tuer_geschlossen > 0.0) { + Z_Anteil_Befeuchtung += + (100.0 / Regler_Befeuchtung_Xp * Regler_Befeuchtung_Tz * + ((Regelabweichung_Befeuchtung - + Regelabweichung_Befeuchtung_alt) - + (Regelabweichung_Befeuchtung_alt - + Regelabweichung_Befeuchtung_alt_alt)) / + sampling_time - + Z_Anteil_Befeuchtung) / + (Tau_Befeuchtung_Tz / sampling_time); + } + // Regler_Befeuchtung_MAX = 10.0; + // Berechnung Stellgrad Befeuchtung + if (Counter_Tuer_offen > 60.0 || !Startup_finished) { + Stellgrad_Befeuchtung = 0.0; + } else { + Stellgrad_Befeuchtung = + limit(P_Anteil_Befeuchtung + I_Anteil_Befeuchtung + + D_Anteil_Befeuchtung + Z_Anteil_Befeuchtung, + Regler_Befeuchtung_MIN, Regler_Befeuchtung_MAX); + } + + // Berechnung Stellgrad befeuchtung Mittelwert + + if (!Startup_finished) { + Stellgrad_Befeuchtung_Mittelwert = 0.0; + } else { + Stellgrad_Befeuchtung_Mittelwert = + limit(Stellgrad_Befeuchtung_Mittelwert + + (Stellgrad_Befeuchtung - Stellgrad_Befeuchtung_Mittelwert) / + (600.0 / sampling_time), + Stellgrad_Befeuchtung - 5.0 * 100.0 / Regler_Befeuchtung_Xp, + Stellgrad_Befeuchtung + 5.0 * 100.0 / Regler_Befeuchtung_Xp); + } + + if (!Startup_finished) { + Stellgrad_Befeuchtung_Standby = 4.0; + } else if (!(Feuchtesprung && Counter_Feuchtesprung < 300.0)) { + Stellgrad_Befeuchtung_Standby = + limit(Stellgrad_Befeuchtung_Standby + + (Stellgrad_Befeuchtung - Stellgrad_Befeuchtung_Standby) / + (600.0 / sampling_time), + 2.0, 8.0); + } + + // Regelabweichung Entfeuchtung + + Regelabweichung_Entfeuchtung = Regelabweichung_Feuchte; + + // Gradient Regelabweichung Entfeuchtung + + if (!Startup_finished) { + Regelabweichung_Entfeuchtung_Gradient = 0.0; + } + + else { + Regelabweichung_Entfeuchtung_Gradient = + limit(Regelabweichung_Entfeuchtung_Gradient + + ((Regelabweichung_Entfeuchtung - + Regelabweichung_Entfeuchtung_alt) * + 60.0 / sampling_time - + Regelabweichung_Entfeuchtung_Gradient) / + 60.0 * sampling_time, + -20.0, 5.0); + } + + // Faktor Entfeuchtung + + if (!Startup_finished) { + Faktor_Entfeuchtung = 5.0; + } else if (Regelabweichung_Entfeuchtung < -0.5) { + Faktor_Entfeuchtung = + std::min(Faktor_Entfeuchtung + sampling_time / 60.0, 5.0); + } else { + Faktor_Entfeuchtung = std::max(Faktor_Entfeuchtung - sampling_time, 0.2); + } + + // Gegenbefeuchten Band + + if (!Startup_finished || Feuchtesprung || + (Counter_Feuchtesprung > -600.0 && + Faktor_Gegenbefeuchten_Band == 5.0)) { + Faktor_Gegenbefeuchten_Band = 5.0; + } else if (Stellgrad_Befeuchtung_Mittelwert - Sollwert_Gegenbefeuchten < + -1.0) { + if (Regelabweichung_Kuehlung > 0.05) { + Faktor_Gegenbefeuchten_Band = + std::max(Faktor_Gegenbefeuchten_Band - sampling_time / 10.0, 0.0); + } else { + Faktor_Gegenbefeuchten_Band = + std::min(Faktor_Gegenbefeuchten_Band + sampling_time / 60.0, 5.0); + } + + } else if (Stellgrad_Befeuchtung_Mittelwert - Sollwert_Gegenbefeuchten > + 1.0 && + Stellgrad_Entfeuchtung_Mittelwert < -10.0) { + if (Regelabweichung_Kuehlung < -0.05) { + Faktor_Gegenbefeuchten_Band = + std::max(Faktor_Gegenbefeuchten_Band - sampling_time / 10.0, 0.0); + } else { + Faktor_Gegenbefeuchten_Band = + std::min(Faktor_Gegenbefeuchten_Band + sampling_time / 600.0, 2.0); + } + } else { + Faktor_Gegenbefeuchten_Band = + std::max(Faktor_Gegenbefeuchten_Band - sampling_time / 60.0, 0.2); + } + + // Sollwert Gegenbefeuchten für I-Anteilverschiebung + + Sollwert_Gegenbefeuchten = + 6.0 - 4.0 * (-Stellgrad_Entfeuchtung_Mittelwert / 100.0); + double Offset_Entfeuchtung = 0.0 * Stellgrad_Kuehlung_Mittelwert; + + //(* P-Anteil Entfeuchtung *) + + double P_Anteil_Entfeuchtung = 0.0; + if (!Startup_finished) { + P_Anteil_Entfeuchtung = 0.0; + } else { + P_Anteil_Entfeuchtung = 100.0 / Regler_Entfeuchtung_Xp * + Faktor_Entfeuchtung * + Regelabweichung_Entfeuchtung; + } + // I-Anteil Entfeuchtung + if (!Startup_finished) { + I_Anteil_Entfeuchtung = 0.0; + } else if (Counter_Tuer_geschlossen > 60.0) { + I_Anteil_Entfeuchtung = limit( + I_Anteil_Entfeuchtung + + 100.0 / Regler_Entfeuchtung_Xp / Regler_Entfeuchtung_Tn * + sampling_time * + (Regelabweichung_Entfeuchtung + + (Stellgrad_Befeuchtung - Sollwert_Gegenbefeuchten) / 100.0 * + Regler_Befeuchtung_Xp * Theta_I_Entfeuchtung * + Faktor_Gegenbefeuchten_Band), + Regler_Entfeuchtung_I_Anteil_MIN, Regler_Entfeuchtung_I_Anteil_MAX); + } + // D-Anteil Entfeuchtung + if (!Startup_finished) { + D_Anteil_Entfeuchtung = 0.0; + } else if (Counter_Tuer_geschlossen > 0.0) { + D_Anteil_Entfeuchtung = + D_Anteil_Entfeuchtung + + (100.0 / Regler_Entfeuchtung_Xp * Regler_Entfeuchtung_Tv * + (Regelabweichung_Entfeuchtung - + Regelabweichung_Entfeuchtung_alt) / + sampling_time - + D_Anteil_Entfeuchtung) / + (Tau_Entfeuchtung_Tv / sampling_time); + } + + // Begrenzung Stellgrad und I-Anteil + + if ((Counter_Tuer_geschlossen < 180.0) || (Counter_Tuer_offen > 0.0)) { + Regler_Entfeuchtung_MAX = I_Anteil_Entfeuchtung; + Regler_Entfeuchtung_MIN = -100.0; + Regler_Entfeuchtung_I_Anteil_MAX = I_Anteil_Entfeuchtung; + Regler_Entfeuchtung_I_Anteil_MIN = + limit(-100.0 - P_Anteil_Entfeuchtung, Regler_Entfeuchtung_MIN, + Regler_Entfeuchtung_I_Anteil_MAX); + } else { + Regler_Entfeuchtung_MAX = 0.0; + Regler_Entfeuchtung_MIN = -100.0; + Regler_Entfeuchtung_I_Anteil_MAX = 1.5 / Regler_Entfeuchtung_Xp * 100.0; + Regler_Entfeuchtung_I_Anteil_MIN = + limit(-100.0 - P_Anteil_Entfeuchtung + + Regelabweichung_Entfeuchtung_Gradient / 20.0 * 100.0, + Regler_Entfeuchtung_MIN, Regler_Entfeuchtung_I_Anteil_MAX); + } + + // Berechnung Stellgrad Entfeuchtung + + if (Counter_Tuer_offen > 60.0 || !Startup_finished) { + Stellgrad_Entfeuchtung = 0.0; + } else { + Stellgrad_Entfeuchtung = + limit(P_Anteil_Entfeuchtung + I_Anteil_Entfeuchtung + + Offset_Entfeuchtung + D_Anteil_Entfeuchtung, + Regler_Entfeuchtung_MIN, Regler_Entfeuchtung_MAX); + } + + // Berechnung Stellgrad entfeuchtung Mittelwert + + if (!Startup_finished) { + Stellgrad_Entfeuchtung_Mittelwert = 0.0; + } else { + Stellgrad_Entfeuchtung_Mittelwert = limit( + Stellgrad_Entfeuchtung_Mittelwert + + (Stellgrad_Entfeuchtung - Stellgrad_Entfeuchtung_Mittelwert) / + (600.0 / sampling_time), + Stellgrad_Entfeuchtung - 5.0 * 100.0 / Regler_Entfeuchtung_Xp, + Stellgrad_Entfeuchtung + 5.0 * 100.0 / Regler_Entfeuchtung_Xp); + } + + // PID Regler Tür + // f_PID_Door(...) + double Offset_Temperatur_Tuer; + if (Feuchtesprung) { + Offset_Temperatur_Tuer = 0.0; + } else { + Offset_Temperatur_Tuer = + 2.0 * Betauungsschutz / 100.0 * + limit((90.0 + Stellgrad_Kuehlung_Mittelwert) / (90.0 - 80.0), 0.0, + 1.0); + } + + // Regelabweichung + if (!Tuer_offen || + std::abs(Regelabweichung_Tuer) > + std::abs(Sollwert_Temperatur + Offset_Temperatur_Tuer - + Istwert_Temperatur_Tuer)) { + Regelabweichung_Tuer = Sollwert_Temperatur + Offset_Temperatur_Tuer - + Istwert_Temperatur_Tuer; + } + + // P-Anteil + + // Anti-Windup über dynamisches Integrator Clamping + + double Regler_Tuer_MAX = limit( + (100.0 + Stellgrad_Kuehlung) / (100.0 - 80.0) * 100.0, 0.0, 100.0); + double Regler_Tuer_MIN = 0.0; + double Regler_Tuer_I_Anteil_MAX = + limit(100.0 - P_Anteil_Tuer, 0.0, Regler_Tuer_MAX); + double Regler_Tuer_I_Anteil_MIN = 0.0; + + if (!Startup_finished) { + P_Anteil_Tuer = 0.0; + } else { + P_Anteil_Tuer = 100.0 / Regler_Tuer_Xp * Regelabweichung_Tuer; + } + + // I-Anteil + if (!Startup_finished) { + I_Anteil_Tuer = 0.0; + } else if (Temperatursprung && Regelabweichung_Tuer > 0.0) { + I_Anteil_Tuer = limit(I_Anteil_Tuer, Regler_Tuer_I_Anteil_MIN, + Regler_Tuer_I_Anteil_MAX); + } else if (!Tuer_offen) { + I_Anteil_Tuer = + limit(I_Anteil_Tuer + 100.0 / Regler_Tuer_Xp / Regler_Tuer_Tn * + sampling_time * Regelabweichung_Tuer, + Regler_Tuer_I_Anteil_MIN, Regler_Tuer_I_Anteil_MAX); + } + // D-Anteil + + if (!Startup_finished) { + D_Anteil_Tuer = 0.0; + } else { + D_Anteil_Tuer = D_Anteil_Tuer + + (100.0 / Regler_Tuer_Xp * Regler_Tuer_Tv * + (Regelabweichung_Tuer - Regelabweichung_Tuer_alt) / + sampling_time - + D_Anteil_Tuer) / + (Tau_Tuer_Tv / sampling_time); + } + + double Stellgrad_Tuer; + // Berechnung Stellgrad Tür + if (Tuer_offen || !Startup_finished) { + Stellgrad_Tuer = limit(P_Anteil_Tuer + I_Anteil_Tuer + D_Anteil_Tuer, + Regler_Tuer_MIN, Regler_Tuer_MAX); + } + + // Kennfelder Kühlung/Entfeuchtung + + int Index_Ueberhitzung = 1; + while (Kennfeld_Ueberhitzung[0][Index_Ueberhitzung] < Istwert_Temperatur && + Index_Ueberhitzung < 12) { + Index_Ueberhitzung++; + } + double Interpolation_Ueberhitzung = limit((Kennfeld_Ueberhitzung[0][Index_Ueberhitzung - 1] - Istwert_Temperatur) / + (Kennfeld_Ueberhitzung[0][Index_Ueberhitzung - 1] - Kennfeld_Ueberhitzung[0][Index_Ueberhitzung]), + 0.0, 1.0); + double Skalierung_Ueberhitzung_Kennfeld_Min = Kennfeld_Ueberhitzung[1][Index_Ueberhitzung] * + (Interpolation_Ueberhitzung + Kennfeld_Ueberhitzung[1][Index_Ueberhitzung - 1]) * + (1.0 - Interpolation_Ueberhitzung); + double Skalierung_Ueberhitzung_Kennfeld_Max = Kennfeld_Ueberhitzung[2][Index_Ueberhitzung] * + (Interpolation_Ueberhitzung + Kennfeld_Ueberhitzung[2][Index_Ueberhitzung - 1]) * + (1.0 - Interpolation_Ueberhitzung); + double Sollwert_Ueberhitzung = Kennfeld_Ueberhitzung[3][Index_Ueberhitzung] * + (Interpolation_Ueberhitzung + Kennfeld_Ueberhitzung[3][Index_Ueberhitzung - 1]) * + (1.0 - Interpolation_Ueberhitzung); + + //(* Entfeuchtung und Abtauung aus Kennfeld *) + int Index_Entfeuchtung = 1; // todo uj - warum nicht mit 0 starten? + while ((Kennfeld_Entfeuchtung[0][Index_Entfeuchtung] < Istwert_Temperatur) && (Index_Ueberhitzung < 12)) { + Index_Entfeuchtung++; + } + double Interpolation_Entfeuchtung = limit((Kennfeld_Entfeuchtung[0][Index_Entfeuchtung - 1] - + (Istwert_Temperatur) / (Kennfeld_Entfeuchtung[0][Index_Entfeuchtung - 1] ) - + Kennfeld_Entfeuchtung[0][Index_Entfeuchtung]), + 0.0, 1.0); + double Skalierung_Entfeuchtungsventil = Kennfeld_Entfeuchtung[1][Index_Entfeuchtung] * + Interpolation_Entfeuchtung + + Kennfeld_Entfeuchtung[1][Index_Entfeuchtung - 1] * + (1.0 - Interpolation_Entfeuchtung); + double Abtauzyklus_Pause = + Kennfeld_Entfeuchtung[2][Index_Entfeuchtung] * + Interpolation_Entfeuchtung + + Kennfeld_Entfeuchtung[2][Index_Entfeuchtung - 1] * + (1.0 - Interpolation_Entfeuchtung); + double Abtauzyklus_Dauer = + Kennfeld_Entfeuchtung[3][Index_Entfeuchtung] * + Interpolation_Entfeuchtung + + Kennfeld_Entfeuchtung[3][Index_Entfeuchtung - 1] * + (1.0 - Interpolation_Entfeuchtung); + + // Ende - f_PID_Door(...) + + // Überhitzungsregelung + + // Temperatur Verdampferausgang PT1 + // f_PT1.Vapourize(...) + if (!Startup_finished) { + Istwert_Temperatur_Verdampferausgang_PT1 = + Istwert_Temperatur_Verdampferausgang; + } else { + Istwert_Temperatur_Verdampferausgang_PT1 += + (Istwert_Temperatur_Verdampferausgang - + Istwert_Temperatur_Verdampferausgang_PT1) / + (60.0 * 4.0); + } + + // Skalierung Überhitzung + if (Istwert_Temperatur_Verdampferausgang < + (Istwert_Temperatur + Sollwert_Ueberhitzung)) { + Counter_Durchzug = MIN(Counter_Durchzug + sampling_time, 10.0); + } else { + // uj-todo; template for MAX + // Counter_Durchzug = MAX(MAX(Counter_Durchzug-sampling_time,-10),0); + } + if (Counter_Durchzug >= 10.0) { + Durchzug = true; + } else if (Counter_Durchzug <= -10.0) { + Durchzug = false; + } + + double Skalierung_Ueberhitzung_PT1 = Skalierung_Ueberhitzung_Kennfeld_Max; + + // Magnetventil Kühlung + + // Stellgrad Kühlung + + if (Counter_Verdichter_aus > 60.0 && Counter_Verdichter_aus < 600.0) { + Stellgrad_Kuehlventil = 1.0; + } else if (Istwert_Temperatur > 120.0 || Counter_Kuehlung_Freigabe <= 0.0) { + Stellgrad_Kuehlventil = 0.0; + } else { + Stellgrad_Kuehlventil = MAX(-Stellgrad_Kuehlung, 0.0) * + Skalierung_Ueberhitzung_PT1 * + Counter_Kuehlung_Freigabe; + } + + // Ende - f_PT1.Vapourize(...) + + // PWM Generierung Kuehlventil + // bool step(double Stellgrad,double sampling_time){ + + // f_PWMCoolingValve.Step(...) + Kuehlventil = PWM_Kuehlventil.step(Stellgrad_Kuehlventil, sampling_time); + + // Magnetventil Entfeuchtung + double T_Entfeuchtung; + if (!Startup_finished) { + T_Entfeuchtung = Istwert_Temperatur; + } else if (Entfeuchtungsventil) { + T_Entfeuchtung = + limit(T_Entfeuchtung + + ((Istwert_Temperatur - T_Entfeuchtung) * U_Entfeuchtung - + P_Entfeuchtung) / + (4.0 * C_Entfeuchtung), + -30.0, Istwert_Temperatur); + } else { + T_Entfeuchtung = + limit(T_Entfeuchtung + + ((Istwert_Temperatur - T_Entfeuchtung) * U_Entfeuchtung) / + (4.0 * C_Entfeuchtung), + -30.0, Istwert_Temperatur); + } + // Stellgrad Entfeuchtung + + if (Istwert_Temperatur > 120.0 || Counter_Entfeuchtung_Freigabe <= 0.0) { + Stellgrad_Entfeuchtungsventil = 0.0; + } else { + Stellgrad_Entfeuchtungsventil = MAX(-Stellgrad_Entfeuchtung, 0.0) * + Skalierung_Entfeuchtungsventil * + Counter_Entfeuchtung_Freigabe; + } + + // Abtauzyklus + bool Freigabe_Abtauzyklus = + Istwert_Feuchte > Sollwert_Feuchte_Absolut + 2.5; + if (!Freigabe_Abtauzyklus) { + Counter_Freigabe_Abtauzyklus = 0.0; + } else { + Counter_Freigabe_Abtauzyklus += sampling_time; + } + double Skalierung_Abtauzyklus_Dauer = 0.0; + ; + if (Abtauzyklus_Pause > 0.0 && Abtauzyklus_Dauer > 0.0) { + Skalierung_Abtauzyklus_Dauer = + limit(Counter_Freigabe_Abtauzyklus / + (10.0 * (Abtauzyklus_Pause + Abtauzyklus_Dauer) * 60.0), + 1.0, 5.0); + } + if (Counter_Abtauzyklus > + (Abtauzyklus_Pause + Abtauzyklus_Dauer * Skalierung_Abtauzyklus_Dauer) * + 60.0) { + Counter_Abtauzyklus = 0.0; + } else if ((T_Entfeuchtung < 0.0 && Freigabe_Abtauzyklus) || Abtauzyklus) { + Counter_Abtauzyklus += sampling_time; + } + + else { + Counter_Abtauzyklus = MAX(Counter_Abtauzyklus - sampling_time, 0.0); + } + Abtauzyklus = Counter_Abtauzyklus > Abtauzyklus_Pause * 60.0 && + Abtauzyklus_Pause > 0.0; + + if (Abtauzyklus) { + Stellgrad_Entfeuchtungsventil = 0.0; + } + // Ende -f_PWMCoolingValve.Step(...) + + + // PWM Entfeuchtungsventil + // f_PWMDeHumizeValve.Step(...) + Entfeuchtungsventil = PWM_Entfeuchtungsventil.step( + Stellgrad_Entfeuchtungsventil, sampling_time); + + // Druckausgleich vor Start Verdichter + if (!Verdichter && Counter_Entfeuchtung_Freigabe > 5.0) { + Entfeuchtungsventil = true; + } + + // Heizung Kessel + + if (Freigabe_Heizung) { + Stellgrad_HeizungKessel = + MAX(Stellgrad_Heizung * Counter_Heizung_Freigabe, 0.0); + } else { + Stellgrad_HeizungKessel = 0.0; + } + + // PWM Heizung Kessel + HeizungKessel = PWM_Heizung_Kessel.step(Stellgrad_HeizungKessel, 0.25); + + // Betauungsschutz + + double Stellgrad_Betauungsschutz_MAX = limit( + (90.0 + Stellgrad_Kuehlung_Mittelwert) / (90.0 - 80.0) * 100.0, 0.0, + limit((Sollwert_Temperatur - 25.0) / (-20.0 - 25.0) * Betauungsschutz, + 0.0, Betauungsschutz)); + + if (!Startup_finished) { + Stellgrad_Betauungsschutz = 0.0; + } + + // Tuerheizung + Stellgrad_HeizungTuer = + limit(Stellgrad_Tuer + Stellgrad_Betauungsschutz / 10.0, 0.0, 100.0); + + HeizungTuer = PWM_Heizung_Tuer.step(Stellgrad_HeizungTuer, 0.25); + + // Heizung Kesselrand + + Stellgrad_HeizungKesselrand = + limit(Stellgrad_Tuer * + limit(1.0 + Betauungsschutz / 100.0 * 2.0 * + (90.0 + Stellgrad_Kuehlung_Mittelwert) / + (90.0 - 80.0), + 1.0, 2.0) + + Stellgrad_Betauungsschutz, + 0.0, 100.0); + + // Ende - f_PWMDeHumizeValve.Step(...) + + + // PWM Kesselrand + // Ende - f_PWMKesselRand.Step(...) + HeizungKesselrand = PWM_Heizung_Kesselrand.step(Stellgrad_HeizungKesselrand, 0.25); + // Ende - f_PWMKesselRand.Step(...) + + { + // Binder Feuchtemodul + + // Sperrsignal Feuchtemodul + + bool Sperrsignal_Feuchte = false; + + // Gradient Feuchtemodul + + if (!Startup_finished) { + Temperatur_Feuchtemodul_Gradient = 0; + } else { + Temperatur_Feuchtemodul_Gradient += + ((Temperatur_Feuchtemodul - Temperatur_Feuchtemodul_alt) * 60.0 * + 4.0 - + Temperatur_Feuchtemodul_Gradient) / + (4.0 * 10.0); + } + + Sollwert_Temperatur_Feuchtemodul = + Sollwert_Temperatur_Feuchtemodul_MIN + + Stellgrad_Feuchtemodul_Mittelwert / 100.0 * + (Sollwert_Temperatur_Feuchtemodul_MAX - + Sollwert_Temperatur_Feuchtemodul_MIN); + + // Offset Stellgrad Feuchtemodul + + double Temperatur_Feuchtemodul_Standby = + Sollwert_Temperatur_Feuchtemodul - + (Stellgrad_Entfeuchtung_Mittelwert - 0.0) / (-100.0 - 0.0) * 60.0; + double Standby_Feuchtemodul = + limit((Temperatur_Feuchtemodul_Standby - Temperatur_Feuchtemodul) / + 10.0 * 5.0, + 0.0, 5.0); + + // Stellgrad Feuchtemodul + Stellgrad_Feuchtemodul = limit( + Stellgrad_Befeuchtung + + 2.0 * limit(Stellgrad_Befeuchtung - Stellgrad_Feuchtemodul_PT1, + -2.0, 2.0) + + Stellgrad_Feuchtemodul_Nachfuellen, + 0.0, 100.0); + + // Begrenzung Temperatur Feuchtemodul über Temperatur + double Stellgrad_Feuchtemodul_MAX_Temperatur = limit( + (Temperatur_Feuchtemodul_MAX - Temperatur_Feuchtemodul) / 40.0 * 100.0, + 0.0, 100.0); + + double Temperatur_Feuchtemodul_Gradient_MAX = 10.0; + if (Temperatur_Feuchtemodul < 90.0) { + Temperatur_Feuchtemodul_Gradient_MAX = 10.0; + } else { + Temperatur_Feuchtemodul_Gradient_MAX = limit( + 20.0 - + (Temperatur_Feuchtemodul - (Temperatur_Feuchtemodul_MAX - 60.0)) / + 60.0 * 20.0 - + Stellgrad_Feuchtemodul_MAX / 100.0 * 10.0, + 5.0, 20.0); + } + + double Stellgrad_Feuchtemodul_MAX_adaptiv = 10.0; + if (!Startup_finished) { + Stellgrad_Feuchtemodul_MAX_adaptiv = 10.0; + } else if (Temperatur_Feuchtemodul < 80.0) { + Stellgrad_Feuchtemodul_MAX_adaptiv = 10.0; + } else if (Stellgrad_Feuchtemodul + 20.0 > + Stellgrad_Feuchtemodul_MAX_adaptiv && + Stellgrad_Feuchtemodul_MAX_adaptiv < + Stellgrad_Feuchtemodul_MAX_Temperatur && + Temperatur_Feuchtemodul_Gradient < + 2.0 * Temperatur_Feuchtemodul_Gradient_MAX && + !Sperrsignal_Feuchte) { + Stellgrad_Feuchtemodul_MAX_adaptiv = + limit(Stellgrad_Feuchtemodul_MAX_adaptiv + + 20.0 * + limit((Temperatur_Feuchtemodul_Gradient_MAX - + Temperatur_Feuchtemodul_Gradient) / + Temperatur_Feuchtemodul_Gradient_MAX, + -2.0, 1.0) / + (60.0 * 4.0), + 0.0, Stellgrad_Feuchtemodul_MAX_Temperatur); + } else { + Stellgrad_Feuchtemodul_MAX_adaptiv = + limit(Stellgrad_Feuchtemodul_MAX_adaptiv - 5.0 / (60.0 * 4.0), 10.0, + Stellgrad_Feuchtemodul_MAX_Temperatur); + } + + // Begrenzung Stellgrad_Feuchtemodul + + Stellgrad_Feuchtemodul_MAX = + MIN(Stellgrad_Feuchtemodul_MAX_Temperatur - 5.0, + Stellgrad_Feuchtemodul_MAX_adaptiv + Stellgrad_Feuchtemodul_Boost); + + Stellgrad_Feuchtemodul = + MIN(Stellgrad_Feuchtemodul, Stellgrad_Feuchtemodul_MAX); + + // Stellgrad Feuchtemodul Boost + + if (!Startup_finished || Temperatur_Feuchtemodul < 80.0) { + Stellgrad_Feuchtemodul_Boost = 0.0; + } else if (Stellgrad_Feuchtemodul < + Stellgrad_Feuchtemodul_MAX_adaptiv - 10.0) { + Stellgrad_Feuchtemodul_Boost = + MIN(Stellgrad_Feuchtemodul_Boost + 10.0 / 60.0 * sampling_time, + 2.0 * Stellgrad_Feuchtemodul_MAX_Temperatur); + } else { + Stellgrad_Feuchtemodul_Boost = MAX( + Stellgrad_Feuchtemodul_Boost - (Stellgrad_Feuchtemodul + 10.0 - + Stellgrad_Feuchtemodul_MAX_adaptiv) / + 60.0 * sampling_time, + 0.0); + } + if (!Startup_finished) { + Stellgrad_Feuchtemodul_PT1 = Stellgrad_Feuchtemodul; + } else if (is_valid(Stellgrad_Feuchtemodul_PT1)) { + Stellgrad_Feuchtemodul_PT1 = 0.0; + } else { + Stellgrad_Feuchtemodul_PT1 = + Stellgrad_Feuchtemodul_PT1 + + (Stellgrad_Feuchtemodul - Stellgrad_Feuchtemodul_PT1) / (4.0 * 30.0); + } + + // Nachfüllen Befeuchtungsmodul + + double Stellgrad_Nachfuellen_Temperatur = 0.0; + double Skalierung_Nachfuellen_Temperatur_P_Anteil = 0.0; + double Skalierung_Nachfuellen_Temperatur_D_Anteil = 0.0; + + if (!Startup_finished) { + Stellgrad_Nachfuellen_Temperatur = 0.0; + Skalierung_Nachfuellen_Temperatur_D_Anteil = 0.0; + Skalierung_Nachfuellen_Temperatur_D_Anteil = 0.0; + Skalierung_Nachfuellen_Temperatur_I_Anteil = 0.0; + } else { + Stellgrad_Nachfuellen_Temperatur = limit( + MAX(Temperatur_Feuchtemodul - Sollwert_Temperatur_Feuchtemodul, 0.0) * + 2.0 + + MIN(Temperatur_Feuchtemodul - Sollwert_Temperatur_Feuchtemodul, + 0.0) * + 1.0, + -20.0, 50.0); + Skalierung_Nachfuellen_Temperatur_P_Anteil = limit( + MAX(Temperatur_Feuchtemodul - Sollwert_Temperatur_Feuchtemodul, 0.0) / + 20.0 + + MIN(Temperatur_Feuchtemodul - Sollwert_Temperatur_Feuchtemodul, + 0.0) / + 40.0, + -0.2, 5.0); + Skalierung_Nachfuellen_Temperatur_D_Anteil = + limit(Temperatur_Feuchtemodul_Gradient / 10.0, -5.0, 5.0); + Skalierung_Nachfuellen_Temperatur_I_Anteil = + limit(Skalierung_Nachfuellen_Temperatur_I_Anteil + + limit(Skalierung_Nachfuellen_Temperatur_P_Anteil + + Skalierung_Nachfuellen_Temperatur_D_Anteil, + -0.2, 25.0) * + sampling_time / 1200.0, + 0.0, 5.0); + } + double Stellgrad_Nachfuellen = 0.0; + Stellgrad_Feuchtemodul_Nachfuellen = 0.0; + + if (Temperatur_Feuchtemodul > Temperatur_Feuchtemodul_MAX && + Temperatur_Feuchtemodul_Gradient > 0.0) { + Stellgrad_Nachfuellen = 20.0; + Stellgrad_Feuchtemodul_Nachfuellen = 0.0; + } else { + Stellgrad_Nachfuellen = limit( + ((Stellgrad_Feuchtemodul_PT1 - Stellgrad_Feuchtemodul_Nachfuellen) * + (MAX(Skalierung_Nachfuellen_Temperatur_P_Anteil + + Skalierung_Nachfuellen_Temperatur_D_Anteil, + 0.0) + + Skalierung_Nachfuellen_Temperatur_I_Anteil) + + Stellgrad_Nachfuellen_Temperatur) * + 2.0 * 7.9681 / Durchflussmenge_Einlassventil_Feuchtemodul, + 0.0, 100.0); + Stellgrad_Feuchtemodul_Nachfuellen = + 0.5 * Stellgrad_Nachfuellen * + Durchflussmenge_Einlassventil_Feuchtemodul / 60.0 * 4.19 * 75.0 / + 600.0; + } + //(* Entleeren des Kessels *) + bool Entleeren_Kessel = false; + if (Startup_finished && Temperatur_Feuchtemodul < 70.0) { + Entleeren_Kessel = Counter_Entleeren_Kessel < 60.0; + Counter_Entleeren_Kessel += sampling_time; + } else { + Counter_Entleeren_Kessel = 0.0; + Entleeren_Kessel = false; + } + + //(* Abschlämmen des Kessels *) + Abschlaemmintegral = + Abschlaemmintegral + 0.1 * Durchflussmenge_Einlassventil_Feuchtemodul / + Durchflussmenge_Abschlaemmventil_Feuchtemodul * + Stellgrad_Nachfuellen / 100.0 * sampling_time; + + if (Entleeren_Kessel) { + Abschlaemmventil = true; + Stellgrad_Abschlaemmventil_zyklisch = 100.0; + } else { + Counter_Zyklus_Abschlaemmventil += sampling_time; + if (Abschlaemmintegral > 0.25 && Temperatur_Feuchtemodul_Gradient < 0.0) { + Abschlaemmventil = true; + Stellgrad_Abschlaemmventil_zyklisch = 2.5; + Counter_Zyklus_Abschlaemmventil = 0.0; + Abschlaemmintegral -= 0.25; + } else { + Abschlaemmventil = false; + if (Counter_Zyklus_Abschlaemmventil >= 10.0) { + Stellgrad_Abschlaemmventil_zyklisch = 0.0; + } + } + } + + // Stellgrad_Feuchtemodul = 2.0; + + // PWM Befeuchtungsmodul + HeizungFeuchtemodul = + PWM_Heizung_Feuchtemodul.step(Stellgrad_Feuchtemodul, 0.25); + // PWM Nachfüllen + Nachfuellen = PWM_Nachfuellen.step(Stellgrad_Nachfuellen, 0.25); + + // Abwassermanagement + if (!Entleerbehaelter_Unten || !Entleerbehaelter_Oben || Entleeren_Kessel) { + Counter_Nachlauf_Entleeren = 10.0; + Counter_Pause_Entleeren += sampling_time; + if (Counter_Pause_Entleeren > 30.0) { + Counter_Pause_Entleeren = 0.0; + } + + } else { + Counter_Nachlauf_Entleeren = + MAX(Counter_Nachlauf_Entleeren - sampling_time, 0.0); + Counter_Pause_Entleeren = 0.0; + } + bool Entleeren_Pause = false; + Entleeren = Counter_Nachlauf_Entleeren > 0.0; + Entleeren_Pause = Counter_Pause_Entleeren > 27.0; + Entleerpumpe = Entleeren && !Entleeren_Pause; + + if (!Startup_finished) { + Zyklus_Entleeren_Mittelwert = 600.0; + } else if (Entleeren && !Entleeren_alt) { + Zyklus_Entleeren_Mittelwert = limit( + Zyklus_Entleeren_Mittelwert + + (Counter_Zyklus_Entleeren - Zyklus_Entleeren_Mittelwert) / 10.0, + 10.0, 3600.0); + Counter_Zyklus_Entleeren = 0.0; + } else { + Counter_Zyklus_Entleeren += sampling_time; + } + + if (Steuerkontakt_Standby || Istwert_Temperatur > 110.0) { + Counter_Kuehlung_Freigabe = 0.0; + } else { + if (Stellgrad_Kuehlung < 0.0 || Stellgrad_Heizung < 2.0 || + Counter_Tuer_geschlossen < 300.0) { + Counter_Kuehlung_Freigabe = + MIN(Counter_Kuehlung_Freigabe + sampling_time / 10.0, 1.0); + } else { + Counter_Kuehlung_Freigabe = + MAX(Counter_Kuehlung_Freigabe - sampling_time / 300.0, 0.0); + } + } + Freigabe_Kuehlung = Counter_Kuehlung_Freigabe >= 1.0 || + (Freigabe_Kuehlung && Counter_Kuehlung_Freigabe > 0.0); + // * Freigabe Kühlung *) + + // (* Freigabe Entfeuchtung *) + if (Steuerkontakt_Standby || Istwert_Temperatur > 110.0) { + Counter_Entfeuchtung_Freigabe = 0.0; + } else { + if (Stellgrad_Entfeuchtung < 0.0 || Stellgrad_Befeuchtung < 2.0 || + Counter_Tuer_geschlossen < 300.0) { + Counter_Entfeuchtung_Freigabe = + MIN(Counter_Entfeuchtung_Freigabe + sampling_time / 10.0, 10.0); + } else { + Counter_Entfeuchtung_Freigabe = + MAX(Counter_Entfeuchtung_Freigabe - sampling_time / 300.0, 0.0); + } + } + Freigabe_Entfeuchtung = + Counter_Entfeuchtung_Freigabe >= 1.0 || + (Freigabe_Entfeuchtung && Counter_Entfeuchtung_Freigabe > 0.0); + + // (* Freigabe Heizung *) + if (Steuerkontakt_Standby || Istwert_Temperatur > 110.0) { + Counter_Heizung_Freigabe = 0.0; + } else { + if (Stellgrad_Heizung < 0.0 || Stellgrad_Kuehlung > -2.0 || + Counter_Tuer_geschlossen < 300.0) { + Counter_Heizung_Freigabe = + MIN(Counter_Heizung_Freigabe + sampling_time / 10.0, 10.0); + } else { + Counter_Heizung_Freigabe = + MAX(Counter_Heizung_Freigabe - sampling_time / 300.0, 0.0); + } + } + Freigabe_Heizung = Counter_Heizung_Freigabe >= 1.0 || + (Freigabe_Heizung && Counter_Heizung_Freigabe > 0.0); + // (* Freigabe Befeuchtung *) + if (Steuerkontakt_Standby || Istwert_Temperatur > 110.0) { + Counter_Befeuchtung_Freigabe = 0.0; + } else { + if (Stellgrad_Befeuchtung < 0.0 || Stellgrad_Entfeuchtung > -2.0 || + Counter_Tuer_geschlossen < 300.0) { + Counter_Befeuchtung_Freigabe = + MIN(Counter_Befeuchtung_Freigabe + sampling_time / 10.0, 10.0); + } else { + Counter_Befeuchtung_Freigabe = + MAX(Counter_Befeuchtung_Freigabe - sampling_time / 300.0, 0.0); + } + } + Freigabe_Befeuchtung = + Counter_Befeuchtung_Freigabe >= 1.0 || + (Freigabe_Befeuchtung && Counter_Befeuchtung_Freigabe > 0.0); + + // Verdichterabscaltung + + if (!Startup_finished) { + Drehzahl_Verdichter_adaptiv = Drehzahl_Verdichter_MAX; + } else if (Temperatursprung) { + Drehzahl_Verdichter_adaptiv = + MAX(Drehzahl_Verdichter_Kuehlung, Drehzahl_Verdichter_Entfeuchtung); + } else if (is_valid(Stellgrad_Kuehlung)) { + Drehzahl_Verdichter_adaptiv = + limit(Drehzahl_Verdichter_adaptiv + + (-Stellgrad_Kuehlung - 25.0) / 100.0 * + (Drehzahl_Verdichter_MAX - Drehzahl_Verdichter_MIN) / + (4.0 * 600.0), + Drehzahl_Verdichter_MIN, Drehzahl_Verdichter_MAX); + } + + Drehzahl_Verdichter_Kuehlung = + Drehzahl_Verdichter_MIN + + (MAX(-Stellgrad_Kuehlung_Mittelwert, -Stellgrad_Kuehlung) - 30.0) / + (90.0 - 30.0) * (Drehzahl_Verdichter_MAX - Drehzahl_Verdichter_MIN); + Drehzahl_Verdichter_Entfeuchtung = + Drehzahl_Verdichter_MIN + + 0.5 * + (MAX(-Stellgrad_Entfeuchtung_Mittelwert, -Stellgrad_Entfeuchtung) - + 50.0) / + (90.0 - 50.0) * (Drehzahl_Verdichter_MAX - Drehzahl_Verdichter_MIN); + + if (Verdichter) { + Drehzahl_Verdichter = + limit(MAX(Drehzahl_Verdichter_Kuehlung, + MAX(Drehzahl_Verdichter_Entfeuchtung, + Drehzahl_Verdichter_adaptiv)), + Drehzahl_Verdichter_MIN, Drehzahl_Verdichter_MAX); + } else { + Drehzahl_Verdichter = 1000.0; + } + + Stellgrad_Verdichter = + Drehzahl_Verdichter / Drehzahl_Verdichter_MAX * 100.0 * (160.0 / 200.0); + /* + (* -------------------- *) + (* Verflüssigerregelung *) + (* -------------------- *) */ + + Verfluessiger = Verfluessiger && + ((Drehzahl_Verdichter_adaptiv - Drehzahl_Verdichter_MIN) / ((Drehzahl_Verdichter_MAX - Drehzahl_Verdichter_MIN) < 0.30) && + (-Stellgrad_Kuehlung_Mittelwert < 30.0) && + (-Stellgrad_Entfeuchtung_Mittelwert < 60.0) || ((Drehzahl_Verdichter_adaptiv - Drehzahl_Verdichter_MIN) / (Drehzahl_Verdichter_MAX - Drehzahl_Verdichter_MIN) < 0.20) && + (-Stellgrad_Kuehlung_Mittelwert < 20.0) && + -Stellgrad_Entfeuchtung_Mittelwert < 50.0); + + }// Ende Feuchtemodul + + // ---------------------------------------- + // Werte die auf Veränderung geprüft werden + // ---------------------------------------- + Sammelalarm_quittiert_alt = Sammelalarm_quittiert; + Istwert_Temperatur_alt = Istwert_Temperatur; + Regelabweichung_Temperatur_alt = Regelabweichung_Temperatur; + Sollwert_Temperatur_alt = Sollwert_Temperatur; + Istwert_Feuchte_alt = Istwert_Feuchte; + Regelabweichung_Feuchte_alt_alt = Regelabweichung_Feuchte_alt; + Regelabweichung_Feuchte_alt = Regelabweichung_Feuchte; + Sollwert_Feuchte_alt = Sollwert_Feuchte; + Durchzug_alt = Durchzug; + Regelabweichung_Tuer_alt = Regelabweichung_Tuer; + HeizungFeuchtemodul_alt = HeizungFeuchtemodul; + Regelabweichung_Befeuchtung_alt_alt = Regelabweichung_Befeuchtung_alt; + Regelabweichung_Entfeuchtung_alt = Regelabweichung_Entfeuchtung; + + + + // ---------------- + // Rückgabewerte + // ---------------- + // F_Outputs out{}; + + binOut.bool_out01 = (std::abs((Sollwert_Temperatur - Istwert_Temperatur)) > Temperaturband); // du nutzt Temperaturband-Alarm + // separat; hier nur Beispiel + binOut.bool_out02 = (std::abs((Sollwert_Feuchte - Istwert_Feuchte)) > Feuchteband) && + (!Befeuchtung_aus) && (!Entfeuchtung_aus); + binOut.bool_out03 = Befeuchtung_aus || Entfeuchtung_aus; + binOut.bool_out07 = (!Status_Uebertemperatur) && + (!(std::abs(Istwert_Ueberwachungsregler - Istwert_Temperatur) > 20.0)); + alarmOut.Startup = Startup_finished; + + binOut.bool_out09 = HeizungKessel; + binOut.bool_out11 = HeizungTuer; + binOut.bool_out12 = HeizungKesselrand; + binOut.bool_out13 = Verfluessiger; + binOut.bool_out14 = Nachfuellen; + binOut.bool_out16 = Entleerpumpe; + binOut.bool_out17 = HeizungFeuchtemodul; + binOut.bool_out20 = Abschlaemmventil; + binOut.bool_out18 = Kuehlventil; + binOut.bool_out19 = Entfeuchtungsventil; + binOut.bool_out21 = Verdichter; + binOut.bool_out23 = !Sammelalarm_quittiert; + + analogOut.real_out01 = Istwert_Temperatur; + analogOut.real_out02 = Istwert_Temperatur; + analogOut.real_out04 = Istwert_Temperatur; + analogOut.real_out05 = limit(Istwert_Feuchte, 0.0, 100.0); + analogOut.real_out06 = limit(Istwert_Feuchte, 0.0, 100.0); + analogOut.real_out07 = Sollwert_Feuchte; + analogOut.real_out08 = limit(Istwert_Feuchte, 0.0, 100.0); + analogOut.real_out09 = Stellgrad_HeizungKessel; + analogOut.real_out10 = Stellgrad_Pumpe; + analogOut.real_out11 = Stellgrad_HeizungTuer; + analogOut.real_out12 = Stellgrad_HeizungKesselrand; + analogOut.real_out13 = Stellgrad_Feuchtemodul; + analogOut.real_out14 = Stellgrad_Abschlaemmventil_zyklisch; + analogOut.real_out16 = Temperatur_Feuchtemodul; + analogOut.Stellgrad_Feuchtemodul = Stellgrad_Feuchtemodul; + analogOut.real_out18 = Stellgrad_Kuehlventil; + analogOut.real_out19 = Stellgrad_Entfeuchtungsventil; + analogOut.real_out20 = Stellgrad_Luefter; + analogOut.real_out21 = Stellgrad_Verdichter; + analogOut.real_out25 = Schaltwert_Uebertemperatur; + analogOut.real_out26 = Schaltwert_Untertemperatur; + analogOut.Stellgrad_Heizung = Stellgrad_Heizung; + analogOut.Stellgrad_Kuehlung = Stellgrad_Kuehlung; + analogOut.Stellgrad_Befeuchtung = Stellgrad_Befeuchtung; + analogOut.Stellgrad_Entfeuchtung = Stellgrad_Entfeuchtung; + analogOut.Counter_Tuer = Counter_Tuer_offen; + + // alarms (wie ST) + alarmOut.alarm_01 = Bandalarm_Temperatur; + alarmOut.alarm_02 = Bandalarm_Feuchte; + alarmOut.alarm_03 = Tueralarm; + alarmOut.alarm_04 = false; + alarmOut.alarm_05 = false; + alarmOut.alarm_06 = Alarm_Wasser_Befeuchtungsmodul && !Befeuchtung_aus; + alarmOut.alarm_07 = Alarm_Abwasser_Befeuchtungsmodul; + alarmOut.alarm_08 = (Alarm_Heizung_Befeuchtungsmodul || Alarm_PT100_Befeuchtungsmodul) && + !Befeuchtung_aus; + + // alarm_09..alarm_15 sind im ST mit Selbsthaltung/Quittierung etc.: + alarmOut.alarm_09 = (((Istwert_Temperatur_Tuer < -50.0) || (Istwert_Temperatur_Tuer > 120.0)) && + Startup_finished) ||(alarm_09 && Sammelalarm_quittiert); + + alarmOut.alarm_10 = (std::abs(Istwert_Ueberwachungsregler - Istwert_Temperatur) > 20.0) || + ((((Istwert_Ueberwachungsregler < -50.0) || + (Istwert_Ueberwachungsregler > 120.0) && Startup_finished))) || + (alarm_10 && Sammelalarm_quittiert); + + alarmOut.alarm_11 = + Status_Uebertemperatur || StatusQuittierung_Uebertemperatur; + alarmOut.alarm_12 = + Status_Untertemperatur || StatusQuittierung_Untertemperatur; + + alarmOut.alarm_13 = (((Istwert_Temperatur_Verdampferausgang < -50.0) || + (Istwert_Temperatur_Verdampferausgang > 120.0)) && + Startup_finished) || + (alarm_13 && Sammelalarm_quittiert); + + alarmOut.alarm_14 = + (Counter_Wasserkanister_leer > 10.0 && Startup_finished) || + (alarm_14 && Sammelalarm_quittiert); + + alarmOut.alarm_15 = + ((analogInput.real_in11 > Sollwert_Feuchte_Max && !Befeuchtung_aus) || + (analogInput.real_in11 < Sollwert_Feuchte_Min && !Entfeuchtung_aus)) || + (alarm_15 && Sammelalarm_quittiert); + + // Selbsthaltung der Alarm-Bits (wie ST-OR alarm_x ...) + alarm_09 = alarmOut.alarm_09; + alarm_10 = alarmOut.alarm_10; + alarm_13 = alarmOut.alarm_13; + alarm_14 = alarmOut.alarm_14; + alarm_15 = alarmOut.alarm_15; + + // return out; + } + +private: + // ===== ST: VAR CONSTANT ===== + static constexpr double sampling_time = 0.25; + + static constexpr std::array, 4> Kennfeld_Ueberhitzung{ + {// 0: Temperatur + std::array{-20.0, -10.0, 0.0, 10.0, 20.0, 30.0, 40.0, 50.0, + 60.0, 70.0, 80.0, 90.0, 100.0}, + // 1: Skalierung Min + std::array{0.01, 0.02, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, + 0.8, 0.9, 1.0, 1.0}, + // 2: Skalierung Max + std::array{0.01, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, + 1.0, 1.0, 1.0}, + // 3: Sollwert Überhitzung + std::array{-6.0, -8.0, -10.0, -8.0, -6.0, -8.0, -10.0, -12.0, + -16.0, -20.0, -24.0, -28.0, -32.0}}}; + static constexpr std::array, 4> Kennfeld_Entfeuchtung{ + {// 0: Temperatur + std::array{-20.0, -10.0, 0.0, 10.0, 20.0, 30.0, 40.0, 50.0, + 60.0, 70.0, 80.0, 90.0, 100.0}, + // 1: Skalierung Entfeuchtung + std::array{0.08, 0.08, 0.08, 0.10, 0.12, 0.14, 0.16, 0.18, + 0.20, 0.22, 0.24, 0.26, 0.28}, + // 2: Abtauzyklus Pause + std::array{120.0, 120.0, 120.0, 120.0, 120.0, 90.0, 60.0, + 60.0, 60.0, 0.0, 0.0, 0.0, 0.0}, + // 3: Abtauzyklus Dauer + std::array{60.0, 60.0, 60.0, 30.0, 20.0, 10.0, 8.0, 4.0, 2.0, + 0.0, 0.0, 0.0, 0.0}}}; + + // Kennfelder (nur die, die oben genutzt werden; den Rest kannst du genauso + // hinzufügen) + static constexpr std::array Kennfeld_Regler_Heizung_Xp{ + 0.2, 0.5, 0.8, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0}; + static constexpr std::array Kennfeld_Regler_Kuehlung_Xp{ + 0.1, 0.1, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.0}; + static constexpr std::array, 9> + Kennfeld_Regler_Befeuchtung_Xp{ + {std::array{1.00, 0.54, 0.31, 0.18, 0.11, 0.07, 0.05, 0.03, + 0.02}, + std::array{1.00, 0.54, 0.31, 0.18, 0.11, 0.07, 0.05, 0.03, + 0.02}, + std::array{1.00, 0.54, 0.31, 0.18, 0.11, 0.07, 0.05, 0.03, + 0.02}, + std::array{1.00, 0.54, 0.31, 0.18, 0.11, 0.07, 0.05, 0.03, + 0.02}, + std::array{1.00, 0.54, 0.31, 0.18, 0.11, 0.07, 0.05, 0.03, + 0.02}, + std::array{1.00, 0.54, 0.31, 0.18, 0.11, 0.07, 0.05, 0.03, + 0.02}, + std::array{1.00, 0.54, 0.31, 0.18, 0.11, 0.07, 0.05, 0.03, + 0.02}, + std::array{1.00, 0.54, 0.31, 0.18, 0.11, 0.07, 0.05, 0.03, + 0.02}, + std::array{1.00, 0.54, 0.31, 0.18, 0.11, 0.07, 0.05, 0.03, + 0.02}}}; + static constexpr std::array, 9> + Kennfeld_Regler_Entfeuchtung_Xp{ + {std::array{1.00, 0.80, 0.60, 0.50, 0.40, 0.35, 0.30, 0.25, + 0.20}, + std::array{1.00, 0.80, 0.60, 0.50, 0.40, 0.35, 0.30, 0.25, + 0.20}, + std::array{1.00, 0.80, 0.60, 0.50, 0.40, 0.35, 0.30, 0.25, + 0.20}, + std::array{1.00, 0.80, 0.60, 0.50, 0.40, 0.35, 0.30, 0.25, + 0.20}, + std::array{1.00, 0.80, 0.60, 0.50, 0.40, 0.35, 0.30, 0.25, + 0.20}, + std::array{1.00, 0.80, 0.60, 0.50, 0.40, 0.35, 0.30, 0.25, + 0.20}, + std::array{1.00, 0.80, 0.60, 0.50, 0.40, 0.35, 0.30, 0.25, + 0.20}, + std::array{1.00, 0.80, 0.60, 0.50, 0.40, 0.35, 0.30, 0.25, + 0.20}, + std::array{1.00, 0.80, 0.60, 0.50, 0.40, 0.35, 0.30, 0.25, + 0.20}}}; + + static constexpr std::array, 3> + Kennfeld_Sollwert_Feuchte_Limit{ + {std::array{0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100}, + std::array{80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80}, + std::array{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}}; + + // Zeitkonstanten etc. + static constexpr double Tau_Heizung_Tv = 10.0; + + // Faktoren + static constexpr double F_Xp_Heizung = 3.8; + static constexpr double F_Xp_Kuehlung = 33.6; + static constexpr double F_Xp_Befeuchtung_BINDER = 131.0; + static constexpr double F_Xp_Entfeuchtung = 100.0; + static constexpr double F_Xp_Tuer = 10.0; + + // ===== ST: VAR (Zustände / Merker) ===== + // (ich halte hier nur die, die im übersetzten Teil genutzt werden; den Rest + // kannst du 1:1 ergänzen) + double Istwert_Temperatur{}; + double Istwert_Temperatur_alt{}; + double Sollwert_Temperatur{}; + double Sollwert_Temperatur_alt{}; + double Sollwert_Gegenbefeuchten = 0.0; + double Regelabweichung_Befeuchtung_alt = 0.0; + double P_Anteil_Befeuchtung = 0.0; + double Counter_Entfeuchtung_Freigabe = 0.0; + bool Freigabe_Entfeuchtung = false; + double Counter_Heizung_Freigabe = 0.0; + bool Freigabe_Heizung = false; + double Counter_Befeuchtung_Freigabe = 0.0; + bool Freigabe_Befeuchtung = false; + bool Abtauzyklus = false; + double Counter_Zyklus_Entleeren = 0.0; + double Drehzahl_Verdichter_Kuehlung = 0.0; + double Drehzahl_Verdichter_Entfeuchtung = 0.0; + double Drehzahl_Verdichter = 0.0; + + /*PWM(double zyklus_min, double zyklus_max, double initial_zykluszeit = -1.0) + noexcept : Zyklus(0.0), Ausgabe(0.0), Zykluszeit((initial_zykluszeit > 0.0) ? + initial_zykluszeit : zyklus_max), Zyklus_MIN(zyklus_min), + Zyklus_MAX(zyklus_max) + {} + + bool step(double Stellgrad,double sampling_time,double Zyklus_MIN,double + Zyklus_MAX){*/ + PWM PWM_Heizung_Kessel = {10.0, 600.0, 0.0}; + PWM PWM_Heizung_Tuer = {10.0, 600.0, 0.0}; + PWM PWM_Nachfuellen = {10.0, 600.0, 0.0}; + PWM PWM_Heizung_Kesselrand = {10.0, 600.0, 0.0}; + PWM PWM_Heizung_Feuchtemodul = {10.0, 600.0, 0.0}; + PWM PWM_Kuehlventil = {10.0, 600.0, 0.0}; + PWM PWM_Entfeuchtungsventil = {10.0, 600.0, 0.0}; + + double Istwert_Ueberwachungsregler{}; + std::uint32_t Modus_Ueberwachungsregler{}; + double Offset_Ueberwachungsregler{}; + double Klasse_Ueberwachungsregler{}; + bool Wasserkanister_leer{}; + double Regler_Tuer_Tn = 700.0; + double Regler_Tuer_Tv = 60.0; + double Tau_Tuer_Tv = 60.0; + double Regler_Entfeuchtung_MAX = 0.0; + double Regler_Entfeuchtung_MIN = 0.0; + double Regler_Entfeuchtung_I_Anteil_MAX = 0.0; + double Regler_Entfeuchtung_I_Anteil_MIN = 0.0; + bool Freigabe_Kuehlung = false; + double Sollwert_Temperatur_Feuchtemodul_MIN = 110.0; + double Sollwert_Temperatur_Feuchtemodul_MAX = 130.0; + double Zyklus_Entleeren_Mittelwert = 600.0; + + double Grenzwert_Uebertemperatur{}; + double Schaltwert_Uebertemperatur{}; + bool Status_Uebertemperatur{}; + std::uint32_t Counter_Status_Uebertemperatur{}; + bool StatusQuittierung_Uebertemperatur{}; + + double Grenzwert_Untertemperatur{}; + double Schaltwert_Untertemperatur{}; + bool Status_Untertemperatur{}; + std::uint32_t Counter_Status_Untertemperatur{}; + bool StatusQuittierung_Untertemperatur{}; + + double Istwert_Feuchte{}; + double Istwert_Feuchte_alt{}; + double Sollwert_Feuchte{}; + double Sollwert_Feuchte_alt{}; + double Counter_Entleeren_Kessel{}; + + bool Regelung_AUS{}; + double Counter_Regelung_AUS{}; + bool Steuerkontakt_Standby{}; + bool Sammelalarm{}; + bool Sammelalarm_quittiert{}; + bool Sammelalarm_quittiert_alt{}; + double Regler_Kuehlung_Tv = 5.0; + double Tau_Kuehlung_Tv = 30.0; + double Theta_I_Kuehlung = 1.0; + + // Feuchte absolut + double p_H2Omax_Sollwert{}; + double p_H2Omax_Istwert{}; + double Taupunkt_Istwert{}; + double Sollwert_Feuchte_Absolut{}; + double Sollwert_Temperatur_Feuchtemodul{}; + double Counter_Kuehlung_Freigabe = 0.0; + + // Tür + bool Tuer_offen{}; + double Counter_Tuer_offen{}; + double Counter_Tuer_geschlossen{}; + double Istwert_Temperatur_Tuer{}; + double Regelabweichung_Tuer{}; + double Regelabweichung_Tuer_alt{}; + double Abschlaemmintegral = 0.0; + double Standby_Feuchtemodul = 0.0; + double Regelabweichung_Befeuchtung_alt_alt = 0.0; + double Regelabweichung_Entfeuchtung_alt = 0.0; + double Durchflussmenge_Einlassventil_Feuchtemodul = 400.0; + double Durchflussmenge_Abschlaemmventil_Feuchtemodul = 1500.0; + + // Startup / reset + std::uint32_t Counter_reset_flag{}; + bool Startup_finished{}; + + // Feuchte limit + std::uint16_t Index_Sollwert_Feuchte_Limit{}; + double Interpolation_Sollwert_Feuchte_Limit{}; + double Sollwert_Feuchte_Min{}; + double Sollwert_Feuchte_Max{}; + + // Abschaltung Feuchte-Regler + bool Sollwert_Feuchte_aktiv{}; + bool Steuerkontakt_Befeuchtung_aus{}; + bool Steuerkontakt_Entfeuchtung_aus{}; + bool Befeuchtung_aus{}; + bool Entfeuchtung_aus{}; + double Sollwert_Gegenheizen = 2.0; + // Parameter Indizes + std::uint16_t Index_Feuchte{}; + std::uint16_t Index_Temperatur{}; + std::uint16_t Index_Temperatur_ohne_Feuchte{}; + + // Reglerparameter + double Regler_Heizung_Xp{}; + double Regler_Kuehlung_Xp{}; + double Regler_Befeuchtung_Xp{}; + double Regler_Entfeuchtung_Xp{}; + double Regler_Tuer_Xp{}; + double Regler_Befeuchtung_Tv = 30.0; + double Regler_Befeuchtung_Tn = 100.0; + double Regler_Befeuchtung_Tz = 1200.0; + double Tau_Befeuchtung_Tv = 10.0; + double Tau_Befeuchtung_Tz = 5.0; + + // Regelkern Temperatur + double Sollwert_Temperatur_MIN{}; + double Sollwert_Temperatur_MAX{}; + + double Regelabweichung_Temperatur{}; + double Regelabweichung_Temperatur_alt{}; + double Regelabweichung_Temperatur_Mittelwert{}; + double Standardregelabweichung_Temperatur{}; + double Regelabweichung_Temperatur_Gradient{}; + double Standardgradient_Regelabweichung_Temperatur{}; + double Zykluszeit_Regelabweichung_Temperatur{}; + double Amplitude_Regelabweichung_Temperatur{}; + double Zykluszeit_Regelabweichung_Heizung{}; + double Zykluszeit_Regelabweichung_Kuehlung{}; + double Regelabweichung_Kuehlung_Gradient{}; + double Regelabweichung_Kuehlung_alt{}; + double Faktor_Kuehlung{}; + double Faktor_Gegenheizen_Band{}; + double I_Anteil_Kuehlung{}; + double D_Anteil_Kuehlung{}; + double Regelabweichung_Befeuchtung_Gradient{}; + double I_Anteil_Befeuchtung{}; + double Istwert_Temperatur_Verdampferausgang_PT1 = 0.0; + double D_Anteil_Befeuchtung{}; + bool Temperatursprung{}; + double Counter_Temperatursprung{}; + double Faktor_Entfeuchtung{}; + double Faktor_Gegenbefeuchten_Band = 5.0; + double I_Anteil_Entfeuchtung = 0.0; + double D_Anteil_Entfeuchtung = 0.0; + double I_Anteil_Tuer = 0.0; + double P_Anteil_Tuer; + double Regler_Heizung_MIN{}; + double Regler_Heizung_MAX{}; + double Regler_Heizung_I_Anteil_MIN{}; + double Regler_Heizung_I_Anteil_MAX{}; + double P_Anteil_Heizung{}; + double I_Anteil_Heizung{}; + double D_Anteil_Heizung{}; + double Stellgrad_Heizung{}; + double Stellgrad_Heizung_Mittelwert{}; + double Regelabweichung_Entfeuchtung_Gradient = 0.0; + double D_Anteil_Tuer = 0.0; + double Counter_Verdichter_aus = 0.0; + double Counter_Freigabe_Abtauzyklus = 0.0; + double Counter_Abtauzyklus; + double Stellgrad_Feuchtemodul_MAX{}; + double Skalierung_Nachfuellen_Temperatur_I_Anteil{}; + double Counter_Zyklus_Abschlaemmventil = 0.0; + const double Regler_Kuehlung_Tn = 200.0; + + double Stellgrad_Feuchtemodul_Boost{}; + const double Temperatur_Feuchtemodul_MAX = 200.0; + + // Feuchte - nur Platzhalter (weil spätere Ausdrücke referenzieren) + double Regelabweichung_Feuchte{}; + double Regelabweichung_Feuchte_alt{}; + double Regelabweichung_Feuchte_alt_alt{}; + double Regelabweichung_Feuchte_Mittelwert{}; + double Standardregelabweichung_Feuchte{}; + double Regelabweichung_Feuchte_Gradient{}; + double Standardgradient_Regelabweichung_Feuchte{}; + double Zykluszeit_Regelabweichung_Feuchte{}; + double Amplitude_Regelabweichung_Feuchte{}; + bool Feuchtesprung{}; + double Counter_Feuchtesprung = 0.0; + double Offset_Regelabweichung_Befeuchtung{}; + double Offset_Regelabweichung_Entfeuchtung{}; + double Stellgrad_Kuehlung{}; + double Stellgrad_Kuehlung_Mittelwert{}; + double Stellgrad_Befeuchtung{}; + double Stellgrad_Befeuchtung_Mittelwert{}; + double Stellgrad_Befeuchtung_Standby{}; + double Stellgrad_Entfeuchtung{}; + double Stellgrad_Entfeuchtung_Mittelwert{}; + double Z_Anteil_Befeuchtung{}; + + // Aktoren/Signale (Defaults, bis restliche Logik ergänzt ist) + bool HeizungKessel{}; + double Stellgrad_HeizungKessel{}; + bool HeizungTuer{}; + double Stellgrad_HeizungTuer{}; + bool HeizungKesselrand{}; + double Stellgrad_HeizungKesselrand{}; + bool Verfluessiger{}; + bool Nachfuellen{}; + bool Entleerpumpe{}; + bool HeizungFeuchtemodul{}; + bool HeizungFeuchtemodul_alt{}; + bool Abschlaemmventil{}; + double Stellgrad_Abschlaemmventil_zyklisch{}; + bool Kuehlventil{}; + double Stellgrad_Kuehlventil{}; + bool Entfeuchtungsventil{}; + double Stellgrad_Entfeuchtungsventil{}; + bool Verdichter{}; + double Stellgrad_Verdichter{}; + double Stellgrad_Pumpe{}; + double Stellgrad_Luefter{}; + double Stellgrad_Betauungsschutz{}; + double Temperatur_Feuchtemodul_Gradient = 0.0; + double Stellgrad_Feuchtemodul_MAX_adaptiv = 0.0; + double Counter_Nachlauf_Entleeren = 0.0; + double Counter_Pause_Entleeren = 0.0; + + // “Durchzug” (wird später in Überhitzungslogik gesetzt) + bool Durchzug{}; + bool Durchzug_alt{}; + double Counter_Durchzug{}; + + // Befeuchtungsmodul Zustände (Platzhalter, damit “Werte die auf Veränderung + // geprüft werden” passt) + double Temperatur_Feuchtemodul{}; + double Temperatur_Feuchtemodul_alt{}; + double Stellgrad_Feuchtemodul{}; + double Stellgrad_Feuchtemodul_Mittelwert{}; + double Stellgrad_Feuchtemodul_PT1{}; + double Stellgrad_Feuchtemodul_Nachfuellen{}; + bool Entleeren{}; + bool Entleeren_alt{}; + bool Entleerbehaelter_Oben{}; + bool Entleerbehaelter_Unten{}; + double Counter_Wasserkanister_leer{}; + double Regler_Entfeuchtung_Tv = 5.0; + double Regler_Entfeuchtung_Tn = 200.0; + double Tau_Entfeuchtung_Tv = 60.0; + double Theta_I_Entfeuchtung = 0.1; + double C_Entfeuchtung = 200.0; + double U_Entfeuchtung = 0.4; + double P_Entfeuchtung = 500.0; + double Regler_Entfeuchten_I_Anteil_MIN = 0.0; + double Drehzahl_Verdichter_MIN = 1800.0; + double Drehzahl_Verdichter_MAX = 4500.0; + double Drehzahl_Verdichter_adaptiv = 0.0; + + // Alarmbits mit Selbsthaltung + bool alarm_09{}; + bool alarm_10{}; + bool alarm_13{}; + bool alarm_14{}; + bool alarm_15{}; + bool Alarm_Wasser_Befeuchtungsmodul{}; + bool Alarm_Abwasser_Befeuchtungsmodul{}; + bool Alarm_PT100_Befeuchtungsmodul{}; + bool Alarm_Heizung_Befeuchtungsmodul{}; + bool Bandalarm_Temperatur{}; + bool Bandalarm_Feuchte{}; + bool Tueralarm{}; +}; + +// namespace UTILITY_FUNCTIONS + +// double PT100_ResistanceToTemperature_Linear(double R) +// { +// constexpr double R0 = 100.0; +// constexpr double alpha = 0.00385; // IEC-Näherung + +// return (R - R0) / (R0 * alpha); +// } + +class PT1 { +public: + PT1() = default; + void initialize(double fs, double t_cutoff) { + fs_ = fs; + ts_ = 1 / fs_; + double f_cutoff = 1. / t_cutoff; + tau_ = 1 / (2 * PI_CONST * f_cutoff); + lambda_ = 2 * tau_ / ts_; + b0_ = k_ / (1. + lambda_); + b1_ = k_ / (1. + lambda_); + a0_ = (1. - lambda_) / (1. + lambda_); + }; + + double step(double x) { + + double y = b0_ * x + s1_; + // s1 = b1*x - a1*y + s1_ = b1_ * x - a0_ * y; + return y; + }; + +private: + double s1_ = 0.; + double fs_ = 1.; + double ts_ = 1.; + double tau_ = 1.; + double a0_ = 0.; + double b0_ = 0.; + double b1_ = 0.; + double k_ = 1.; + double lambda_ = 1.; +}; + +#ifdef BUILD_TARGET_SOM +namespace appengine::state { +class IStateVariable; +} +#endif + +#ifdef BUILD_TARGET_SOM +class Controller : public ControllerBase { +public: + bool initialize(const char *configFilePath, + appengine::IAppLogic *appLogic) override; + void step() override; + void terminate() override; + +private: + appengine::IAppLogic *appLogic_{nullptr}; + + // Beispiel: du wirst für diese ST-Logik sehr viele StateVars mappen; + // hier nur exemplarisch: + std::shared_ptr tempVariable_; + std::shared_ptr tempSetPointVariable_; + + // TODO: bool_inXX / real_inXX / bool_outXX / real_outXX / alarm_XX als + // StateVariables holen (oder je nach AppEngine: arrays/IO mapping) + + ClimateAlgorithm algo_{}; + PT1 FILTERED_TEMP{}; + PT1 FILTER_TUER{}; + // Eingänge + std::shared_ptr const_duty_cycle_; + std::shared_ptr const_freq_; + std::shared_ptr Wasserstand_Oben_Config_; + std::shared_ptr Wasserstand_Unten_Config_; + std::shared_ptr Fuellstand_Config_; + std::shared_ptr SV_Tuer_Variable_; + std::shared_ptr SV_Verdampferausgang_; + std::shared_ptr SV_Befeuchtungsmodul_; + std::shared_ptr SV_Verdichter_on_; + std::shared_ptr Startup_; + std::shared_ptr CounterTuer_; + + // ausgänge + std::vector subscriptions_{}; + std::shared_ptr Heizung_Bef_Config_; + std::shared_ptr MV_Kuehlung_Config_; + std::shared_ptr Abschlaemmen_Config_; + std::shared_ptr Entleerpumpe_Config_; + std::shared_ptr Heizung_Kesselrand_Config_; + std::shared_ptr + Freigabe_Verfluessigerluefter_Config_; + std::shared_ptr Heizung_Innenraum_Config_; + std::shared_ptr Heizung_Tuer_Config_; + std::shared_ptr Uebertemperatur_Config_; + std::shared_ptr MV_Entfeuchtung_Config_; + std::shared_ptr MV_Druckluft_Config_; + std::shared_ptr + Ansteuerung_Wassereinlass_Config_; + std::shared_ptr + Ansteuerung_Verdichter_Config_; + std::shared_ptr Verdichter_Duty_Config; + std::shared_ptr Luefter_Innenraum_Config_; + + std::shared_ptr SV_Stellgrad_Heizung; + std::shared_ptr SV_Stellgrad_Kuehlung; + std::shared_ptr SV_Stellgrad_Befeuchtung; + std::shared_ptr SV_Stellgrad_Entfeuchtung; + // Regelgrößen + std::shared_ptr SV_Sollwert_Temperatur_; + std::shared_ptr SV_Temperatur_Variable_; + std::shared_ptr SV_Sollwert_Feuchte_; + std::shared_ptr SV_Feuchte_Variable_; + + // std::vector subscriptions_{}; +}; + +extern "C" BINDER_SIMULINK_API_EXPORT ControllerBase *create(); + +#else +class Controller { + +public: + bool initialize(const char *configFilePath); + void step(); + void terminate(); + +private: +#if 0 + appengine::IAppLogic *appLogic_{nullptr}; + + // Beispiel: du wirst für diese ST-Logik sehr viele StateVars mappen; + // hier nur exemplarisch: + std::shared_ptr tempVariable_; + std::shared_ptr tempSetPointVariable_; + + // TODO: bool_inXX / real_inXX / bool_outXX / real_outXX / alarm_XX als StateVariables holen + // (oder je nach AppEngine: arrays/IO mapping) + + ClimateAlgorithm algo_{}; + PT1 FILTERED_TEMP{} ; + PT1 FILTER_TUER{}; + // Eingänge + std::shared_ptr const_duty_cycle_; + std::shared_ptr const_freq_; + std::shared_ptr Wasserstand_Oben_Config_; + std::shared_ptr Wasserstand_Unten_Config_; + std::shared_ptr Fuellstand_Config_; + std::shared_ptr SV_Tuer_Variable_; + std::shared_ptr SV_Verdampferausgang_; + std::shared_ptr SV_Befeuchtungsmodul_; + std::shared_ptr SV_Verdichter_on_; + std::shared_ptr Startup_; + std::shared_ptr CounterTuer_; + + // ausgänge + std::vector subscriptions_{}; + std::shared_ptr Heizung_Bef_Config_; + std::shared_ptr MV_Kuehlung_Config_; + std::shared_ptr Abschlaemmen_Config_; + std::shared_ptr Entleerpumpe_Config_; + std::shared_ptr Heizung_Kesselrand_Config_; + std::shared_ptr Freigabe_Verfluessigerluefter_Config_; + std::shared_ptr Heizung_Innenraum_Config_; + std::shared_ptr Heizung_Tuer_Config_; + std::shared_ptr Uebertemperatur_Config_; + std::shared_ptr MV_Entfeuchtung_Config_; + std::shared_ptr MV_Druckluft_Config_; + std::shared_ptr Ansteuerung_Wassereinlass_Config_; + std::shared_ptr Ansteuerung_Verdichter_Config_; + std::shared_ptr Verdichter_Duty_Config; + std::shared_ptr Luefter_Innenraum_Config_; + + std::shared_ptr SV_Stellgrad_Heizung; + std::shared_ptr SV_Stellgrad_Kuehlung; + std::shared_ptr SV_Stellgrad_Befeuchtung; + std::shared_ptr SV_Stellgrad_Entfeuchtung; + // Regelgrößen + std::shared_ptr SV_Sollwert_Temperatur_; + std::shared_ptr SV_Temperatur_Variable_; + std::shared_ptr SV_Sollwert_Feuchte_; + std::shared_ptr SV_Feuchte_Variable_; + + //std::vector subscriptions_{}; +#endif +}; + +#endif diff --git a/app/climate-algorithm.cpp b/app/climate-algorithm.cpp new file mode 100644 index 0000000..516ef5c --- /dev/null +++ b/app/climate-algorithm.cpp @@ -0,0 +1 @@ +// todo: create, import file header \ No newline at end of file diff --git a/app/climate-algorithm.h b/app/climate-algorithm.h new file mode 100644 index 0000000..be15a5c --- /dev/null +++ b/app/climate-algorithm.h @@ -0,0 +1,22 @@ +// todo: create, import file header + +#ifndef CLIMATE_ALGORITHM_H +#define CLIMATE_ALGORITHM_H +#include +#include + +//todo - install +// #include + +#include "filter.h" +#include "pwm.hpp" +#include "pid.h" + + +class ClimateAlgorithm { +public: +private: + +} + +#endif // CLIMATE_ALGORITHM_H diff --git a/app/datamodel.cpp b/app/datamodel.cpp new file mode 100644 index 0000000..c9abb23 --- /dev/null +++ b/app/datamodel.cpp @@ -0,0 +1,29 @@ + +/* +File: datamodel.cpp +Description: This is a C++ source file containing implementation code for a data collection (called model) used for + the realisation of a climate chamber control algorithm +Rev: 0.1 - draft +Created: 20.03.26 +Author: Uwe Jakobeit +Copyright: Binder GmbH TUT +Purpose: Configuration data and run-time datasets are provided for a controller simulation + +Notes: [Any relevant details, such as dependencies, usage examples, or known issues.] +*/ + +#include "datamodel.h" + +DataModel::DataModel() +{ + + // uj todo - set defaults, if JSON input fails + // for now only hard-coded data + Kennfeld_Ueberhitzung = Kennfeld_Ueberhitzung_Default; + // In English: + HeadlineOverheat = HeadlineOverheatDefault; + + Kennfeld_Entfeuchtung = Kennfeld_Entfeuchtung_Default; + + Kennfeld_Ueberhitzung = Kennfeld_Ueberhitzung_Default; +} \ No newline at end of file diff --git a/app/datamodel.h b/app/datamodel.h new file mode 100644 index 0000000..3de8c40 --- /dev/null +++ b/app/datamodel.h @@ -0,0 +1,64 @@ +#ifndef DATAMODEL_H +#define DATAMODEL_H + +#include "dataset.h" + + +#define HeadlineOverheat Kennfeld_Ueberhitzung +#define HeadlineOverheatDefault Kennfeld_Ueberhitzung_Default + + +class DataModel{ +public: + DataModel(); + +private: + QList> Kennfeld_Ueberhitzung; + QList> Kennfeld_Entfeuchtung; + QList> Kennfeld_Regler_Heizung_Xp; + + QList> Kennfeld_Ueberhitzung_Default = { + {-20.0, -10.0, 0.0, 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0}, // 0: Temperatur + {0.01, 0.02, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.0}, // 1: Skalierung Min + {0.01, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.0, 1.0, 1.0}, // 1: Skalierung Max + {-6.0, -8.0, -10.0, -8.0, -6.0, -8.0, -10.0, -12.0, -16.0, -20.0, -24.0, -28.0, -32.0} // 3: Sollwert Überhitzung + }; + + QList> Kennfeld_Entfeuchtung_Default{ + { -20.0, -10.0, 0.0, 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0}, // 0: Temperatur + { 0.08, 0.08, 0.08, 0.10, 0.12, 0.14, 0.16, 0.18, 0.20, 0.22, 0.24, 0.26, 0.28}, // 1: Skalierung Entfeuchtung + { 120.0, 120.0, 120.0, 120.0, 120.0, 90.0, 60.0, 60.0, 60.0, 0.0, 0.0, 0.0, 0.0}, // 2: Abtauzyklus Pause + { 60.0, 60.0, 60.0, 30.0, 20.0, 10.0, 8.0, 4.0, 2.0, 0.0, 0.0, 0.0, 0.0} // 3: Abtauzyklus Dauer + }; + + QList Kennfeld_Regler_Heizung_Xp_Default{ + 0.2, 0.5, 0.8, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0}; + + QList Kennfeld_Regler_Kuehlung_Xp{ + 0.1, 0.1, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.0}; + + QList> Kennfeld_Regler_Befeuchtung_Xp{ + {1.00, 0.54, 0.31, 0.18, 0.11, 0.07, 0.05, 0.03, 0.02}, + {1.00, 0.54, 0.31, 0.18, 0.11, 0.07, 0.05, 0.03, 0.02}, + {1.00, 0.54, 0.31, 0.18, 0.11, 0.07, 0.05, 0.03, 0.02}, + {1.00, 0.54, 0.31, 0.18, 0.11, 0.07, 0.05, 0.03, 0.02}, + {1.00, 0.54, 0.31, 0.18, 0.11, 0.07, 0.05, 0.03, 0.02}, + {1.00, 0.54, 0.31, 0.18, 0.11, 0.07, 0.05, 0.03, 0.02}, + {1.00, 0.54, 0.31, 0.18, 0.11, 0.07, 0.05, 0.03, 0.02}, + {1.00, 0.54, 0.31, 0.18, 0.11, 0.07, 0.05, 0.03, 0.02}, + {1.00, 0.54, 0.31, 0.18, 0.11, 0.07, 0.05, 0.03, 0.02}}; + + QList> Kennfeld_Regler_Entfeuchtung_Xp{ + {1.00, 0.80, 0.60, 0.50, 0.40, 0.35, 0.30, 0.25, 0.20}, + {1.00, 0.80, 0.60, 0.50, 0.40, 0.35, 0.30, 0.25, 0.20}, + {1.00, 0.80, 0.60, 0.50, 0.40, 0.35, 0.30, 0.25, 0.20}, + {1.00, 0.80, 0.60, 0.50, 0.40, 0.35, 0.30, 0.25, 0.20}, + {1.00, 0.80, 0.60, 0.50, 0.40, 0.35, 0.30, 0.25, 0.20}, + {1.00, 0.80, 0.60, 0.50, 0.40, 0.35, 0.30, 0.25, 0.20}, + {1.00, 0.80, 0.60, 0.50, 0.40, 0.35, 0.30, 0.25, 0.20}, + {1.00, 0.80, 0.60, 0.50, 0.40, 0.35, 0.30, 0.25, 0.20}, + {1.00, 0.80, 0.60, 0.50, 0.40, 0.35, 0.30, 0.25, 0.20}}; +}; + + +#endif // DATAMODEL_H diff --git a/app/dataset.cpp b/app/dataset.cpp new file mode 100644 index 0000000..d1ac897 --- /dev/null +++ b/app/dataset.cpp @@ -0,0 +1,60 @@ +/* +File: dataset.cpp +Description: This is a C++ source file containing implementation code handling configuration data +Rev: 0.1 +Created: 20.03.2026 +Author: Uwe Jakobeit +Copyright: Binder GmbH, TUT 2026 +Purpose: [Briefly describe the file's functionality, e.g., "Implements a class for managing user data."] + Implementation of classes which provide changes of dataset without (re-)comiling +Notes: [Any relevant details, such as dependencies, usage examples, or known issues.] +*/ + + +#include "dataset.h" + + +using namespace std; + +// Read config file and setup headlines ( characteristics ) +Dataset::Dataset(QString& configFile) +{ + // headline << &mHeadLineTemperature + // << &mHeadLineHumidity + // << &mHeadLineOverheat; + + + // Now you can create a QVector of pointers to QVectorBase + QVector mixedVectors; + +// QVector mHeadlineVector; + + + + + // Usage + QVector intVec = {1, 2, 3}; + QVector dblVec = {1.0, 2, 3}; + + QVector stringVec = {"hello", "world"}; + + mixedVectors.append(new QVectorWrapper(intVec)); + mixedVectors.append(new QVectorWrapper(stringVec)); + + mHeadlineVector.append(new QVectorWrapper(intVec)); + mHeadlineVector.append(new QVectorWrapper(stringVec)); + + // Iterate and use polymorphic behavior + for (QVectorBase* vec : mixedVectors) { + vec->print(); + } + // // Clean up + // qDeleteAll(mixedVectors); + // mixedVectors.clear(); +} + +QVectorBase* Dataset::HeadLine(uint8_t LineId) +{ + + return mHeadlineVector.at(LineId); +} diff --git a/app/dataset.h b/app/dataset.h new file mode 100644 index 0000000..b3822fe --- /dev/null +++ b/app/dataset.h @@ -0,0 +1,69 @@ +// #include +// #include +// #include +#include +#include + +using namespace std; +enum class LineId { + Temperature, + Humidity, + OverHeat +}; + + +#if 0 +class Dataset{ + +public: + Dataset(QString& configFile); + + // return headlines (Kennlinien) of known types from ST code + QVector* HeadLine(enum class LineId); +private: + + // Class members (m_, but don't like the '_' ) + vector headline; + + vector mHeadLineTemperature; + vector mHeadLineOverheat; + vector mHeadLineHumidity; +}; + +#endif + +#include +#include + + + + +// Forward declaration of a base class for polymorphic behavior +class QVectorBase { +public: + virtual ~QVectorBase() = default; + virtual void print() const = 0; +}; + +// Template class to wrap a QVector and inherit from QVectorBase +template +class QVectorWrapper : public QVectorBase { +public: + QVector vec; + + QVectorWrapper() = default; + explicit QVectorWrapper(const QVector& v) : vec(v) {} + + void print() const override { + qDebug() << "Vector of" << sizeof(T) << "bytes:" << vec; + } +}; + +class Dataset{ + public: + Dataset(QString& configFile); + QVectorBase *HeadLine(uint8_t LineId); + + private: + QVector mHeadlineVector; +}; \ No newline at end of file diff --git a/app/filter.cpp b/app/filter.cpp new file mode 100644 index 0000000..b1bbf3f --- /dev/null +++ b/app/filter.cpp @@ -0,0 +1,20 @@ +#include "filter.h" + +PT1Filter::PT1Filter(double tau, double dt) : output(0.0) { + filterFactor = dt / (tau + dt); +} + +double PT1Filter::update(double input) { + output += filterFactor * (input - output); + return output; +} + +double PT1Filter::step(double input) { + output += filterFactor * (input - output); + return output; +}; + + +void PT1Filter::reset() { + output = 0.0; +} \ No newline at end of file diff --git a/app/filter.h b/app/filter.h new file mode 100644 index 0000000..0b221d4 --- /dev/null +++ b/app/filter.h @@ -0,0 +1,20 @@ +#ifndef FILTER_H +#define FILTER_H + +#pragma once + +class PT1Filter { +private: + double output; + double filterFactor; + +public: + PT1Filter(double tau, double dt); + double update(double input); + double step(double input); + void reset(); +}; + + + +#endif // FILTER_H diff --git a/app/main.cpp b/app/main.cpp new file mode 100644 index 0000000..55bdef2 --- /dev/null +++ b/app/main.cpp @@ -0,0 +1,30 @@ +#include +#include + +#include "Controller.hpp" + +int main(int argc, char *argv[]) +{ + QCoreApplication a(argc, argv); + + // Set up code that uses the Qt event loop here. + // Call QCoreApplication::quit() or QCoreApplication::exit() to quit the application. + // A not very useful example would be including + // #include + // near the top of the file and calling + // QTimer::singleShot(5000, &a, &QCoreApplication::quit); + // which quits the application after 5 seconds. + + // If you do not need a running Qt event loop, remove the call + // to QCoreApplication::exec() or use the Non-Qt Plain C++ Application template. + + Controller bbr; + + + qDebug() << "Perform one bbr setp"; + bbr.step(); + + return 0; + + // return QCoreApplication::exec(); +} diff --git a/app/pid.cpp b/app/pid.cpp new file mode 100644 index 0000000..5d71a58 --- /dev/null +++ b/app/pid.cpp @@ -0,0 +1,9 @@ +// todo: create, import file header + +#include "pid.h" + +PID::PID() +{ + +} + diff --git a/app/pid.h b/app/pid.h new file mode 100644 index 0000000..b17daff --- /dev/null +++ b/app/pid.h @@ -0,0 +1,12 @@ +#ifndef PWM_H +#define PWM_H + +class PID{ +public: + PID(); + +private: + +}; + +#endif //PWM_H diff --git a/app/pwm.cpp b/app/pwm.cpp new file mode 100644 index 0000000..10fcb82 --- /dev/null +++ b/app/pwm.cpp @@ -0,0 +1,18 @@ +// todo: create, import file header + +#include "pwm.h" + +PWM::PWM(double cycleTime_Min,double cycleTime_Max) +{ + m_cycle = 0.0; + m_out = 0.0; + m_cycleTime = 0.0; + m_cycleTime_Min = cycleTime_Min; + m_cycleTime_Max = cycleTime_Max; +} + +bool PWM::step(double setValue,double samplingTime) +{ + bool output_bool; + return output_bool; +} diff --git a/app/pwm.h b/app/pwm.h new file mode 100644 index 0000000..665f013 --- /dev/null +++ b/app/pwm.h @@ -0,0 +1,20 @@ +#ifndef PWM_H +#define PWM_H + +#include + +class PWM +{ +public: + PWM(double cycleTime_Min,double cycleTime_Max); + + bool step(double setValue,double samplingTime); + +private: + double m_cycle = 0.0; + double m_out = 0.0; + double m_cycleTime = 0.0; + double m_cycleTime_Min = 0.0; + double m_cycleTime_Max = 0.0; +}; +#endif // PWM_H diff --git a/app/text-templates.h b/app/text-templates.h new file mode 100644 index 0000000..4d1fffc --- /dev/null +++ b/app/text-templates.h @@ -0,0 +1,19 @@ +// CPP Source file header ( as well h-file header, so far (20.03.26) + +/* +File: filename.cpp +Description: This is a C++ source file containing implementation code for a program or library component. +Rev: 0.1 +Created: [Date] +Author: [Your Name] +Copyright: [Your Organization or Name] [Year(s)] +Purpose: [Briefly describe the file's functionality, e.g., "Implements a class for managing user data."] +Notes: [Any relevant details, such as dependencies, usage examples, or known issues.] +*/ + + +// CPP Source function header +// todo + +// Header file function header +// todo \ No newline at end of file diff --git a/config/CMakeLists.txt b/config/CMakeLists.txt new file mode 100644 index 0000000..f2f450e --- /dev/null +++ b/config/CMakeLists.txt @@ -0,0 +1,38 @@ + +if(0) + +# qt_standard_project_setup() + +# qt_add_executable(app main.cpp +# ) + +add_library(config_lib STATIC dataset.h dataset.cpp + ) + +target_include_directories(config_lib PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}) +target_include_directories(config_lib PRIVATE ${Qt6Core_INCLUDE_DIRS}) + +# add_executable(app main.cpp filter.cpp) +target_link_libraries(app PRIVATE config_lib +) +endif() + + +qt_standard_project_setup() + +qt_add_executable(app main.cpp + ) + +qt_add_library(config_lib STATIC dataset.h dataset.cpp +) + + +target_include_directories(config_lib PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}) +target_include_directories(config_lib PRIVATE ${Qt6Core_INCLUDE_DIRS}) + +# add_executable(app main.cpp filter.cpp) +target_link_libraries(app PRIVATE + config_lib + Qt::Core +) + diff --git a/ks/CMakeLists.txt b/ks/CMakeLists.txt new file mode 100644 index 0000000..33b6305 --- /dev/null +++ b/ks/CMakeLists.txt @@ -0,0 +1,25 @@ +cmake_minimum_required(VERSION 3.28) +project(ks_lib LANGUAGES CXX) + +qt_standard_project_setup() + +file(GLOB_RECURSE SOURCES CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp") +file(GLOB_RECURSE HEADERS CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/*.hpp") + + +# qt_add_executable(ks main.cpp +# ) + +qt_add_library(${PROJECT_NAME} STATIC main.cpp + ${SOURCES} + ${HEADERS} + ) + +target_include_directories(${PROJECT_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/Models/FP56/Model_grt_rtw) +target_include_directories(${PROJECT_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}) +target_include_directories(${PROJECT_NAME} PRIVATE ${Qt6Core_INCLUDE_DIRS}) + +# add_executable(app main.cpp filter.cpp) +target_link_libraries(${PROJECT_NAME} PRIVATE + Qt::Core +) diff --git a/ks/Models/FP56/Model.slx b/ks/Models/FP56/Model.slx new file mode 100755 index 0000000000000000000000000000000000000000..c0ee9259222eddbfc81c720684040557628ff489 GIT binary patch literal 33044 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 literal 0 HcmV?d00001 diff --git a/ks/Models/FP56/Model.slx.autosave b/ks/Models/FP56/Model.slx.autosave new file mode 100755 index 0000000000000000000000000000000000000000..f276a21d4f3347d7a32c847740db8359b55494fb GIT binary patch literal 22141 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

    MDXWD?^-Kk^WJ(#T@AiIJ%S%<;SZ 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 literal 0 HcmV?d00001 diff --git a/ks/Models/FP56/Model_grt_rtw/Model.bat b/ks/Models/FP56/Model_grt_rtw/Model.bat new file mode 100755 index 0000000..5d341b8 --- /dev/null +++ b/ks/Models/FP56/Model_grt_rtw/Model.bat @@ -0,0 +1,16 @@ + +set skipSetupArg=%2 +if "%skipSetupArg%" NEQ "skip_setup_msvc" ( +call "setup_msvc.bat" +) + +cd . + +if "%1"=="" (nmake -f Model.mk all) else (nmake -f Model.mk %1) +@if errorlevel 1 goto error_exit + +exit /B 0 + +:error_exit +echo The make command returned an error of %errorlevel% +exit /B 1 \ No newline at end of file diff --git a/ks/Models/FP56/Model_grt_rtw/Model.cpp b/ks/Models/FP56/Model_grt_rtw/Model.cpp new file mode 100755 index 0000000..c72bf89 --- /dev/null +++ b/ks/Models/FP56/Model_grt_rtw/Model.cpp @@ -0,0 +1,358 @@ +/* + * Model.cpp + * + * Code generation for model "Model". + * + * Model version : 1.2 + * Simulink Coder version : 9.7 (R2022a) 13-Nov-2021 + * C++ source code generated on : Sat Mar 28 11:28:04 2026 + * + * Target selection: grt.tlc + * Note: GRT includes extra infrastructure and instrumentation for prototyping + * Embedded hardware selection: Intel->x86-64 (Windows64) + * Code generation objectives: Unspecified + * Validation result: Not run + */ + +#include "Model.h" +#include "rtwtypes.h" +#include "Model_private.h" + +extern "C" { + +#include "rt_nonfinite.h" + +} +/* + * This function updates continuous states using the ODE3 fixed-step + * solver algorithm + */ + void Model::rt_ertODEUpdateContinuousStates(RTWSolverInfo *si ) +{ + /* Solver Matrices */ + static const real_T rt_ODE3_A[3]{ + 1.0/2.0, 3.0/4.0, 1.0 + }; + + static const real_T rt_ODE3_B[3][3]{ + { 1.0/2.0, 0.0, 0.0 }, + + { 0.0, 3.0/4.0, 0.0 }, + + { 2.0/9.0, 1.0/3.0, 4.0/9.0 } + }; + + time_T t { rtsiGetT(si) }; + + time_T tnew { rtsiGetSolverStopTime(si) }; + + time_T h { rtsiGetStepSize(si) }; + + real_T *x { rtsiGetContStates(si) }; + + ODE3_IntgData *id { static_cast(rtsiGetSolverData(si)) }; + + real_T *y { id->y }; + + real_T *f0 { id->f[0] }; + + real_T *f1 { id->f[1] }; + + real_T *f2 { id->f[2] }; + + real_T hB[3]; + int_T i; + int_T nXc { 3 }; + + rtsiSetSimTimeStep(si,MINOR_TIME_STEP); + + /* Save the state values at time t in y, we'll use x as ynew. */ + (void) std::memcpy(y, x, + static_cast(nXc)*sizeof(real_T)); + + /* Assumes that rtsiSetT and ModelOutputs are up-to-date */ + /* f0 = f(t,y) */ + rtsiSetdX(si, f0); + Model_derivatives(); + + /* f(:,2) = feval(odefile, t + hA(1), y + f*hB(:,1), args(:)(*)); */ + hB[0] = h * rt_ODE3_B[0][0]; + for (i = 0; i < nXc; i++) { + x[i] = y[i] + (f0[i]*hB[0]); + } + + rtsiSetT(si, t + h*rt_ODE3_A[0]); + rtsiSetdX(si, f1); + this->step(); + Model_derivatives(); + + /* f(:,3) = feval(odefile, t + hA(2), y + f*hB(:,2), args(:)(*)); */ + for (i = 0; i <= 1; i++) { + hB[i] = h * rt_ODE3_B[1][i]; + } + + for (i = 0; i < nXc; i++) { + x[i] = y[i] + (f0[i]*hB[0] + f1[i]*hB[1]); + } + + rtsiSetT(si, t + h*rt_ODE3_A[1]); + rtsiSetdX(si, f2); + this->step(); + Model_derivatives(); + + /* tnew = t + hA(3); + ynew = y + f*hB(:,3); */ + for (i = 0; i <= 2; i++) { + hB[i] = h * rt_ODE3_B[2][i]; + } + + for (i = 0; i < nXc; i++) { + x[i] = y[i] + (f0[i]*hB[0] + f1[i]*hB[1] + f2[i]*hB[2]); + } + + rtsiSetT(si, tnew); + rtsiSetSimTimeStep(si,MAJOR_TIME_STEP); +} + +/* Model step function */ +void Model::step() +{ + real_T rtb_Gain1; + real_T rtb_Gain4; + if (rtmIsMajorTimeStep((&Model_M))) { + /* set solver stop time */ + if (!((&Model_M)->Timing.clockTick0+1)) { + rtsiSetSolverStopTime(&(&Model_M)->solverInfo, (((&Model_M) + ->Timing.clockTickH0 + 1) * (&Model_M)->Timing.stepSize0 * 4294967296.0)); + } else { + rtsiSetSolverStopTime(&(&Model_M)->solverInfo, (((&Model_M) + ->Timing.clockTick0 + 1) * (&Model_M)->Timing.stepSize0 + (&Model_M) + ->Timing.clockTickH0 * (&Model_M)->Timing.stepSize0 * 4294967296.0)); + } + } /* end MajorTimeStep */ + + /* Update absolute time of base rate at minor time step */ + if (rtmIsMinorTimeStep((&Model_M))) { + (&Model_M)->Timing.t[0] = rtsiGetT(&(&Model_M)->solverInfo); + } + + /* Outport: '/Temperatur' incorporates: + * Integrator: '/Integrator1' + */ + Model_Y.Temperatur = Model_X.Integrator1_CSTATE; + + /* Gain: '/Gain1' incorporates: + * Integrator: '/Integrator' + * Integrator: '/Integrator1' + * Sum: '/Plus1' + */ + rtb_Gain1 = Model_P.alphaHD * Model_P.AHD * (Model_X.Integrator_CSTATE - + Model_X.Integrator1_CSTATE); + + /* Gain: '/Gain' incorporates: + * Inport: '/Stellgrad' + * Sum: '/Plus' + */ + Model_B.Gain = 1.0 / (Model_P.mHD * Model_P.CHD) * (Model_U.Stellgrad - + rtb_Gain1); + + /* Gain: '/Gain4' incorporates: + * Integrator: '/Integrator1' + * Integrator: '/Integrator2' + * Sum: '/Plus4' + */ + rtb_Gain4 = Model_P.alphaSW * Model_P.Ai * (Model_X.Integrator1_CSTATE - + Model_X.Integrator2_CSTATE); + + /* Gain: '/Gain2' incorporates: + * Sum: '/Plus2' + */ + Model_B.Gain2 = 1.0 / (Model_P.ml * Model_P.Cl + Model_P.mES * Model_P.CES) * + (rtb_Gain1 - rtb_Gain4); + + /* Gain: '/Gain5' incorporates: + * Constant: '/Constant' + * Gain: '/Gain7' + * Integrator: '/Integrator2' + * Sum: '/Plus5' + * Sum: '/Plus7' + */ + Model_B.Gain5 = (rtb_Gain4 - Model_P.alpha_aussen * Model_P.A_Aussen * + (Model_X.Integrator2_CSTATE - Model_P.Constant_Value)) * (1.0 + / (Model_P.mSW * Model_P.CSW)); + if (rtmIsMajorTimeStep((&Model_M))) { + /* Matfile logging */ + rt_UpdateTXYLogVars((&Model_M)->rtwLogInfo, ((&Model_M)->Timing.t)); + } /* end MajorTimeStep */ + + if (rtmIsMajorTimeStep((&Model_M))) { + /* signal main to stop simulation */ + { /* Sample time: [0.0s, 0.0s] */ + if ((rtmGetTFinal((&Model_M))!=-1) && + !((rtmGetTFinal((&Model_M))-((((&Model_M)->Timing.clockTick1+(&Model_M) + ->Timing.clockTickH1* 4294967296.0)) * 0.05)) > ((((&Model_M) + ->Timing.clockTick1+(&Model_M)->Timing.clockTickH1* 4294967296.0)) + * 0.05) * (DBL_EPSILON))) { + rtmSetErrorStatus((&Model_M), "Simulation finished"); + } + } + + rt_ertODEUpdateContinuousStates(&(&Model_M)->solverInfo); + + /* Update absolute time for base rate */ + /* The "clockTick0" counts the number of times the code of this task has + * been executed. The absolute time is the multiplication of "clockTick0" + * and "Timing.stepSize0". 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. + */ + if (!(++(&Model_M)->Timing.clockTick0)) { + ++(&Model_M)->Timing.clockTickH0; + } + + (&Model_M)->Timing.t[0] = rtsiGetSolverStopTime(&(&Model_M)->solverInfo); + + { + /* Update absolute timer for sample time: [0.05s, 0.0s] */ + /* The "clockTick1" counts the number of times the code of this task has + * been executed. The resolution of this integer timer is 0.05, which is the step size + * of the task. Size of "clockTick1" 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.clockTick1 and the high bits + * Timing.clockTickH1. When the low bit overflows to 0, the high bits increment. + */ + (&Model_M)->Timing.clockTick1++; + if (!(&Model_M)->Timing.clockTick1) { + (&Model_M)->Timing.clockTickH1++; + } + } + } /* end MajorTimeStep */ +} + +/* Derivatives for root system: '' */ +void Model::Model_derivatives() +{ + XDot_Model_T *_rtXdot; + _rtXdot = ((XDot_Model_T *) (&Model_M)->derivs); + + /* Derivatives for Integrator: '/Integrator1' */ + _rtXdot->Integrator1_CSTATE = Model_B.Gain2; + + /* Derivatives for Integrator: '/Integrator' */ + _rtXdot->Integrator_CSTATE = Model_B.Gain; + + /* Derivatives for Integrator: '/Integrator2' */ + _rtXdot->Integrator2_CSTATE = Model_B.Gain5; +} + +/* Model initialize function */ +void Model::initialize() +{ + /* Registration code */ + + /* initialize non-finites */ + rt_InitInfAndNaN(sizeof(real_T)); + + { + /* Setup solver object */ + rtsiSetSimTimeStepPtr(&(&Model_M)->solverInfo, &(&Model_M) + ->Timing.simTimeStep); + rtsiSetTPtr(&(&Model_M)->solverInfo, &rtmGetTPtr((&Model_M))); + rtsiSetStepSizePtr(&(&Model_M)->solverInfo, &(&Model_M)->Timing.stepSize0); + rtsiSetdXPtr(&(&Model_M)->solverInfo, &(&Model_M)->derivs); + rtsiSetContStatesPtr(&(&Model_M)->solverInfo, (real_T **) &(&Model_M) + ->contStates); + rtsiSetNumContStatesPtr(&(&Model_M)->solverInfo, &(&Model_M) + ->Sizes.numContStates); + rtsiSetNumPeriodicContStatesPtr(&(&Model_M)->solverInfo, &(&Model_M) + ->Sizes.numPeriodicContStates); + rtsiSetPeriodicContStateIndicesPtr(&(&Model_M)->solverInfo, &(&Model_M) + ->periodicContStateIndices); + rtsiSetPeriodicContStateRangesPtr(&(&Model_M)->solverInfo, &(&Model_M) + ->periodicContStateRanges); + rtsiSetErrorStatusPtr(&(&Model_M)->solverInfo, (&rtmGetErrorStatus((&Model_M)))); + rtsiSetRTModelPtr(&(&Model_M)->solverInfo, (&Model_M)); + } + + rtsiSetSimTimeStep(&(&Model_M)->solverInfo, MAJOR_TIME_STEP); + (&Model_M)->intgData.y = (&Model_M)->odeY; + (&Model_M)->intgData.f[0] = (&Model_M)->odeF[0]; + (&Model_M)->intgData.f[1] = (&Model_M)->odeF[1]; + (&Model_M)->intgData.f[2] = (&Model_M)->odeF[2]; + (&Model_M)->contStates = ((X_Model_T *) &Model_X); + rtsiSetSolverData(&(&Model_M)->solverInfo, static_cast(&(&Model_M) + ->intgData)); + rtsiSetIsMinorTimeStepWithModeChange(&(&Model_M)->solverInfo, false); + rtsiSetSolverName(&(&Model_M)->solverInfo,"ode3"); + rtmSetTPtr((&Model_M), &(&Model_M)->Timing.tArray[0]); + rtmSetTFinal((&Model_M), 10.0); + (&Model_M)->Timing.stepSize0 = 0.05; + + /* Setup for data logging */ + { + static RTWLogInfo rt_DataLoggingInfo; + rt_DataLoggingInfo.loggingInterval = (nullptr); + (&Model_M)->rtwLogInfo = &rt_DataLoggingInfo; + } + + /* Setup for data logging */ + { + rtliSetLogXSignalInfo((&Model_M)->rtwLogInfo, (nullptr)); + rtliSetLogXSignalPtrs((&Model_M)->rtwLogInfo, (nullptr)); + rtliSetLogT((&Model_M)->rtwLogInfo, "tout"); + rtliSetLogX((&Model_M)->rtwLogInfo, ""); + rtliSetLogXFinal((&Model_M)->rtwLogInfo, ""); + rtliSetLogVarNameModifier((&Model_M)->rtwLogInfo, "rt_"); + rtliSetLogFormat((&Model_M)->rtwLogInfo, 4); + rtliSetLogMaxRows((&Model_M)->rtwLogInfo, 0); + rtliSetLogDecimation((&Model_M)->rtwLogInfo, 1); + rtliSetLogY((&Model_M)->rtwLogInfo, ""); + rtliSetLogYSignalInfo((&Model_M)->rtwLogInfo, (nullptr)); + rtliSetLogYSignalPtrs((&Model_M)->rtwLogInfo, (nullptr)); + } + + /* Matfile logging */ + rt_StartDataLoggingWithStartTime((&Model_M)->rtwLogInfo, 0.0, rtmGetTFinal + ((&Model_M)), (&Model_M)->Timing.stepSize0, (&rtmGetErrorStatus((&Model_M)))); + + /* InitializeConditions for Integrator: '/Integrator1' */ + Model_X.Integrator1_CSTATE = Model_P.T_amb; + + /* InitializeConditions for Integrator: '/Integrator' */ + Model_X.Integrator_CSTATE = Model_P.T_amb; + + /* InitializeConditions for Integrator: '/Integrator2' */ + Model_X.Integrator2_CSTATE = Model_P.T_amb; +} + +/* Model terminate function */ +void Model::terminate() +{ + /* (no terminate code required) */ +} + +/* Constructor */ +Model::Model() : + Model_U(), + Model_Y(), + Model_B(), + Model_X(), + Model_M() +{ + /* Currently there is no constructor body generated.*/ +} + +/* Destructor */ +Model::~Model() +{ + /* Currently there is no destructor body generated.*/ +} + +/* Real-Time Model get method */ +RT_MODEL_Model_T * Model::getRTM() +{ + return (&Model_M); +} diff --git a/ks/Models/FP56/Model_grt_rtw/Model.h b/ks/Models/FP56/Model_grt_rtw/Model.h new file mode 100644 index 0000000..f49784c --- /dev/null +++ b/ks/Models/FP56/Model_grt_rtw/Model.h @@ -0,0 +1,408 @@ +/* + * Model.h + * + * Code generation for model "Model". + * + * Model version : 1.1 + * Simulink Coder version : 9.7 (R2022a) 13-Nov-2021 + * C++ source code generated on : Thu Mar 26 17:54:04 2026 + * + * Target selection: grt.tlc + * Note: GRT includes extra infrastructure and instrumentation for prototyping + * Embedded hardware selection: Intel->x86-64 (Windows64) + * Code generation objectives: Unspecified + * Validation result: Not run + */ + +#ifndef RTW_HEADER_Model_h_ +#define RTW_HEADER_Model_h_ +#include "rtwtypes.h" +#include "rtw_continuous.h" +#include "rtw_solver.h" +#include "rt_logging.h" +#include "Model_types.h" +#include +#include + +extern "C" { + +#include "rt_nonfinite.h" + +} +/* Macros for accessing real-time model data structure */ +#ifndef rtmGetContStateDisabled +#define rtmGetContStateDisabled(rtm) ((rtm)->contStateDisabled) +#endif + +#ifndef rtmSetContStateDisabled +#define rtmSetContStateDisabled(rtm, val) ((rtm)->contStateDisabled = (val)) +#endif + +#ifndef rtmGetContStates +#define rtmGetContStates(rtm) ((rtm)->contStates) +#endif + +#ifndef rtmSetContStates +#define rtmSetContStates(rtm, val) ((rtm)->contStates = (val)) +#endif + +#ifndef rtmGetContTimeOutputInconsistentWithStateAtMajorStepFlag +#define rtmGetContTimeOutputInconsistentWithStateAtMajorStepFlag(rtm) ((rtm)->CTOutputIncnstWithState) +#endif + +#ifndef rtmSetContTimeOutputInconsistentWithStateAtMajorStepFlag +#define rtmSetContTimeOutputInconsistentWithStateAtMajorStepFlag(rtm, val) ((rtm)->CTOutputIncnstWithState = (val)) +#endif + +#ifndef rtmGetDerivCacheNeedsReset +#define rtmGetDerivCacheNeedsReset(rtm) ((rtm)->derivCacheNeedsReset) +#endif + +#ifndef rtmSetDerivCacheNeedsReset +#define rtmSetDerivCacheNeedsReset(rtm, val) ((rtm)->derivCacheNeedsReset = (val)) +#endif + +#ifndef rtmGetFinalTime +#define rtmGetFinalTime(rtm) ((rtm)->Timing.tFinal) +#endif + +#ifndef rtmGetIntgData +#define rtmGetIntgData(rtm) ((rtm)->intgData) +#endif + +#ifndef rtmSetIntgData +#define rtmSetIntgData(rtm, val) ((rtm)->intgData = (val)) +#endif + +#ifndef rtmGetOdeF +#define rtmGetOdeF(rtm) ((rtm)->odeF) +#endif + +#ifndef rtmSetOdeF +#define rtmSetOdeF(rtm, val) ((rtm)->odeF = (val)) +#endif + +#ifndef rtmGetOdeY +#define rtmGetOdeY(rtm) ((rtm)->odeY) +#endif + +#ifndef rtmSetOdeY +#define rtmSetOdeY(rtm, val) ((rtm)->odeY = (val)) +#endif + +#ifndef rtmGetPeriodicContStateIndices +#define rtmGetPeriodicContStateIndices(rtm) ((rtm)->periodicContStateIndices) +#endif + +#ifndef rtmSetPeriodicContStateIndices +#define rtmSetPeriodicContStateIndices(rtm, val) ((rtm)->periodicContStateIndices = (val)) +#endif + +#ifndef rtmGetPeriodicContStateRanges +#define rtmGetPeriodicContStateRanges(rtm) ((rtm)->periodicContStateRanges) +#endif + +#ifndef rtmSetPeriodicContStateRanges +#define rtmSetPeriodicContStateRanges(rtm, val) ((rtm)->periodicContStateRanges = (val)) +#endif + +#ifndef rtmGetRTWLogInfo +#define rtmGetRTWLogInfo(rtm) ((rtm)->rtwLogInfo) +#endif + +#ifndef rtmGetZCCacheNeedsReset +#define rtmGetZCCacheNeedsReset(rtm) ((rtm)->zCCacheNeedsReset) +#endif + +#ifndef rtmSetZCCacheNeedsReset +#define rtmSetZCCacheNeedsReset(rtm, val) ((rtm)->zCCacheNeedsReset = (val)) +#endif + +#ifndef rtmGetdX +#define rtmGetdX(rtm) ((rtm)->derivs) +#endif + +#ifndef rtmSetdX +#define rtmSetdX(rtm, val) ((rtm)->derivs = (val)) +#endif + +#ifndef rtmGetErrorStatus +#define rtmGetErrorStatus(rtm) ((rtm)->errorStatus) +#endif + +#ifndef rtmSetErrorStatus +#define rtmSetErrorStatus(rtm, val) ((rtm)->errorStatus = (val)) +#endif + +#ifndef rtmGetStopRequested +#define rtmGetStopRequested(rtm) ((rtm)->Timing.stopRequestedFlag) +#endif + +#ifndef rtmSetStopRequested +#define rtmSetStopRequested(rtm, val) ((rtm)->Timing.stopRequestedFlag = (val)) +#endif + +#ifndef rtmGetStopRequestedPtr +#define rtmGetStopRequestedPtr(rtm) (&((rtm)->Timing.stopRequestedFlag)) +#endif + +#ifndef rtmGetT +#define rtmGetT(rtm) (rtmGetTPtr((rtm))[0]) +#endif + +#ifndef rtmGetTFinal +#define rtmGetTFinal(rtm) ((rtm)->Timing.tFinal) +#endif + +#ifndef rtmGetTPtr +#define rtmGetTPtr(rtm) ((rtm)->Timing.t) +#endif + +/* Block signals (default storage) */ +struct B_Model_T { + real_T Gain; /* '/Gain' */ + real_T Gain2; /* '/Gain2' */ + real_T Gain5; /* '/Gain5' */ +}; + +/* Continuous states (default storage) */ +struct X_Model_T { + real_T Integrator1_CSTATE; /* '/Integrator1' */ + real_T Integrator_CSTATE; /* '/Integrator' */ + real_T Integrator2_CSTATE; /* '/Integrator2' */ +}; + +/* State derivatives (default storage) */ +struct XDot_Model_T { + real_T Integrator1_CSTATE; /* '/Integrator1' */ + real_T Integrator_CSTATE; /* '/Integrator' */ + real_T Integrator2_CSTATE; /* '/Integrator2' */ +}; + +/* State disabled */ +struct XDis_Model_T { + boolean_T Integrator1_CSTATE; /* '/Integrator1' */ + boolean_T Integrator_CSTATE; /* '/Integrator' */ + boolean_T Integrator2_CSTATE; /* '/Integrator2' */ +}; + +#ifndef ODE3_INTG +#define ODE3_INTG + +/* ODE3 Integration Data */ +struct ODE3_IntgData { + real_T *y; /* output */ + real_T *f[3]; /* derivatives */ +}; + +#endif + +/* External inputs (root inport signals with default storage) */ +struct ExtU_Model_T { + real_T Stellgrad; /* '/Stellgrad' */ +}; + +/* External outputs (root outports fed by signals with default storage) */ +struct ExtY_Model_T { + real_T Temperatur; /* '/Temperatur' */ +}; + +/* Parameters (default storage) */ +struct P_Model_T_ { + real_T AHD; /* Variable: AHD + * Referenced by: '/Gain1' + */ + real_T A_Aussen; /* Variable: A_Aussen + * Referenced by: '/Gain7' + */ + real_T Ai; /* Variable: Ai + * Referenced by: '/Gain4' + */ + real_T CES; /* Variable: CES + * Referenced by: '/Gain2' + */ + real_T CHD; /* Variable: CHD + * Referenced by: '/Gain' + */ + real_T CSW; /* Variable: CSW + * Referenced by: '/Gain5' + */ + real_T Cl; /* Variable: Cl + * Referenced by: '/Gain2' + */ + real_T T_amb; /* Variable: T_amb + * Referenced by: + * '/Integrator' + * '/Integrator1' + * '/Integrator2' + */ + real_T alphaHD; /* Variable: alphaHD + * Referenced by: '/Gain1' + */ + real_T alphaSW; /* Variable: alphaSW + * Referenced by: '/Gain4' + */ + real_T alpha_aussen; /* Variable: alpha_aussen + * Referenced by: '/Gain7' + */ + real_T mES; /* Variable: mES + * Referenced by: '/Gain2' + */ + real_T mHD; /* Variable: mHD + * Referenced by: '/Gain' + */ + real_T mSW; /* Variable: mSW + * Referenced by: '/Gain5' + */ + real_T ml; /* Variable: ml + * Referenced by: '/Gain2' + */ + real_T Constant_Value; /* Expression: 0 + * Referenced by: '/Constant' + */ +}; + +/* Real-time Model Data Structure */ +struct tag_RTM_Model_T { + const char_T *errorStatus; + RTWLogInfo *rtwLogInfo; + RTWSolverInfo solverInfo; + X_Model_T *contStates; + int_T *periodicContStateIndices; + real_T *periodicContStateRanges; + real_T *derivs; + boolean_T *contStateDisabled; + boolean_T zCCacheNeedsReset; + boolean_T derivCacheNeedsReset; + boolean_T CTOutputIncnstWithState; + real_T odeY[3]; + real_T odeF[3][3]; + ODE3_IntgData intgData; + + /* + * Sizes: + * The following substructure contains sizes information + * for many of the model attributes such as inputs, outputs, + * dwork, sample times, etc. + */ + struct { + int_T numContStates; + int_T numPeriodicContStates; + int_T numSampTimes; + } Sizes; + + /* + * Timing: + * The following substructure contains information regarding + * the timing information for the model. + */ + struct { + uint32_T clockTick0; + uint32_T clockTickH0; + time_T stepSize0; + uint32_T clockTick1; + uint32_T clockTickH1; + time_T tFinal; + SimTimeStep simTimeStep; + boolean_T stopRequestedFlag; + time_T *t; + time_T tArray[2]; + } Timing; +}; + +/* Block parameters (default storage) */ +#ifdef __cplusplus + +extern "C" { + +#endif + + extern P_Model_T Model_P; + +#ifdef __cplusplus + +} +#endif + +/* Block signals (default storage) */ +#ifdef __cplusplus + +extern "C" { + +#endif + + extern struct B_Model_T Model_B; + +#ifdef __cplusplus + +} +#endif + +/* Continuous states (default storage) */ +extern X_Model_T Model_X; + +#ifdef __cplusplus + +extern "C" { + +#endif + + /* External inputs (root inport signals with default storage) */ + extern struct ExtU_Model_T Model_U; + + /* External outputs (root outports fed by signals with default storage) */ + extern struct ExtY_Model_T Model_Y; + +#ifdef __cplusplus + +} +#endif + +#ifdef __cplusplus + +extern "C" { + +#endif + + /* Model entry point functions */ + extern void Model_initialize(void); + extern void Model_step(void); + extern void Model_terminate(void); + +#ifdef __cplusplus + +} +#endif + +/* Real-time Model object */ +#ifdef __cplusplus + +extern "C" { + +#endif + + extern RT_MODEL_Model_T *const Model_M; + +#ifdef __cplusplus + +} +#endif + +/*- + * The generated code includes comments that allow you to trace directly + * back to the appropriate location in the model. The basic format + * is /block_name, where system is the system number (uniquely + * assigned by Simulink) and block_name is the name of the block. + * + * Use the MATLAB hilite_system command to trace the generated code back + * to the model. For example, + * + * hilite_system('') - opens system 3 + * hilite_system('/Kp') - opens and selects block Kp which resides in S3 + * + * Here is the system hierarchy for this model + * + * '' : 'Model' + * '' : 'Model/Subsystem3' + */ +#endif /* RTW_HEADER_Model_h_ */ diff --git a/ks/Models/FP56/Model_grt_rtw/Model.mk b/ks/Models/FP56/Model_grt_rtw/Model.mk new file mode 100755 index 0000000..c3c2f80 --- /dev/null +++ b/ks/Models/FP56/Model_grt_rtw/Model.mk @@ -0,0 +1,426 @@ +########################################################################### +## Makefile generated for component 'Model'. +## +## Makefile : Model.mk +## Generated on : Sat Mar 28 11:28:08 2026 +## Final product: $(RELATIVE_PATH_TO_ANCHOR)\Model.exe +## Product type : executable +## +########################################################################### + +########################################################################### +## MACROS +########################################################################### + +# Macro Descriptions: +# PRODUCT_NAME Name of the system to build +# MAKEFILE Name of this makefile +# COMPILER_COMMAND_FILE Compiler command listing model reference header paths +# CMD_FILE Command file + +PRODUCT_NAME = Model +MAKEFILE = Model.mk +MATLAB_ROOT = C:\PROGRA~1\MATLAB\R2022a +MATLAB_BIN = C:\PROGRA~1\MATLAB\R2022a\bin +MATLAB_ARCH_BIN = $(MATLAB_BIN)\win64 +START_DIR = E:\Repositories\Binder_Beispiel_ReglerBBR\Models\FP56 +SOLVER = +SOLVER_OBJ = +CLASSIC_INTERFACE = 0 +TGT_FCN_LIB = GNU +MODEL_HAS_DYNAMICALLY_LOADED_SFCNS = 0 +RELATIVE_PATH_TO_ANCHOR = .. +COMPILER_COMMAND_FILE = Model_comp.rsp +CMD_FILE = Model.rsp +C_STANDARD_OPTS = +CPP_STANDARD_OPTS = +NODEBUG = 1 + +########################################################################### +## TOOLCHAIN SPECIFICATIONS +########################################################################### + +# Toolchain Name: Microsoft Visual C++ 2019 v16.0 | nmake (64-bit Windows) +# Supported Version(s): 16.0 +# ToolchainInfo Version: 2022a +# Specification Revision: 1.0 +# +#------------------------------------------- +# Macros assumed to be defined elsewhere +#------------------------------------------- + +# NODEBUG +# cvarsdll +# cvarsmt +# conlibsmt +# ldebug +# conflags +# cflags + +#----------- +# MACROS +#----------- + +MW_EXTERNLIB_DIR = $(MATLAB_ROOT)\extern\lib\win64\microsoft +MW_LIB_DIR = $(MATLAB_ROOT)\lib\win64 +CPU = AMD64 +APPVER = 5.02 +CVARSFLAG = $(cvarsmt) +CFLAGS_ADDITIONAL = -D_CRT_SECURE_NO_WARNINGS +CPPFLAGS_ADDITIONAL = -EHs -D_CRT_SECURE_NO_WARNINGS /wd4251 /Zc:__cplusplus +LIBS_TOOLCHAIN = $(conlibs) + +TOOLCHAIN_SRCS = +TOOLCHAIN_INCS = +TOOLCHAIN_LIBS = + +#------------------------ +# BUILD TOOL COMMANDS +#------------------------ + +# C Compiler: Microsoft Visual C Compiler +CC = cl + +# Linker: Microsoft Visual C Linker +LD = link + +# C++ Compiler: Microsoft Visual C++ Compiler +CPP = cl + +# C++ Linker: Microsoft Visual C++ Linker +CPP_LD = link + +# Archiver: Microsoft Visual C/C++ Archiver +AR = lib + +# MEX Tool: MEX Tool +MEX_PATH = $(MATLAB_ARCH_BIN) +MEX = "$(MEX_PATH)\mex" + +# Download: Download +DOWNLOAD = + +# Execute: Execute +EXECUTE = $(PRODUCT) + +# Builder: NMAKE Utility +MAKE = nmake + + +#------------------------- +# Directives/Utilities +#------------------------- + +CDEBUG = -Zi +C_OUTPUT_FLAG = -Fo +LDDEBUG = /DEBUG +OUTPUT_FLAG = -out: +CPPDEBUG = -Zi +CPP_OUTPUT_FLAG = -Fo +CPPLDDEBUG = /DEBUG +OUTPUT_FLAG = -out: +ARDEBUG = +STATICLIB_OUTPUT_FLAG = -out: +MEX_DEBUG = -g +RM = @del +ECHO = @echo +MV = @ren +RUN = @cmd /C + +#---------------------------------------- +# "Faster Builds" Build Configuration +#---------------------------------------- + +ARFLAGS = /nologo +CFLAGS = $(cflags) $(CVARSFLAG) $(CFLAGS_ADDITIONAL) \ + /Od /Oy- +CPPFLAGS = /TP $(cflags) $(CVARSFLAG) $(CPPFLAGS_ADDITIONAL) \ + /Od /Oy- +CPP_LDFLAGS = $(ldebug) $(conflags) $(LIBS_TOOLCHAIN) +CPP_SHAREDLIB_LDFLAGS = $(ldebug) $(conflags) $(LIBS_TOOLCHAIN) \ + -dll -def:$(DEF_FILE) +DOWNLOAD_FLAGS = +EXECUTE_FLAGS = +LDFLAGS = $(ldebug) $(conflags) $(LIBS_TOOLCHAIN) +MEX_CPPFLAGS = +MEX_CPPLDFLAGS = +MEX_CFLAGS = +MEX_LDFLAGS = +MAKE_FLAGS = -f $(MAKEFILE) +SHAREDLIB_LDFLAGS = $(ldebug) $(conflags) $(LIBS_TOOLCHAIN) \ + -dll -def:$(DEF_FILE) + + + +########################################################################### +## OUTPUT INFO +########################################################################### + +PRODUCT = $(RELATIVE_PATH_TO_ANCHOR)\Model.exe +PRODUCT_TYPE = "executable" +BUILD_TYPE = "Top-Level Standalone Executable" + +########################################################################### +## INCLUDE PATHS +########################################################################### + +INCLUDES_BUILDINFO = + +INCLUDES = $(INCLUDES_BUILDINFO) + +########################################################################### +## DEFINES +########################################################################### + +DEFINES_BUILD_ARGS = -DCLASSIC_INTERFACE=0 -DALLOCATIONFCN=0 -DMAT_FILE=1 -DONESTEPFCN=1 -DTERMFCN=1 -DMULTI_INSTANCE_CODE=1 -DINTEGER_CODE=0 -DMT=0 +DEFINES_CUSTOM = +DEFINES_OPTS = -DTID01EQ=1 +DEFINES_STANDARD = -DMODEL=Model -DNUMST=2 -DNCSTATES=3 -DHAVESTDIO -DRT -DUSE_RTMODEL + +DEFINES = $(DEFINES_BUILD_ARGS) $(DEFINES_CUSTOM) $(DEFINES_OPTS) $(DEFINES_STANDARD) + +########################################################################### +## SOURCE FILES +########################################################################### + +SRCS = $(MATLAB_ROOT)\rtw\c\src\rt_logging.c $(START_DIR)\Model_grt_rtw\Model.cpp $(START_DIR)\Model_grt_rtw\Model_data.cpp $(START_DIR)\Model_grt_rtw\rtGetInf.cpp $(START_DIR)\Model_grt_rtw\rtGetNaN.cpp $(START_DIR)\Model_grt_rtw\rt_nonfinite.cpp + +MAIN_SRC = $(MATLAB_ROOT)\rtw\c\src\common\rt_cppclass_main.cpp + +ALL_SRCS = $(SRCS) $(MAIN_SRC) + +########################################################################### +## OBJECTS +########################################################################### + +OBJS = rt_logging.obj Model.obj Model_data.obj rtGetInf.obj rtGetNaN.obj rt_nonfinite.obj + +MAIN_OBJ = rt_cppclass_main.obj + +ALL_OBJS = $(OBJS) $(MAIN_OBJ) + +########################################################################### +## PREBUILT OBJECT FILES +########################################################################### + +PREBUILT_OBJS = + +########################################################################### +## LIBRARIES +########################################################################### + +LIBS = + +########################################################################### +## SYSTEM LIBRARIES +########################################################################### + +SYSTEM_LIBS = + +########################################################################### +## ADDITIONAL TOOLCHAIN FLAGS +########################################################################### + +#--------------- +# C Compiler +#--------------- + +CFLAGS_BASIC = $(DEFINES) @$(COMPILER_COMMAND_FILE) + +CFLAGS = $(CFLAGS) $(CFLAGS_BASIC) + +#----------------- +# C++ Compiler +#----------------- + +CPPFLAGS_BASIC = $(DEFINES) @$(COMPILER_COMMAND_FILE) + +CPPFLAGS = $(CPPFLAGS) $(CPPFLAGS_BASIC) + +########################################################################### +## INLINED COMMANDS +########################################################################### + + +!include $(MATLAB_ROOT)\rtw\c\tools\vcdefs.mak + + +########################################################################### +## PHONY TARGETS +########################################################################### + +.PHONY : all build buildobj clean info prebuild download execute set_environment_variables + + +all : build + @cmd /C "@echo ### Successfully generated all binary outputs." + + +build : set_environment_variables prebuild $(PRODUCT) + + +buildobj : set_environment_variables prebuild $(OBJS) $(PREBUILT_OBJS) + @cmd /C "@echo ### Successfully generated all binary outputs." + + +prebuild : + + +download : $(PRODUCT) + + +execute : download + @cmd /C "@echo ### Invoking postbuild tool "Execute" ..." + $(EXECUTE) $(EXECUTE_FLAGS) + @cmd /C "@echo ### Done invoking postbuild tool." + + +set_environment_variables : + @set INCLUDE=$(INCLUDES);$(INCLUDE) + @set LIB=$(LIB) + + +########################################################################### +## FINAL TARGET +########################################################################### + +#------------------------------------------- +# Create a standalone executable +#------------------------------------------- + +$(PRODUCT) : $(OBJS) $(PREBUILT_OBJS) $(MAIN_OBJ) + @cmd /C "@echo ### Creating standalone executable "$(PRODUCT)" ..." + $(CPP_LD) $(CPP_LDFLAGS) -out:$(PRODUCT) @$(CMD_FILE) $(SYSTEM_LIBS) $(TOOLCHAIN_LIBS) + @cmd /C "@echo ### Created: $(PRODUCT)" + + +########################################################################### +## INTERMEDIATE TARGETS +########################################################################### + +#--------------------- +# SOURCE-TO-OBJECT +#--------------------- + +.c.obj : + $(CC) $(CFLAGS) -Fo"$@" "$<" + + +.cpp.obj : + $(CPP) $(CPPFLAGS) -Fo"$@" "$<" + + +{$(RELATIVE_PATH_TO_ANCHOR)}.c.obj : + $(CC) $(CFLAGS) -Fo"$@" "$<" + + +{$(RELATIVE_PATH_TO_ANCHOR)}.cpp.obj : + $(CPP) $(CPPFLAGS) -Fo"$@" "$<" + + +{$(START_DIR)}.c.obj : + $(CC) $(CFLAGS) -Fo"$@" "$<" + + +{$(START_DIR)}.cpp.obj : + $(CPP) $(CPPFLAGS) -Fo"$@" "$<" + + +{$(START_DIR)\Model_grt_rtw}.c.obj : + $(CC) $(CFLAGS) -Fo"$@" "$<" + + +{$(START_DIR)\Model_grt_rtw}.cpp.obj : + $(CPP) $(CPPFLAGS) -Fo"$@" "$<" + + +{$(MATLAB_ROOT)\rtw\c\src}.c.obj : + $(CC) $(CFLAGS) -Fo"$@" "$<" + + +{$(MATLAB_ROOT)\rtw\c\src}.cpp.obj : + $(CPP) $(CPPFLAGS) -Fo"$@" "$<" + + +{$(MATLAB_ROOT)\simulink\src}.c.obj : + $(CC) $(CFLAGS) -Fo"$@" "$<" + + +{$(MATLAB_ROOT)\simulink\src}.cpp.obj : + $(CPP) $(CPPFLAGS) -Fo"$@" "$<" + + +rt_logging.obj : "$(MATLAB_ROOT)\rtw\c\src\rt_logging.c" + $(CC) $(CFLAGS) -Fo"$@" "$(MATLAB_ROOT)\rtw\c\src\rt_logging.c" + + +Model.obj : "$(START_DIR)\Model_grt_rtw\Model.cpp" + $(CPP) $(CPPFLAGS) -Fo"$@" "$(START_DIR)\Model_grt_rtw\Model.cpp" + + +Model_data.obj : "$(START_DIR)\Model_grt_rtw\Model_data.cpp" + $(CPP) $(CPPFLAGS) -Fo"$@" "$(START_DIR)\Model_grt_rtw\Model_data.cpp" + + +rtGetInf.obj : "$(START_DIR)\Model_grt_rtw\rtGetInf.cpp" + $(CPP) $(CPPFLAGS) -Fo"$@" "$(START_DIR)\Model_grt_rtw\rtGetInf.cpp" + + +rtGetNaN.obj : "$(START_DIR)\Model_grt_rtw\rtGetNaN.cpp" + $(CPP) $(CPPFLAGS) -Fo"$@" "$(START_DIR)\Model_grt_rtw\rtGetNaN.cpp" + + +rt_nonfinite.obj : "$(START_DIR)\Model_grt_rtw\rt_nonfinite.cpp" + $(CPP) $(CPPFLAGS) -Fo"$@" "$(START_DIR)\Model_grt_rtw\rt_nonfinite.cpp" + + +rt_cppclass_main.obj : "$(MATLAB_ROOT)\rtw\c\src\common\rt_cppclass_main.cpp" + $(CPP) $(CPPFLAGS) -Fo"$@" "$(MATLAB_ROOT)\rtw\c\src\common\rt_cppclass_main.cpp" + + +########################################################################### +## DEPENDENCIES +########################################################################### + +$(ALL_OBJS) : rtw_proj.tmw $(COMPILER_COMMAND_FILE) $(MAKEFILE) + + +########################################################################### +## MISCELLANEOUS TARGETS +########################################################################### + +info : + @cmd /C "@echo ### PRODUCT = $(PRODUCT)" + @cmd /C "@echo ### PRODUCT_TYPE = $(PRODUCT_TYPE)" + @cmd /C "@echo ### BUILD_TYPE = $(BUILD_TYPE)" + @cmd /C "@echo ### INCLUDES = $(INCLUDES)" + @cmd /C "@echo ### DEFINES = $(DEFINES)" + @cmd /C "@echo ### ALL_SRCS = $(ALL_SRCS)" + @cmd /C "@echo ### ALL_OBJS = $(ALL_OBJS)" + @cmd /C "@echo ### LIBS = $(LIBS)" + @cmd /C "@echo ### MODELREF_LIBS = $(MODELREF_LIBS)" + @cmd /C "@echo ### SYSTEM_LIBS = $(SYSTEM_LIBS)" + @cmd /C "@echo ### TOOLCHAIN_LIBS = $(TOOLCHAIN_LIBS)" + @cmd /C "@echo ### CFLAGS = $(CFLAGS)" + @cmd /C "@echo ### LDFLAGS = $(LDFLAGS)" + @cmd /C "@echo ### SHAREDLIB_LDFLAGS = $(SHAREDLIB_LDFLAGS)" + @cmd /C "@echo ### CPPFLAGS = $(CPPFLAGS)" + @cmd /C "@echo ### CPP_LDFLAGS = $(CPP_LDFLAGS)" + @cmd /C "@echo ### CPP_SHAREDLIB_LDFLAGS = $(CPP_SHAREDLIB_LDFLAGS)" + @cmd /C "@echo ### ARFLAGS = $(ARFLAGS)" + @cmd /C "@echo ### MEX_CFLAGS = $(MEX_CFLAGS)" + @cmd /C "@echo ### MEX_CPPFLAGS = $(MEX_CPPFLAGS)" + @cmd /C "@echo ### MEX_LDFLAGS = $(MEX_LDFLAGS)" + @cmd /C "@echo ### MEX_CPPLDFLAGS = $(MEX_CPPLDFLAGS)" + @cmd /C "@echo ### DOWNLOAD_FLAGS = $(DOWNLOAD_FLAGS)" + @cmd /C "@echo ### EXECUTE_FLAGS = $(EXECUTE_FLAGS)" + @cmd /C "@echo ### MAKE_FLAGS = $(MAKE_FLAGS)" + + +clean : + $(ECHO) "### Deleting all derived files..." + @if exist $(PRODUCT) $(RM) $(PRODUCT) + $(RM) $(ALL_OBJS) + $(ECHO) "### Deleted all derived files." + + diff --git a/ks/Models/FP56/Model_grt_rtw/Model.rsp b/ks/Models/FP56/Model_grt_rtw/Model.rsp new file mode 100755 index 0000000..098fa8b --- /dev/null +++ b/ks/Models/FP56/Model_grt_rtw/Model.rsp @@ -0,0 +1,7 @@ +rt_logging.obj +Model.obj +Model_data.obj +rtGetInf.obj +rtGetNaN.obj +rt_nonfinite.obj +rt_cppclass_main.obj diff --git a/ks/Models/FP56/Model_grt_rtw/Model_comp.rsp b/ks/Models/FP56/Model_grt_rtw/Model_comp.rsp new file mode 100755 index 0000000..ce12c4d --- /dev/null +++ b/ks/Models/FP56/Model_grt_rtw/Model_comp.rsp @@ -0,0 +1,6 @@ +-IE:\Repositories\Binder_Beispiel_ReglerBBR\Models\FP56 +-IE:\Repositories\Binder_Beispiel_ReglerBBR\Models\FP56\Model_grt_rtw +-I"C:\Program Files\MATLAB\R2022a\extern\include" +-I"C:\Program Files\MATLAB\R2022a\simulink\include" +-I"C:\Program Files\MATLAB\R2022a\rtw\c\src" +-I"C:\Program Files\MATLAB\R2022a\rtw\c\src\ext_mode\common" diff --git a/ks/Models/FP56/Model_grt_rtw/Model_data.cpp b/ks/Models/FP56/Model_grt_rtw/Model_data.cpp new file mode 100755 index 0000000..8f3be12 --- /dev/null +++ b/ks/Models/FP56/Model_grt_rtw/Model_data.cpp @@ -0,0 +1,103 @@ +/* + * Model_data.cpp + * + * Code generation for model "Model". + * + * Model version : 1.2 + * Simulink Coder version : 9.7 (R2022a) 13-Nov-2021 + * C++ source code generated on : Sat Mar 28 11:28:04 2026 + * + * Target selection: grt.tlc + * Note: GRT includes extra infrastructure and instrumentation for prototyping + * Embedded hardware selection: Intel->x86-64 (Windows64) + * Code generation objectives: Unspecified + * Validation result: Not run + */ + +#include "Model.h" + +/* Block parameters (default storage) */ +P_Model_T Model::Model_P{ + /* Variable: AHD + * Referenced by: '/Gain1' + */ + 0.0255, + + /* Variable: A_Aussen + * Referenced by: '/Gain7' + */ + 4.361516, + + /* Variable: Ai + * Referenced by: '/Gain4' + */ + 0.164002, + + /* Variable: CES + * Referenced by: '/Gain2' + */ + 520.5763, + + /* Variable: CHD + * Referenced by: '/Gain' + */ + 1002.4, + + /* Variable: CSW + * Referenced by: '/Gain5' + */ + 966.0, + + /* Variable: Cl + * Referenced by: '/Gain2' + */ + 900.0, + + /* Variable: T_amb + * Referenced by: + * '/Integrator' + * '/Integrator1' + * '/Integrator2' + */ + 25.0, + + /* Variable: alphaHD + * Referenced by: '/Gain1' + */ + 397.2681, + + /* Variable: alphaSW + * Referenced by: '/Gain4' + */ + 85.2918, + + /* Variable: alpha_aussen + * Referenced by: '/Gain7' + */ + 0.4507, + + /* Variable: mES + * Referenced by: '/Gain2' + */ + 5.914, + + /* Variable: mHD + * Referenced by: '/Gain' + */ + 0.12, + + /* Variable: mSW + * Referenced by: '/Gain5' + */ + 2.82, + + /* Variable: ml + * Referenced by: '/Gain2' + */ + 0.078321408, + + /* Expression: 0 + * Referenced by: '/Constant' + */ + 0.0 +}; diff --git a/ks/Models/FP56/Model_grt_rtw/Model_private.h b/ks/Models/FP56/Model_grt_rtw/Model_private.h new file mode 100644 index 0000000..f567c8f --- /dev/null +++ b/ks/Models/FP56/Model_grt_rtw/Model_private.h @@ -0,0 +1,43 @@ +/* + * Model_private.h + * + * Code generation for model "Model". + * + * Model version : 1.1 + * Simulink Coder version : 9.7 (R2022a) 13-Nov-2021 + * C++ source code generated on : Thu Mar 26 17:54:04 2026 + * + * Target selection: grt.tlc + * Note: GRT includes extra infrastructure and instrumentation for prototyping + * Embedded hardware selection: Intel->x86-64 (Windows64) + * Code generation objectives: Unspecified + * Validation result: Not run + */ + +#ifndef RTW_HEADER_Model_private_h_ +#define RTW_HEADER_Model_private_h_ +#include "rtwtypes.h" +#include "builtin_typeid_types.h" +#include "multiword_types.h" + +/* Private macros used by the generated code to access rtModel */ +#ifndef rtmIsMajorTimeStep +#define rtmIsMajorTimeStep(rtm) (((rtm)->Timing.simTimeStep) == MAJOR_TIME_STEP) +#endif + +#ifndef rtmIsMinorTimeStep +#define rtmIsMinorTimeStep(rtm) (((rtm)->Timing.simTimeStep) == MINOR_TIME_STEP) +#endif + +#ifndef rtmSetTFinal +#define rtmSetTFinal(rtm, val) ((rtm)->Timing.tFinal = (val)) +#endif + +#ifndef rtmSetTPtr +#define rtmSetTPtr(rtm, val) ((rtm)->Timing.t = (val)) +#endif + +/* private model entry point functions */ +extern void Model_derivatives(void); + +#endif /* RTW_HEADER_Model_private_h_ */ diff --git a/ks/Models/FP56/Model_grt_rtw/Model_ref.rsp b/ks/Models/FP56/Model_grt_rtw/Model_ref.rsp new file mode 100755 index 0000000..5f28270 --- /dev/null +++ b/ks/Models/FP56/Model_grt_rtw/Model_ref.rsp @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/ks/Models/FP56/Model_grt_rtw/Model_types.h b/ks/Models/FP56/Model_grt_rtw/Model_types.h new file mode 100644 index 0000000..71e59c4 --- /dev/null +++ b/ks/Models/FP56/Model_grt_rtw/Model_types.h @@ -0,0 +1,28 @@ +/* + * Model_types.h + * + * Code generation for model "Model". + * + * Model version : 1.1 + * Simulink Coder version : 9.7 (R2022a) 13-Nov-2021 + * C++ source code generated on : Thu Mar 26 17:54:04 2026 + * + * Target selection: grt.tlc + * Note: GRT includes extra infrastructure and instrumentation for prototyping + * Embedded hardware selection: Intel->x86-64 (Windows64) + * Code generation objectives: Unspecified + * Validation result: Not run + */ + +#ifndef RTW_HEADER_Model_types_h_ +#define RTW_HEADER_Model_types_h_ + +/* Model Code Variants */ + +/* Parameters (default storage) */ +typedef struct P_Model_T_ P_Model_T; + +/* Forward declaration for rtModel */ +typedef struct tag_RTM_Model_T RT_MODEL_Model_T; + +#endif /* RTW_HEADER_Model_types_h_ */ diff --git a/ks/Models/FP56/Model_grt_rtw/buildInfo.mat b/ks/Models/FP56/Model_grt_rtw/buildInfo.mat new file mode 100755 index 0000000000000000000000000000000000000000..0c859ff4c415ff2a12ce297ad1c512e60ba5a8ad GIT binary patch literal 12872 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 (Windows64) + * Code generation objectives: Unspecified + * Validation result: Not run + */ + +#ifndef BUILTIN_TYPEID_TYPES_H +#define BUILTIN_TYPEID_TYPES_H +#include "rtwtypes.h" +#ifndef BUILTIN_TYPEID_TYPES +#define BUILTIN_TYPEID_TYPES + +/* Enumeration of built-in data types */ +typedef enum { + SS_DOUBLE = 0, /* real_T */ + SS_SINGLE = 1, /* real32_T */ + SS_INT8 = 2, /* int8_T */ + SS_UINT8 = 3, /* uint8_T */ + SS_INT16 = 4, /* int16_T */ + SS_UINT16 = 5, /* uint16_T */ + SS_INT32 = 6, /* int32_T */ + SS_UINT32 = 7, /* uint32_T */ + SS_BOOLEAN = 8 /* boolean_T */ +} BuiltInDTypeId; + +#define SS_NUM_BUILT_IN_DTYPE ((int_T)SS_BOOLEAN+1) + +/* Enumeration for MAT-file logging code */ +typedef int_T DTypeId; + +/* Enumeration of pre-defined data types */ +typedef enum { + SS_FCN_CALL = 9, + SS_INTEGER = 10, + SS_POINTER = 11, + SS_INTERNAL_DTYPE2 = 12, + SS_TIMER_UINT32_PAIR = 13, + SS_CONNECTION_TYPE = 14 +} PreDefinedDTypeId; + +#endif /* BUILTIN_TYPEID_TYPES */ +#endif /* BUILTIN_TYPEID_TYPES_H */ diff --git a/ks/Models/FP56/Model_grt_rtw/codeInfo.mat b/ks/Models/FP56/Model_grt_rtw/codeInfo.mat new file mode 100755 index 0000000000000000000000000000000000000000..a757af7ea9c61abe704b5d0684580f34e0d22645 GIT binary patch literal 10092 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 literal 0 HcmV?d00001 diff --git a/ks/Models/FP56/Model_grt_rtw/compileInfo.mat b/ks/Models/FP56/Model_grt_rtw/compileInfo.mat new file mode 100755 index 0000000000000000000000000000000000000000..fc50233c183e7a915329cfda07be903470dc0826 GIT binary patch literal 3035 zcma);c{CL68pmf$jA1Ngt*DWm(Tt_Bq?oK@ENK+N7_vlT$=D`Lh=@?85?OwJh{+@( zlD(0wVPsd?Goz?}mSkzUO}FEod+tB?J?A~={pb0-&+~nk=WBy@utuMN9XX7I*`OUX zeEf*saM($rN2pIwNPq$Cq=_TO7NrA+nS^+IgnE0yf&vX-IFC@6jYkMfOAn^0X`rQN zfYgI&A+=Dj|8quT*kRmkkOW*HZn%OP|%kDf*|n5Md_)uwWW z+6cv#Mkg^qHAr%SyW#ua8xG&-6^=(jJ5zT{97zBnrUj)Bwxzm*m)W>`qz8!clp^6|NfxH{C0fp4FEB9p7@9Xw|Jwki;%9b<&{D~ zNJvqzxOxmCN6S6V!lI|#d^K&QgzOrmGIiTnrzj-y+t$1?;!Iy7L7I|=@48r_K?8T? z>Mr66w`(a;vbqCJ;|BTS?{3c%OHc;NLzS;B7mo67xnWxFEhOfyCtD$lA5^#mOWN%Y zvY3V3llBemP$;vgBpa|ExwO8?irlViw}{#R^$a~!=?l2lkTdXC;f@Cwh466$c+_Q6vG=F}75k64_PNVbX5QqeJ$7TL0dmpT-69#Gkw;VzL7k6- zq7hlkYWn#3OFvusC7O&DPfb1#L{)S)b-ek;3jO-M!Eva?u6Q*;qZu47Z8G(KfF ziA#M0=De!B5S3Z3rl-PF8qp?OY~pYnOyv=C##E9MjRch+BmrI&h#s*L-g zo_^Vv7gAW6gYH6teN}hnhS%}?R&Ma_hN73wY)uIsDBlCBVsyu}Ohi!bzpK63w=DfA ze{NXpQCCOk7g+xt1Jly=G(yDwIV$x8J|BW>Dcu9CR7lwZ-OVC;aRu+(`G}ANPXYln zAY;tz0s!fj(I^$6*(kOmSmBPB_$qK*7|I_5cUoJ9Wh(>b%g^sh(&I~PZ;0gci*HA> zcZnh`1bSsubx5AktGH97*}+t+*;K0@xev*jj*`8u&Xx7e>2k-@ZI{tMe#qr$(j*jV zW@OE5a<_hoD$O)UJ;SHM@P7S^?D`V@Z1Q+870tdRige`Zb%j`y;(lac(p3*z@nuV) zTMdPDR(1Zl3l_Mx;Y!f!RN!#fYz`10fia5YmZS9V`!isVWgtZX)BH~iP#3-;*VPlw zxJRo>50ncQ(@>7?+n#3VwYHxkc7=mCzw1-x+(IB#ib z0OcMZm>X-k6KnY=R_V9N@QB@=ycs*DtBKG&cI1V!HsXzus$g+?Vw|8Fg6BWp0~(mE zPkRyk9dQ4EU<;RLvcpUMA09bwtiI-{g3;(796g5F{wDnVS z$`?tNy}|Tt^E@tciw_7?X(=lVE(PR1u43?wP^Gl9#D=*K-FhAVDxY9`bq zg^F{v9@Kcy6A%EDaF^2ICXup}L_fjn&% zjW>ZG%T%@DUF3i~!F&nz@bm2WwToy!QPJ3yJS%O|DZ`c3>eRi{Y|#t(fE+SxDYqc= zLw-)y*;`JT*#(?z9<5HEZW#)kjXadi5R~{?>+?PfhZ~jwN`y#ZxEUSa$%y}t!hdYx z>}w@IIDC7ZdY^iG3-8)llnWvaXa##XhJW($-1QMIw0s(iBJ;m$JS?K@xoa)Ybi~ zu9L^*lNr#GxL8P!FJWzsS93E~FAh>z07<1tUrnx#otG~3kIwsk#e;1L%a-Rq&EhY0 zZuLh;<6+@1nHV926^2%hmzkWuY5`e!D>a(Ppti Uro}iBo^`Q%wrBvL#7{}~UktfQB>(^b literal 0 HcmV?d00001 diff --git a/ks/Models/FP56/Model_grt_rtw/multiword_types.h b/ks/Models/FP56/Model_grt_rtw/multiword_types.h new file mode 100644 index 0000000..33663f5 --- /dev/null +++ b/ks/Models/FP56/Model_grt_rtw/multiword_types.h @@ -0,0 +1,1169 @@ +/* + * multiword_types.h + * + * Code generation for model "Model". + * + * Model version : 1.1 + * Simulink Coder version : 9.7 (R2022a) 13-Nov-2021 + * C++ source code generated on : Thu Mar 26 17:54:04 2026 + * + * Target selection: grt.tlc + * Note: GRT includes extra infrastructure and instrumentation for prototyping + * Embedded hardware selection: Intel->x86-64 (Windows64) + * Code generation objectives: Unspecified + * Validation result: Not run + */ + +#ifndef MULTIWORD_TYPES_H +#define MULTIWORD_TYPES_H +#include "rtwtypes.h" + +/* + * Definitions supporting external data access + */ +typedef int32_T chunk_T; +typedef uint32_T uchunk_T; + +/* + * 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/ks/Models/FP56/Model_grt_rtw/rtGetInf.cpp b/ks/Models/FP56/Model_grt_rtw/rtGetInf.cpp new file mode 100755 index 0000000..08b398a --- /dev/null +++ b/ks/Models/FP56/Model_grt_rtw/rtGetInf.cpp @@ -0,0 +1,163 @@ +/* + * rtGetInf.cpp + * + * Code generation for model "Model". + * + * Model version : 1.2 + * Simulink Coder version : 9.7 (R2022a) 13-Nov-2021 + * C++ source code generated on : Sat Mar 28 11:28:04 2026 + * + * Target selection: grt.tlc + * Note: GRT includes extra infrastructure and instrumentation for prototyping + * Embedded hardware selection: Intel->x86-64 (Windows64) + * Code generation objectives: Unspecified + * Validation result: Not run + */ + +#include "rtwtypes.h" + +extern "C" { + +#include "rtGetInf.h" + +} +#include + +extern "C" { + +#include "rt_nonfinite.h" + +} +#define NumBitsPerChar 8U + +extern "C" { + /* + * Initialize rtInf needed by the generated code. + * Inf is initialized as non-signaling. Assumes IEEE. + */ + real_T rtGetInf(void) + { + size_t bitsPerReal{ sizeof(real_T) * (NumBitsPerChar) }; + + real_T inf{ 0.0 }; + + if (bitsPerReal == 32U) { + inf = rtGetInfF(); + } else { + uint16_T one{ 1U }; + + enum { + LittleEndian, + BigEndian + } machByteOrder +{ + (*((uint8_T *) &one) == 1U) ? LittleEndian : BigEndian + }; + switch (machByteOrder) { + case LittleEndian: + { + union { + LittleEndianIEEEDouble bitVal; + real_T fltVal; + } tmpVal; + + tmpVal.bitVal.words.wordH = 0x7FF00000U; + tmpVal.bitVal.words.wordL = 0x00000000U; + inf = tmpVal.fltVal; + break; + } + + case BigEndian: + { + union { + BigEndianIEEEDouble bitVal; + real_T fltVal; + } tmpVal; + + tmpVal.bitVal.words.wordH = 0x7FF00000U; + tmpVal.bitVal.words.wordL = 0x00000000U; + inf = tmpVal.fltVal; + break; + } + } + } + + return inf; + } + + /* + * Initialize rtInfF needed by the generated code. + * Inf is initialized as non-signaling. Assumes IEEE. + */ + real32_T rtGetInfF(void) + { + IEEESingle infF; + infF.wordL.wordLuint = 0x7F800000U; + return infF.wordL.wordLreal; + } + + /* + * Initialize rtMinusInf needed by the generated code. + * Inf is initialized as non-signaling. Assumes IEEE. + */ + real_T rtGetMinusInf(void) + { + size_t bitsPerReal{ sizeof(real_T) * (NumBitsPerChar) }; + + real_T minf{ 0.0 }; + + if (bitsPerReal == 32U) { + minf = rtGetMinusInfF(); + } else { + uint16_T one{ 1U }; + + enum { + LittleEndian, + BigEndian + } machByteOrder +{ + (*((uint8_T *) &one) == 1U) ? LittleEndian : BigEndian + }; + switch (machByteOrder) { + case LittleEndian: + { + union { + LittleEndianIEEEDouble bitVal; + real_T fltVal; + } tmpVal; + + tmpVal.bitVal.words.wordH = 0xFFF00000U; + tmpVal.bitVal.words.wordL = 0x00000000U; + minf = tmpVal.fltVal; + break; + } + + case BigEndian: + { + union { + BigEndianIEEEDouble bitVal; + real_T fltVal; + } tmpVal; + + tmpVal.bitVal.words.wordH = 0xFFF00000U; + tmpVal.bitVal.words.wordL = 0x00000000U; + minf = tmpVal.fltVal; + break; + } + } + } + + return minf; + } + + /* + * Initialize rtMinusInfF needed by the generated code. + * Inf is initialized as non-signaling. Assumes IEEE. + */ + real32_T rtGetMinusInfF(void) + { + IEEESingle minfF; + minfF.wordL.wordLuint = 0xFF800000U; + return minfF.wordL.wordLreal; + } +} diff --git a/ks/Models/FP56/Model_grt_rtw/rtGetInf.h b/ks/Models/FP56/Model_grt_rtw/rtGetInf.h new file mode 100644 index 0000000..626f4a3 --- /dev/null +++ b/ks/Models/FP56/Model_grt_rtw/rtGetInf.h @@ -0,0 +1,36 @@ +/* + * rtGetInf.h + * + * Code generation for model "Model". + * + * Model version : 1.1 + * Simulink Coder version : 9.7 (R2022a) 13-Nov-2021 + * C++ source code generated on : Thu Mar 26 17:54:04 2026 + * + * Target selection: grt.tlc + * Note: GRT includes extra infrastructure and instrumentation for prototyping + * Embedded hardware selection: Intel->x86-64 (Windows64) + * Code generation objectives: Unspecified + * Validation result: Not run + */ + +#ifndef RTW_HEADER_rtGetInf_h_ +#define RTW_HEADER_rtGetInf_h_ +#ifdef __cplusplus + +#include "tmwtypes.h" + +extern "C" { + +#endif + + extern real_T rtGetInf(void); + extern real32_T rtGetInfF(void); + extern real_T rtGetMinusInf(void); + extern real32_T rtGetMinusInfF(void); + +#ifdef __cplusplus + +} /* extern "C" */ +#endif +#endif /* RTW_HEADER_rtGetInf_h_ */ diff --git a/ks/Models/FP56/Model_grt_rtw/rtGetNaN.cpp b/ks/Models/FP56/Model_grt_rtw/rtGetNaN.cpp new file mode 100755 index 0000000..936736c --- /dev/null +++ b/ks/Models/FP56/Model_grt_rtw/rtGetNaN.cpp @@ -0,0 +1,120 @@ +/* + * rtGetNaN.cpp + * + * Code generation for model "Model". + * + * Model version : 1.2 + * Simulink Coder version : 9.7 (R2022a) 13-Nov-2021 + * C++ source code generated on : Sat Mar 28 11:28:04 2026 + * + * Target selection: grt.tlc + * Note: GRT includes extra infrastructure and instrumentation for prototyping + * Embedded hardware selection: Intel->x86-64 (Windows64) + * Code generation objectives: Unspecified + * Validation result: Not run + */ + +#include "rtwtypes.h" + +extern "C" { + +#include "rtGetNaN.h" + +} +#include + +extern "C" { + +#include "rt_nonfinite.h" + +} +#define NumBitsPerChar 8U + +extern "C" { + /* + * Initialize rtNaN needed by the generated code. + * NaN is initialized as non-signaling. Assumes IEEE. + */ + real_T rtGetNaN(void) + { + size_t bitsPerReal{ sizeof(real_T) * (NumBitsPerChar) }; + + real_T nan{ 0.0 }; + + if (bitsPerReal == 32U) { + nan = rtGetNaNF(); + } else { + uint16_T one = 1U; + enum { + LittleEndian, + BigEndian + } machByteOrder +{ + (*((uint8_T *) &one) == 1U) ? LittleEndian : BigEndian + }; + switch (machByteOrder) { + case LittleEndian: + { + union { + LittleEndianIEEEDouble bitVal; + real_T fltVal; + } tmpVal; + + tmpVal.bitVal.words.wordH = 0xFFF80000U; + tmpVal.bitVal.words.wordL = 0x00000000U; + nan = tmpVal.fltVal; + break; + } + + case BigEndian: + { + union { + BigEndianIEEEDouble bitVal; + real_T fltVal; + } tmpVal; + + tmpVal.bitVal.words.wordH = 0x7FFFFFFFU; + tmpVal.bitVal.words.wordL = 0xFFFFFFFFU; + nan = tmpVal.fltVal; + break; + } + } + } + + return nan; + } + + /* + * Initialize rtNaNF needed by the generated code. + * NaN is initialized as non-signaling. Assumes IEEE. + */ + real32_T rtGetNaNF(void) + { + IEEESingle nanF{ { 0.0F } }; + + uint16_T one{ 1U }; + + enum { + LittleEndian, + BigEndian + } machByteOrder +{ + (*((uint8_T *) &one) == 1U) ? LittleEndian : BigEndian + }; + switch (machByteOrder) { + case LittleEndian: + { + nanF.wordL.wordLuint = 0xFFC00000U; + break; + } + + case BigEndian: + { + nanF.wordL.wordLuint = 0x7FFFFFFFU; + break; + } + } + + return nanF.wordL.wordLreal; + } +} diff --git a/ks/Models/FP56/Model_grt_rtw/rtGetNaN.h b/ks/Models/FP56/Model_grt_rtw/rtGetNaN.h new file mode 100644 index 0000000..d1ab6c5 --- /dev/null +++ b/ks/Models/FP56/Model_grt_rtw/rtGetNaN.h @@ -0,0 +1,34 @@ +/* + * rtGetNaN.h + * + * Code generation for model "Model". + * + * Model version : 1.1 + * Simulink Coder version : 9.7 (R2022a) 13-Nov-2021 + * C++ source code generated on : Thu Mar 26 17:54:04 2026 + * + * Target selection: grt.tlc + * Note: GRT includes extra infrastructure and instrumentation for prototyping + * Embedded hardware selection: Intel->x86-64 (Windows64) + * Code generation objectives: Unspecified + * Validation result: Not run + */ + +#ifndef RTW_HEADER_rtGetNaN_h_ +#define RTW_HEADER_rtGetNaN_h_ + +#include "tmwtypes.h" + + +#ifdef __cplusplus +extern "C" { +#endif + + extern real_T rtGetNaN(void); + extern real32_T rtGetNaNF(void); + +#ifdef __cplusplus + +} /* extern "C" */ +#endif +#endif /* RTW_HEADER_rtGetNaN_h_ */ diff --git a/ks/Models/FP56/Model_grt_rtw/rt_logging.h b/ks/Models/FP56/Model_grt_rtw/rt_logging.h new file mode 100644 index 0000000..e69de29 diff --git a/ks/Models/FP56/Model_grt_rtw/rt_nonfinite.cpp b/ks/Models/FP56/Model_grt_rtw/rt_nonfinite.cpp new file mode 100755 index 0000000..20d3513 --- /dev/null +++ b/ks/Models/FP56/Model_grt_rtw/rt_nonfinite.cpp @@ -0,0 +1,109 @@ +/* + * rt_nonfinite.cpp + * + * Code generation for model "Model". + * + * Model version : 1.2 + * Simulink Coder version : 9.7 (R2022a) 13-Nov-2021 + * C++ source code generated on : Sat Mar 28 11:28:04 2026 + * + * Target selection: grt.tlc + * Note: GRT includes extra infrastructure and instrumentation for prototyping + * Embedded hardware selection: Intel->x86-64 (Windows64) + * Code generation objectives: Unspecified + * Validation result: Not run + */ + +extern "C" { + +#include "rtGetNaN.h" + +} + extern "C" +{ + +#include "rtGetInf.h" + +} + +#include +#include "rtwtypes.h" + +extern "C" { + +#include "rt_nonfinite.h" + +} +#define NumBitsPerChar 8U + +extern "C" { + real_T rtInf; + real_T rtMinusInf; + real_T rtNaN; + real32_T rtInfF; + real32_T rtMinusInfF; + real32_T rtNaNF; +} + extern "C" +{ + /* + * Initialize the rtInf, rtMinusInf, and rtNaN needed by the + * generated code. NaN is initialized as non-signaling. Assumes IEEE. + */ + void rt_InitInfAndNaN(size_t realSize) + { + (void) (realSize); + rtNaN = rtGetNaN(); + rtNaNF = rtGetNaNF(); + rtInf = rtGetInf(); + rtInfF = rtGetInfF(); + rtMinusInf = rtGetMinusInf(); + rtMinusInfF = rtGetMinusInfF(); + } + + /* Test if value is infinite */ + boolean_T rtIsInf(real_T value) + { + return (boolean_T)((value==rtInf || value==rtMinusInf) ? 1U : 0U); + } + + /* Test if single-precision value is infinite */ + boolean_T rtIsInfF(real32_T value) + { + return (boolean_T)(((value)==rtInfF || (value)==rtMinusInfF) ? 1U : 0U); + } + + /* Test if value is not a number */ + boolean_T rtIsNaN(real_T value) + { + boolean_T result{ (boolean_T) 0 }; + + size_t bitsPerReal{ sizeof(real_T) * (NumBitsPerChar) }; + + if (bitsPerReal == 32U) { + result = rtIsNaNF((real32_T)value); + } else { + union { + LittleEndianIEEEDouble bitVal; + real_T fltVal; + } tmpVal; + + tmpVal.fltVal = value; + result = (boolean_T)((tmpVal.bitVal.words.wordH & 0x7FF00000) == + 0x7FF00000 && + ( (tmpVal.bitVal.words.wordH & 0x000FFFFF) != 0 || + (tmpVal.bitVal.words.wordL != 0) )); + } + + return result; + } + + /* Test if single-precision value is not a number */ + boolean_T rtIsNaNF(real32_T value) + { + IEEESingle tmp; + tmp.wordL.wordLreal = value; + return (boolean_T)( (tmp.wordL.wordLuint & 0x7F800000) == 0x7F800000 && + (tmp.wordL.wordLuint & 0x007FFFFF) != 0 ); + } +} diff --git a/ks/Models/FP56/Model_grt_rtw/rt_nonfinite.h b/ks/Models/FP56/Model_grt_rtw/rt_nonfinite.h new file mode 100644 index 0000000..6ea158f --- /dev/null +++ b/ks/Models/FP56/Model_grt_rtw/rt_nonfinite.h @@ -0,0 +1,64 @@ +/* + * rt_nonfinite.h + * + * Code generation for model "Model". + * + * Model version : 1.1 + * Simulink Coder version : 9.7 (R2022a) 13-Nov-2021 + * C++ source code generated on : Thu Mar 26 17:54:04 2026 + * + * Target selection: grt.tlc + * Note: GRT includes extra infrastructure and instrumentation for prototyping + * Embedded hardware selection: Intel->x86-64 (Windows64) + * Code generation objectives: Unspecified + * Validation result: Not run + */ + +#ifndef RTW_HEADER_rt_nonfinite_h_ +#define RTW_HEADER_rt_nonfinite_h_ +#include +#include "tmwtypes.h" + +#ifdef __cplusplus + +extern "C" { + +#endif + + extern real_T rtInf; + extern real_T rtMinusInf; + extern real_T rtNaN; + extern real32_T rtInfF; + extern real32_T rtMinusInfF; + extern real32_T rtNaNF; + extern void rt_InitInfAndNaN(size_t realSize); + extern boolean_T rtIsInf(real_T value); + extern boolean_T rtIsInfF(real32_T value); + extern boolean_T rtIsNaN(real_T value); + extern boolean_T rtIsNaNF(real32_T value); + struct BigEndianIEEEDouble { + struct { + uint32_T wordH; + uint32_T wordL; + } words; + }; + + struct LittleEndianIEEEDouble { + struct { + uint32_T wordL; + uint32_T wordH; + } words; + }; + + struct IEEESingle { + union { + real32_T wordLreal; + uint32_T wordLuint; + } wordL; + }; + +#ifdef __cplusplus + +} /* extern "C" */ +#endif +#endif /* RTW_HEADER_rt_nonfinite_h_ */ diff --git a/ks/Models/FP56/Model_grt_rtw/rtmodel.h b/ks/Models/FP56/Model_grt_rtw/rtmodel.h new file mode 100644 index 0000000..dcbeb89 --- /dev/null +++ b/ks/Models/FP56/Model_grt_rtw/rtmodel.h @@ -0,0 +1,21 @@ +/* + * rtmodel.h: + * + * Code generation for model "Model". + * + * Model version : 1.1 + * Simulink Coder version : 9.7 (R2022a) 13-Nov-2021 + * C++ source code generated on : Thu Mar 26 17:54:04 2026 + * + * Target selection: grt.tlc + * Note: GRT includes extra infrastructure and instrumentation for prototyping + * Embedded hardware selection: Intel->x86-64 (Windows64) + * Code generation objectives: Unspecified + * Validation result: Not run + */ + +#ifndef RTW_HEADER_rtmodel_h_ +#define RTW_HEADER_rtmodel_h_ +#include "Model.h" +#define GRTINTERFACE 0 +#endif /* RTW_HEADER_rtmodel_h_ */ diff --git a/ks/Models/FP56/Model_grt_rtw/rtw_continuous.h b/ks/Models/FP56/Model_grt_rtw/rtw_continuous.h new file mode 100644 index 0000000..e69de29 diff --git a/ks/Models/FP56/Model_grt_rtw/rtw_proj.tmw b/ks/Models/FP56/Model_grt_rtw/rtw_proj.tmw new file mode 100755 index 0000000..e140916 --- /dev/null +++ b/ks/Models/FP56/Model_grt_rtw/rtw_proj.tmw @@ -0,0 +1,4 @@ +Simulink Coder project for Model using . MATLAB root = C:\Program Files\MATLAB\R2022a. SimStruct date: 13-Nov-2021 07:40:36 +This file is generated by Simulink Coder for use by the make utility +to determine when to rebuild objects when the name of the current Simulink Coder project changes. +The rtwinfomat located at: ..\slprj\grt\Model\tmwinternal\binfo.mat diff --git a/ks/Models/FP56/Model_grt_rtw/rtw_solver.h b/ks/Models/FP56/Model_grt_rtw/rtw_solver.h new file mode 100644 index 0000000..e69de29 diff --git a/ks/Models/FP56/Model_grt_rtw/rtwtypes.h b/ks/Models/FP56/Model_grt_rtw/rtwtypes.h new file mode 100644 index 0000000..233bc22 --- /dev/null +++ b/ks/Models/FP56/Model_grt_rtw/rtwtypes.h @@ -0,0 +1,37 @@ +/* + * rtwtypes.h + * + * Code generation for model "Model". + * + * Model version : 1.1 + * Simulink Coder version : 9.7 (R2022a) 13-Nov-2021 + * C++ source code generated on : Thu Mar 26 17:54:04 2026 + * + * Target selection: grt.tlc + * Note: GRT includes extra infrastructure and instrumentation for prototyping + * Embedded hardware selection: Intel->x86-64 (Windows64) + * Code generation objectives: Unspecified + * Validation result: Not run + */ + +#ifndef RTWTYPES_H +#define RTWTYPES_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/ks/Models/FP56/Model_grt_rtw/rtwtypeschksum.mat b/ks/Models/FP56/Model_grt_rtw/rtwtypeschksum.mat new file mode 100755 index 0000000000000000000000000000000000000000..3ad84fd3cf9194e3fc27810c584250cab70005bb GIT binary patch literal 1538 zcmV+d2L1U>K~zjZLLfCRFd$7qR4ry{Y-KDUP;6mzW^ZzBIv`L(S4mDbG%O%Pa%Ew3 zWn>_4ZaN@SVRRr(VR9fcI3O`GIx;vqFg74EFfukEARr(hARr(hARr(hARr(hARr(h zARr(hARr(hARr(hARr(hARr(B00000000000ZB~{0000h0RRAaoV}CJYr-%T$DgGW z$3%pkcI$CF2s=pGX}HaSf)25c!fwT6_JJlPjX$=3eAgv3oi-E;4lF#{_wDzSeEVox z05EU?>gwK5xo zE}i3?qn>IdoLjP=d%(3-_dx~MT(5#_7Pzb*p_EIS{eoq=>lNRtb9?{fCKb7FtlYX+ z=ZG#lkGluI<9EH=5EzDo0|tb9+3>iR0qh?}1_e6n6ChI`2buaDu;}9< zpbr#pAOHYZ&L%|<0000U0RRAaoTXAtYlA=#U4sc}525$|iC$VtZ`FQ~gC*ENE`nH{ z*ny3^%#I}fxc-;^l&(gJX)T3j;IT7|Z|BWhXF`b2kq{GmPAzQO#JH`U9?mUNRje_e z7i-mh=Zed=|6%bA#RC$gtf&&lu_y^-H7^))AYWy0XuXzND`H=5w1nLeD@b-hDH*ql zG7s7GS|Mneq!2Dw%SwY;A-~^;O)3I=y?jYFAbx~Z2$V3?!xF|fl*rYdWn*Sh3+ViC z2mJ8cvyO|le!PpU9A(fhj$k4Wiwr3C0F6eFaR|8t^1Lu=q?zbxaecGT;==b*!&3ifj<~akr$-usSo?HJR)6;a`{^9TVo444hvW@+$!+JYhy4?{Qc&FaY6pNhKBY~c{$q5?ceD1(=n8e(Nqr6L-!$wpg?2V4(k{{V6g8`mW zy`Vs+nmK!V{Zf2Eyh|v)$LpE}%Eesql@&aBo)%fG&0Xq6UU@_BD3bN6=~R=_wQ-p4 z5{!%>Gg?D|Ti^Ro>gqWG%*!woTAx@Y7xODJ%G6^|j}Ktpr?upMx=(A#)!1u|E}+26 z@~qAC?w;>?b#cB*DzB>lRsM0_rt2(o-Y!_4_x=&*Tc=-c>#Oaf@%W84fwiXrp3!Va3j zE~FyDv%35S>(!;6;J12QL8|OVfv^u1m3kXN(Q`i)=w$L=?!ezUeTw1=)=ZgiS;Vz!&37q>O)KHA-sNViPyU4MSTojI4`cl<916tj+XG)0a<+v o_RUxL19jQPdCl5953H28>U^u{>?=wit1g?abJcqO1 + + + NTDKrwFlC2KuvSUsd+ruOI8Dyv3nMQrYVV99I0a14oaIUdnclSWEQvWIPl0hwuNNm1YfQasnRGmWFrGc9HOJzA== + + \ No newline at end of file diff --git a/ks/Models/FP56/Model_grt_rtw/tmwtypes.h b/ks/Models/FP56/Model_grt_rtw/tmwtypes.h new file mode 100755 index 0000000..974bb27 --- /dev/null +++ b/ks/Models/FP56/Model_grt_rtw/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 + +/* __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 +#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 +# 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 + +#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::max()) +#define MAX_VALID_SIZET_VALUE (std::numeric_limits::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/ks/Models/FP56/Modell.slxc b/ks/Models/FP56/Modell.slxc new file mode 100755 index 0000000000000000000000000000000000000000..7eb14646c41f45c9c134241359ac5b205e6aa54f GIT binary patch literal 5264 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 E0aFf&CIA2c literal 0 HcmV?d00001 diff --git a/ks/Models/FP56/slprj/grt/Model/tmwinternal/BlockTraceInfo.mat b/ks/Models/FP56/slprj/grt/Model/tmwinternal/BlockTraceInfo.mat new file mode 100755 index 0000000000000000000000000000000000000000..51ecd7edd0cb4596d097f5feb5e9e452ee49af9a GIT binary patch literal 567 zcmeZu4DoSvQZUssQ1EpO(M`+DN!3vZ$Vn_o%P-2cQV4Jk_w+L}(NS?FM ze9+dpU!?YBVgFzDU1!T(x|&3E4sq7bt2mjk`)HZ-tM%{w&WE|5oqeA3c-ifF&+F!V zdUMf%9HuF2OBO!TTMQs_gO!T=giQi)wLy!Dj{l(5Yncu?X z(}}9t=O4UYP%^h^3t#_!5qFhyKPAo{p3pa&@94h$eRo99U$&pHT;=J*&&vy1|1P{5 zUU+5ckE&NY_&t4Modho!1{7XdQeh`=`D};f;W(ekZ_ll==n9&b^eW(29FOL`8`fgx zN^tM9n)dKTldR>dh_=P-Wnjr%doxRc`x72Xzu5hMM#B5z zX3o>CTPmjf+O$d}-q&{XlisX?2;B$!Hq_lzo_*o_#%Z-1&n&jxy|1#dx%`Y)j!@>u f8^_=G|FEB^^SFP;qXXw2{`_B?vq;~!?nny&TTTE; literal 0 HcmV?d00001 diff --git a/ks/Models/FP56/slprj/grt/Model/tmwinternal/CompileInfo.xml b/ks/Models/FP56/slprj/grt/Model/tmwinternal/CompileInfo.xml new file mode 100755 index 0000000..25fff6b --- /dev/null +++ b/ks/Models/FP56/slprj/grt/Model/tmwinternal/CompileInfo.xml @@ -0,0 +1,392 @@ + + + + + Model + Model + + AAFJTQAAAAAOAAAAOAAAAAYAAAAIAAAAAgAAAAAAAAAFAAAACAAAAAAAAAABAAAAAQAAAAAAAAAFAAQAAQAAAAEAAAAAAAAA + AHD + A_Aussen + Ai + CES + CHD + CSW + Cl + T_amb + alphaHD + alphaSW + alpha_aussen + mES + mHD + mSW + ml + true + true + true + + Inf + -Inf + 2 + + true + 0.0 + 40 + 0 + + + + + + false + false + false + 2 + 3 + -1.0 + 3 + 3 + 1 + 3 + 0 + + false + + + Inf + -Inf + + true + 0.0 + 40 + 0 + + + + + + + true + 0.0 + 40 + 0 + + + true + true + Cont + .05 + 40 + 1 + + 2 + 327 + <?xml version="1.0"?> +<slexec_sto version="1.1" packageUris="http://schema.mathworks.com/mf0/slexec_mm_sto/R2022a_202107291127"> + <sto.Registry type="sto.Registry" uuid="bb50d8a1-42f1-4048-8a3a-35f2fd3f30fd"> + <clocks type="sto.Timer" uuid="f5bed6c5-0a8f-4e1f-8e77-319416212ee8"> + <computedFundamentalDiscretePeriod>.05</computedFundamentalDiscretePeriod> + <resolution>.05</resolution> + <clockTickConstraint>PeriodicWithFixedResolution</clockTickConstraint> + <rates type="sto.ContinuousRate" uuid="5c1afef0-06f1-4b2e-8657-34fdddc5bbfd"> + <annotation>Cont</annotation> + <description>Continuous</description> + <taskId>_task0</taskId> + <rateSpec type="sto.RateSpec" uuid="6e6d6848-bde8-444d-9025-4ca60f2637b2"/> + </rates> + <rates type="sto.ClassicPeriodicDiscreteRate" uuid="6e67d6ff-8d57-46ff-8399-faa23430698f"> + <annotation>D1</annotation> + <colorIndex>2</colorIndex> + <description>Discrete 1</description> + <rateIdx>1</rateIdx> + <taskId>_task0</taskId> + <rateSpec type="sto.RateSpec" uuid="dd6e73b8-19a4-4fcb-b01d-50659a0627df"> + <period>.05</period> + <rateType>ClassicPeriodicDiscrete</rateType> + </rateSpec> + </rates> + <timeAdvanceMode>FixedStep</timeAdvanceMode> + <baseRate type="sto.ContinuousRate" uuid="3434c387-7d4f-4d79-a40a-fa4605633209"> + <annotation>Cont</annotation> + <description>Continuous</description> + <taskId>_task0</taskId> + <rateSpec type="sto.RateSpec" uuid="dcb91da4-408d-4026-9c1f-23c122d8a84c"/> + </baseRate> + </clocks> + <clocks type="sto.Event" uuid="5f34f5e6-05b6-4121-b292-403595d8c8f2"> + <eventType>PARAMETER_CHANGE_EVENT</eventType> + <cNum>1</cNum> + <clockType>Event</clockType> + <identifier>ParameterChangeEvent</identifier> + <rates type="sto.ModelWideEventRate" uuid="b7ece639-184b-44d7-a56a-1d9c82e20740"> + <clockId>ParameterChangeEvent</clockId> + <rateIdx>-1</rateIdx> + <taskId>ModelWideParameterChangeEvent</taskId> + <useForExecution>NotForExecution</useForExecution> + <rateSpec type="sto.RateSpec" uuid="9af2c701-dc83-4f74-8585-d32564d9bf43"> + <period>Inf</period> + <rateType>ModelWideParameterChangeEvent</rateType> + </rateSpec> + </rates> + <taskingMode>ExplicitTasking</taskingMode> + <timeAdvanceMode>None</timeAdvanceMode> + </clocks> + <executionSpec>Undetermined</executionSpec> + <taskPriorityDirection>HighNumberLast</taskPriorityDirection> + <timeAdvanceMode>FixedStep</timeAdvanceMode> + <taskRegistry type="sto.TaskRegistry" uuid="b1c3e180-f46a-4eca-8fad-1cbe120beb7e"> + <rootTaskHierarchyElements type="sto.Task" uuid="95dd5883-45cf-4bb0-8c9c-a47289ba229a"> + <isExplicit>true</isExplicit> + <rates type="sto.ModelWideEventRate" uuid="3bfb8c8e-711b-462d-b7ca-bb130a422cd5"> + <clockId>ParameterChangeEvent</clockId> + <rateIdx>-1</rateIdx> + <taskId>ModelWideParameterChangeEvent</taskId> + <useForExecution>NotForExecution</useForExecution> + <rateSpec type="sto.RateSpec" uuid="94332274-d943-498f-a62c-669258e94020"> + <period>Inf</period> + <rateType>ModelWideParameterChangeEvent</rateType> + </rateSpec> + </rates> + <elementType>Task</elementType> + <identifier>ModelWideParameterChangeEvent</identifier> + <priority>-1</priority> + <schedulingClockId>ParameterChangeEvent</schedulingClockId> + </rootTaskHierarchyElements> + <rootTaskHierarchyElements type="sto.Task" uuid="ec537706-4286-4fc1-8dc3-144701f6eedc"> + <isExecutable>true</isExecutable> + <orderIndex>1</orderIndex> + <rates type="sto.ContinuousRate" uuid="5d949003-959e-40c0-b549-03a769334b03"> + <annotation>Cont</annotation> + <description>Continuous</description> + <taskId>_task0</taskId> + <rateSpec type="sto.RateSpec" uuid="6120e363-1c84-4b69-a3c7-fa4e6e7c8a43"/> + </rates> + <rates type="sto.ClassicPeriodicDiscreteRate" uuid="dbaaa966-0a0c-4251-b1ce-2c4a948055f7"> + <annotation>D1</annotation> + <colorIndex>2</colorIndex> + <description>Discrete 1</description> + <rateIdx>1</rateIdx> + <taskId>_task0</taskId> + <rateSpec type="sto.RateSpec" uuid="22331311-3e9d-4fb8-9e2d-6c8c46fed61c"> + <period>.05</period> + <rateType>ClassicPeriodicDiscrete</rateType> + </rateSpec> + </rates> + <elementType>Task</elementType> + <identifier>_task0</identifier> + <priority>40</priority> + </rootTaskHierarchyElements> + <taskDependencyGraph type="sto.SerializedTaskConnectionList" uuid="2bd29f97-ba78-45a8-94ac-ff435ae73c67"> + <taskIdentifier>_task0</taskIdentifier> + </taskDependencyGraph> + <taskDependencyGraph type="sto.SerializedTaskConnectionList" uuid="ce15d9f2-1775-47a8-acec-a91bd12af7b1"> + <clockIdentifier>ParameterChangeEvent</clockIdentifier> + <taskIdentifier>ModelWideParameterChangeEvent</taskIdentifier> + </taskDependencyGraph> + </taskRegistry> + </sto.Registry> +</slexec_sto> + true + + + + + true + .05 + 2 + true + 2 + 1 + ode3 + SOLVER_TYPE_FIXEDSTEP + + 8 + 64 + 32 + 32 + 32 + 64 + 64 + 64 + 16 + 64 + 1 + true + 64 + + + + + + 0 + 0 + 0 + 0 + + + + + 1 + 1 + true + 2 + AHD + + + 1 + 1 + true + 2 + A_Aussen + + + 1 + 1 + true + 2 + Ai + + + 1 + 1 + true + 2 + CES + + + 1 + 1 + true + 2 + CHD + + + 1 + 1 + true + 2 + CSW + + + 1 + 1 + true + 2 + Cl + + + 1 + 1 + true + 2 + T_amb + + + 1 + 1 + true + 2 + alphaHD + + + 1 + 1 + true + 2 + alphaSW + + + 1 + 1 + true + 2 + alpha_aussen + + + 1 + 1 + true + 2 + mES + + + 1 + 1 + true + 2 + mHD + + + 1 + 1 + true + 2 + mSW + + + 1 + 1 + true + 2 + ml + + + + + true + true + true + true + true + true + + + + + + + + + + + + + 1.0 + 0.0 + 0.0 + + Model + + 1.0 + 0.0 + 0.0 + + ROOT + + + + + + + + + sltpEvents + + + sltpTaskGroups + + + + + Cont + + + _task0 + + + sltpTasks + + + + + \ No newline at end of file diff --git a/ks/Models/FP56/slprj/grt/Model/tmwinternal/binfo.mat b/ks/Models/FP56/slprj/grt/Model/tmwinternal/binfo.mat new file mode 100755 index 0000000000000000000000000000000000000000..35593a386fcba1a9bd8bd6bfdf3d68004e764bee GIT binary patch literal 19267 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 ByaE6K literal 0 HcmV?d00001 diff --git a/ks/Models/FP56/slprj/grt/Model/tmwinternal/minfo.mat b/ks/Models/FP56/slprj/grt/Model/tmwinternal/minfo.mat new file mode 100755 index 0000000000000000000000000000000000000000..3eab9f72d8105dbbfa016ee8ad806e9c61b45ff1 GIT binary patch literal 2471 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 literal 0 HcmV?d00001 diff --git a/ks/Models/FP56/slprj/grt/_sharedutils/shared_file.dmr b/ks/Models/FP56/slprj/grt/_sharedutils/shared_file.dmr new file mode 100755 index 0000000000000000000000000000000000000000..4dd64ec7bc7c27ba9c4ca93c754c3798d4235cd7 GIT binary patch literal 122880 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 B4OsvH literal 0 HcmV?d00001 diff --git a/ks/Models/FP56/slprj/modeladvisor/com_2emathworks_2ecgo_2egroup_/Model/1/ModelAdvisorData b/ks/Models/FP56/slprj/modeladvisor/com_2emathworks_2ecgo_2egroup_/Model/1/ModelAdvisorData new file mode 100755 index 0000000000000000000000000000000000000000..b862871e906fefa03c009407f97506347746db42 GIT binary patch literal 109568 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 literal 0 HcmV?d00001 diff --git a/ks/Models/FP56/slprj/sim/varcache/Model/checksumOfCache.mat b/ks/Models/FP56/slprj/sim/varcache/Model/checksumOfCache.mat new file mode 100755 index 0000000000000000000000000000000000000000..a74bbb6df1b3181736a767bc53e34a422521218f GIT binary patch literal 392 zcmeZu4DoSvQZUssQ1EpO(M`+DN!3vZ$Vn_o%P-2cQV4Jk_w+L}(NSB|RX2LLe}5OV-AFA#$OD-eVD zEI`Z%#r#0pJtsdYF(*8~D7&~IF*y~iPXH)BL%{s|-}ZmkYTjD*{}8@aK#I9MK>g17 wd1;yH!Ko!dscAqi+}ta&JvaLqHnF^H;GFU1hf^IX=7QAv=BK10ITxq704{(>IRF3v literal 0 HcmV?d00001 diff --git a/ks/Models/FP56/slprj/sim/varcache/Model/varInfo.mat b/ks/Models/FP56/slprj/sim/varcache/Model/varInfo.mat new file mode 100755 index 0000000000000000000000000000000000000000..cf84e4785614e5e25d14496ff66abc5392f7cdb5 GIT binary patch literal 5528 zcmeHLO;3YB5T*6=V6+E+z#crd2CJ=xQxT0e5z| z@V1+5ms$1=@R&Xx*rxMfUX#wLPHfX@xeJdq$-twr8-%_=2G*$m*u7{HD`YfgQxYr< z;>_2?rXgu}$=RjRIXBumY3mS`Y#ML1zI_PW@5h?93*$cYTDET|i*Y>4=5f69f(i9T zLHHW2=nK;juS4hfZP>=f@tAK5I?vmH$h^Nva6Opcgu~o9PD?No8Zq+rdH7`RN|FbU zQOtw!EV+&}=d%QVBH%IBv(~~<_~H9tSt)+--176QC4Azw%dV?e-qlhgL z--E9BO}YJ!Us>JOfxjGA*UUwFKNYVzr#U})-O6|s^}xCvDm{Q&UT_&cLxZSP5=j0`!Qen+*0-X+xG`w>F)pVs`R!J zUPYhlE1z46*P>70ewO=V9I@d%KEJGB=`LnN7C$i;=f&@5oA9{S4yLT|SyTG}?e|Yw literal 0 HcmV?d00001 diff --git a/ks/Models/FP56/slprj/sim/varcache/Modell/checksumOfCache.mat b/ks/Models/FP56/slprj/sim/varcache/Modell/checksumOfCache.mat new file mode 100755 index 0000000000000000000000000000000000000000..9691849ccb705c685ad1ee172d9145722d3d3074 GIT binary patch literal 392 zcmeZu4DoSvQZUssQ1EpO(M`+DN!3vZ$Vn_o%P-2cQV4Jk_w+L}(NSfNGPblbGEguwFfvmh5-`93qo*$)kR1TTY(UHb#JoTZ0<1s` z;U8{L(+5bcMRskvI@&NTa y=jWwmrU$2%1f`|{xo~r@$oAaqXV}E@vVn8Pn;%Yfq?ij*>zkjFisW3J<^li~vqvWY literal 0 HcmV?d00001 diff --git a/ks/Models/FP56/slprj/sim/varcache/Modell/tmwinternal/simulink_cache.xml b/ks/Models/FP56/slprj/sim/varcache/Modell/tmwinternal/simulink_cache.xml new file mode 100755 index 0000000..81c2cb2 --- /dev/null +++ b/ks/Models/FP56/slprj/sim/varcache/Modell/tmwinternal/simulink_cache.xml @@ -0,0 +1,6 @@ + + + + sLonxaz63rcjE+Tfc73PVxZSx3RtBUteMVCh7EdgFqnx/LrVH5YIdBfAMR5tWaUJO0VfY6qRmpBEwBrM1loXHQ== + + \ No newline at end of file diff --git a/ks/Models/FP56/slprj/sim/varcache/Modell/varInfo.mat b/ks/Models/FP56/slprj/sim/varcache/Modell/varInfo.mat new file mode 100755 index 0000000000000000000000000000000000000000..b25c12cff1b80c77f15da4bdbce9ab4bdfac7337 GIT binary patch literal 5528 zcmeHL%T9wp6s7gKFxrJ5FbkKhLDZ_OO7Yc1OkqB|>SS#^3Ohy%!k4iFVN7 zZYG%ycbId5!|maKV-4@DE;&8aiDM00uIIBR>HBo)hEZUWzCG&Qw@;eHju>6CDGBE$ zxsE*I(1;jkp8oy{l2ehn=o!euVwo-vKYs`Y#zrOKb%m1 z6h<%cf<7?~@j7&lUx#gM9FO_dp!2*9h^*Vo1lNK2RXEI@r-g&)2TmX+cM&n-W{TEZt@yX?A(_p1TxF}B9mYaFvV z;ych4zbUuh@hhv_I`Eg{>YC-H_fzqjbDHy$*R70KQ4j2^fzku0HU57_PAlP6>Fk&1 zP-VOhMyg&bs8>;6ZC~kY(Kr26uQFeNIdc6-z1VO}g9*$lUm(|68NXWszZg@0@l2K8 zmeSil^Q&~X6u%v)$5p<6N2p(nllmRg +#include "filter.h" + +TEST(PT1FilterTest, InitialOutputIsZero) { + PT1Filter filter(0.1, 0.01); + EXPECT_DOUBLE_EQ(filter.update(0.0), 0.0); +} + +TEST(PT1FilterTest, StepResponse) { + PT1Filter filter(0.1, 0.01); + double output = 0.0; + for (int i = 0; i < 100; ++i) { + output = filter.update(1.0); + } + EXPECT_NEAR(output, 1.0, 0.01); +} + +TEST(PT1FilterTest, FilterFactorEffect) { + PT1Filter fastFilter(0.01, 0.01); + PT1Filter slowFilter(0.5, 0.01); + EXPECT_GT(fastFilter.update(1.0), slowFilter.update(1.0)); +} + +#endif // FILTER_TEST_CPP