commit 291201a4afa5220ca233d6419964fa0353fe8bbf Author: Jonathan Pilborough z003wskt Date: Tue Aug 29 13:45:40 2023 +0200 Initial version diff --git a/AntriebModel.cpp b/AntriebModel.cpp new file mode 100644 index 0000000..d57db63 --- /dev/null +++ b/AntriebModel.cpp @@ -0,0 +1,86 @@ +/** + * @file Zusi 3 Antrieb DLL Test + * @author Jonathan Pilborough / jonathanp +*/ + +#include "AntriebModel.h" + +#include + +AntriebModel::AntriebModel(int variant) : mVariant(variant), mFahrstufe(0.0f), mZugKraft(0.0f) +{ + +} + +void AntriebModel::Bedienung(AntriebsRenderModus antriebsRenderModus, ProtokollFst* prot, float sp) +{ + if (prot->rischa.funktion == KSF_RischaR || prot->rischa.funktion == KSF_RischaV) + { + if (mVariant == 0) + { + if (prot->schaltstufenSteller.funktion == KSF_FahrstufeX) + { + mFahrstufe = prot->schaltstufenSteller.parameter * 100.0f; + } + } + else if (mVariant == 1) + { + if (prot->zugkraftSteller.funktion == KSF_ZugkraftX) + { + mFahrstufe = prot->zugkraftSteller.parameter * 100.0f; + } + } + } + else + { + mZugKraft = 0.0f; + } + + if (prot->hauptschalter.funktion == KSF_HauptschalterAus) + mHauptschalterAus = 1; + else if (prot->hauptschalter.funktion == KSF_HauptschalterEin) + { + if (mVariant == 0) + { + if ((mZugKraft == 0.0f) && ((prot->schaltstufenSteller.funktion == KSF_FahrstufeSchnellAus) || ((prot->schaltstufenSteller.funktion == KSF_FahrstufeX) && (prot->schaltstufenSteller.parameter == 0)))) + mHauptschalterAus = 0; + } + else if (mVariant == 1) + { + if ((mZugKraft == 0.0f) && ((prot->zugkraftSteller.funktion == KSF_ZugkraftSchnellAus) || ((prot->zugkraftSteller.funktion == KSF_ZugkraftX) && (prot->zugkraftSteller.parameter == 0)))) + mHauptschalterAus = 0; + } + } + + prot->ftdIntern[18] = (mZugKraft == 0.0f) ? 1.0f : 0.0f; // Lichtmelder + + prot->ftdIntern[19] = sqrt(abs(sp)); // Spielen Rollsound +} + +void AntriebModel::Berechnung(double dt, AntriebsRenderModus antriebsRenderModus, Mehrfachtraktionsdaten mehrfachtraktionsdaten) +{ + if (mHauptschalterAus == 0) + mZugKraft = (ZUGKRAFT_MAX / STUFEN) * mFahrstufe; + else + mZugKraft = 0.0; +} + +void AntriebModel::VorspanntraktionsdatenSetzen(float sp, float sollLeistungNormiert) +{ + mZugKraft = sollLeistungNormiert; +} + +float AntriebModel::LeseMaxAntriebskraft(float spAkt) const +{ + return static_cast(ZUGKRAFT_MAX); +} + +float AntriebModel::LeseAntriebskraft() const +{ + return mZugKraft; +} + +float AntriebModel::LeseFahrstufe() const +{ + return mFahrstufe; +} diff --git a/AntriebModel.h b/AntriebModel.h new file mode 100644 index 0000000..a5ba41f --- /dev/null +++ b/AntriebModel.h @@ -0,0 +1,46 @@ +/** + * @file Zusi 3 Antrieb DLL Test + * @author Jonathan Pilborough / jonathanp +*/ + +#ifndef ANTRIEBMODEL_H +#define ANTRIEBMODEL_H + +#include "antrieb.h" + +class AntriebModel +{ +public: + AntriebModel(int variant); + + //Input + void Bedienung(AntriebsRenderModus antriebsRenderModus, ProtokollFst* prot, float sp); + + void Berechnung(double dt, AntriebsRenderModus antriebsRenderModus, Mehrfachtraktionsdaten mehrfachtraktionsdaten); + + void VorspanntraktionsdatenSetzen(float sp, float sollLeistungNormiert); + + //Output + float LeseMaxAntriebskraft(float spAkt) const; + + float LeseAntriebskraft() const; + + float LeseFahrstufe() const; + +private: + //Init + const int mVariant; + + //State + bool mHauptschalterAus = false; + float mFahrstufe; + + //Output + float mZugKraft; + + //Const + int ZUGKRAFT_MAX = 150000; + int STUFEN = 40; +}; + +#endif \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..acf4646 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,20 @@ +cmake_minimum_required(VERSION 3.8.2) + +project(AntriebDll) + +STRING(REGEX REPLACE "[/\\]+$" "" CMAKE_SOURCE_DIR ${CMAKE_SOURCE_DIR}) +STRING(REGEX REPLACE "[/\\]+$" "" CMAKE_CURRENT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}) + +set(MODULE_FILES + antrieb.h + dllmain.cpp + AntriebModel.h + AntriebModel.cpp +) + +add_library(AntriebDll SHARED ${MODULE_FILES}) + +#include(GenerateExportHeader) +#generate_export_header(DLib) + +target_include_directories(AntriebDll PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}) diff --git a/antrieb.h b/antrieb.h new file mode 100644 index 0000000..cbfce4c --- /dev/null +++ b/antrieb.h @@ -0,0 +1,304 @@ +/** + * @file Zusi 3 Antrieb DLL Test + * @author Jonathan Pilborough / jonathanp +*/ + +#ifndef ANTRIEB_H +#define ANTRIEB_H + +#include + +enum Fahrleitungstyp : uint8_t +{ + Fahrl_Ohne, + Fahrl_Unbestimmt, + Fahrl_15kV16Hz, + Fahrl_25kV50Hz, + Fahrl_1500VDC, + Fahrl_1200VDCHamburg, + Fahrl_3kVDC, + Fahrl_750VDCBerlin, + Fahrl_Bordsystem +}; + +enum AntriebsRenderModus : uint8_t +{ + AntrRnd_EigenesFzg, + AntrRnd_EigenerZug, + AntrRnd_AndererZugOderAP, + AntrRnd_Unsichtbar, + AntrRnd_NichtAufgegleist +}; + +//NOT USED? +struct RechnungVereinfachtGesamtzug +{ + // Konstanten (in akt. Zusammenstellung) + const float MasseGesamt; // kg + const float RotationsZuschlag; // kg + const float Laenge; + const float spMax; + const float LeistungMax; + const float DynLeistungMax; + const float AnfahrKraftMax; + const float BremskraftMax; + const float Bremsmasse; + const float cwA; + const int32_t AnzahlAntriebsAchsen; + + // Variablen + float ZugkraftAkt; + float ZugkraftMaxAkt; // f(sp), die gerade max. möglich Zugkraft + float BremskraftLuftAkt; + float BremskraftDynAkt; + float BremskraftMgAkt; + float HangabtrKraftAkt; // neg: geht bergab + float RollwiderstAkt; + float BogenwiderstAkt; + float LuftwiderstAkt; +}; + +//NOT USED? +struct ProtokollMehrfachTraktion +{ + float SollZugkraft; // absolute Vorgabe aus gesteuertem Fahrzeug + float SollLeistungNormiert; // 0...1 + float ZylDruckDynBremse; // druckluftergänzungsbremse usw. + uint8_t SASchaltungAktuell; // 0 oder $F +}; + +enum KombiSchalterFunktion : uint8_t { + KSF_Nichts, + KSF_FahrstufeX, KSF_FahrstufeSchnellAus, KSF_FahrstufeAufX, KSF_FahrstufeFahren, KSF_FahrstufeAbX, + KSF_DynBremseX, KSF_DynBremsenull, KSF_DynBremseAufX, KSF_DynBremseBremsen, KSF_DynBremseAbX, + KSF_AFBX, KSF_AFBnull, KSF_AFBAuf, KSF_AFBAb, + KSF_AFBEinX, + KSF_ZugkraftX, KSF_ZugkraftSchnellAus, KSF_ZugkraftAuf, KSF_ZugkraftFahren, KSF_ZugkraftAb, + KSF_HllFuellen, KSF_HllDruckX, KSF_HllAbschluss, KSF_HllMittel, KSF_HllBremsenSchnell, + KSF_Angleicher, + KSF_ZbvLoesen, KSF_ZbvMittel, KSF_ZbvBremsen, + KSF_GangWahlX, KSF_GangWahlnull, KSF_GangWahlAuf, KSF_GangwahlFahren, KSF_GangWahlAb, + KSF_RischaV, KSF_RischaM, KSF_Rischa0, KSF_RischaR, + KSF_StufenschalterLG, KSF_Stufenschalter0, KSF_StufenschalterSG, + KSF_GruppenschalterStop, KSF_GruppenschalterAus, KSF_GruppenschalterEin, KSF_GruppenschalterStart, + KSF_StromabnehmerAb, KSF_StromabnehmerNull, KSF_StromabnehmerAuf, + KSF_HauptschalterAus, KSF_HauptschalterNull, KSF_HauptschalterEin, + KSF_MgBremseX, + KSF_SandenX, + KSF_PfeifeX, // ist frei und kann neu belegt werden + KSF_GlockeX, // ist frei und kann neu belegt werden + KSF_LokbremseentlueftenX, + KSF_LuefterX, + KSF_Individuell_01, KSF_Individuell_02, KSF_Individuell_03, KSF_Individuell_04, KSF_Individuell_05, + KSF_Individuell_06, KSF_Individuell_07, KSF_Individuell_08, KSF_Individuell_09, KSF_Individuell_10, + KSF_Individuell_11, KSF_Individuell_12, KSF_Individuell_13, KSF_Individuell_14, KSF_Individuell_15, + KSF_Individuell_16, KSF_Individuell_17, KSF_Individuell_18, KSF_Individuell_19, KSF_Individuell_20, + KSF_WandlerfuellungX, + KSF_LuftpresserAus, + KSF_Notaus, + KSF_Individuell_21, KSF_Individuell_22, KSF_Individuell_23, KSF_Individuell_24, KSF_Individuell_25, + KSF_Individuell_26, KSF_Individuell_27, KSF_Individuell_28, KSF_Individuell_29, KSF_Individuell_30, + KSF_Individuell_31, KSF_Individuell_32, KSF_Individuell_33, KSF_Individuell_34, KSF_Individuell_35, + KSF_Individuell_36, KSF_Individuell_37, KSF_Individuell_38, KSF_Individuell_39, KSF_Individuell_40, + KSF_FederspeicherAnlegen, KSF_FederspeicherNull, KSF_FederspeicherLoesen, KSF_FederspeicherUmschalten, + KSF_BatterieHSAus, KSF_BatterieHSNull, KSF_BatterieHSEin, + KSF_FahrschalterLSSAus, + KSF_DynBremseLSSAus, + KSF_ComputerBremseX, KSF_ComputerBremseAufX, KSF_ComputerBremseBremsen, KSF_ComputerBremseAbX, + KSF_FtdIntern_01, KSF_FtdIntern_02, KSF_FtdIntern_03, KSF_FtdIntern_04, KSF_FtdIntern_05, + KSF_FtdIntern_06, KSF_FtdIntern_07, KSF_FtdIntern_08, KSF_FtdIntern_09, KSF_FtdIntern_10, + KSF_FtdIntern_11, KSF_FtdIntern_12, KSF_FtdIntern_13, KSF_FtdIntern_14, KSF_FtdIntern_15, + KSF_FtdIntern_16, KSF_FtdIntern_17, KSF_FtdIntern_18, KSF_FtdIntern_19, KSF_FtdIntern_20, + KSF_FuehrertischDeaktiviert, + KSF_AntriebsUmschaltung +}; + +struct KombischalterFkt { + KombiSchalterFunktion funktion; + float parameter; +}; + +// Achtung Änderungen sind releveant für Antriebs-Brems-dll !!! +struct ProtokollFst { + KombischalterFkt fbv; + KombischalterFkt bv; + KombischalterFkt rischa; + uint8_t sandEin; + uint8_t luefterEin; + uint8_t mgManuellEin; + uint8_t antriebAbregelnEin; // für Eingriffe Schleuderschutz usw. + uint16_t traktionssperreGrund; // 0: Nichts; 1: Federspeicherbremse aktiv; 2: Türsystem; 3: Bremsprobe läuft; 4: Sifa-HS + uint8_t betriebszwangsbremsungEin; + uint8_t zwangshaltEin; + KombischalterFkt schaltstufenSteller; + KombischalterFkt dynBremsSteller; + KombischalterFkt computerBremsSteller; + KombischalterFkt zugkraftSteller; + KombischalterFkt wandlerfuellung; + KombischalterFkt AFBvSollSteller; + KombischalterFkt ganghebel; + KombischalterFkt stufenschalter; + KombischalterFkt gruppenschalter; + KombischalterFkt hauptschalter; + KombischalterFkt stromabnehmer; + KombischalterFkt batterieHS; + uint8_t dynBremseLSSAus; + uint8_t fahrschalterLSSAus; // 1:deaktiviert 2:Normalzustand 3:gestört + uint8_t AFBEin; // Lage des Schalters + uint8_t AFBvSollNullstellungszwang; // wird gf. von LZB aktiviert + float AFBspMax; // 160 oder fzg-vmax und Beachtung Zugdaten + float AFBsppMax; // max. Beschl, default 0.5 + uint8_t TAVHaltebremse; + uint8_t AFBHaltebremseTrotzFahrschalter; + uint8_t tempomatEin; // Lage des Schalters + uint8_t angleicher; + uint8_t luftpresserAus; + uint8_t lokBremseEntlueften; + uint8_t automatischfahren; + float individuell[40]; // 0 - 39 -> 1 - 40 + KombischalterFkt federspeicher; + uint16_t bremsprobeStatus; + uint8_t schleuderschutzElektronischWirksam; + float ftdIntern[20]; // 0 -> 19 -> 1 - 19 + KombischalterFkt fuehrertischDeaktiviert; + KombischalterFkt antriebsaktivierung; +}; + +struct Grundfahrdaten { // das was jedes Fzg braucht, auch wenn der AP fährt + float pAkt; + float zugkraftAkt; +}; + +struct Mehrfachtraktionsdaten { + Grundfahrdaten Grundfahrdaten; + float spAktNormiert; // 0..1 + float lastAktNormiert; // 0..1 + float lastAktDynBremseNormiert; + float zylDruckDynBremse; // druckluftergänzungsbremse usw. + float druckHL; + float druckHBL; + uint8_t hauptschalterRaus; + uint8_t trennschuetzRaus; + uint8_t sand; + Fahrleitungstyp streckenStromsystem; + float fahrlSpannungsfaktor; // 0, wenn kein SA oben, sonst 1 oder 1,x für schwankende Spannung + KombiSchalterFunktion fahrtRichtung; // KSF_RischaV, KSF_RischaM, KSF_Rischa0, KSF_RischaR, + uint16_t antriebsumschaltung; // Index-Nr ab 1 (0=nichts los) +}; + +#define DLLEXPORT __declspec(dllexport) + +#ifdef __cplusplus +extern "C" +{ +#endif + // alle Einheiten in SI (m, N, m/s, kg, s) + + /* Global Information Functions */ + + // die Funktion sollte eine Messagebox starten, die als kurze Doku zur Funktion + // der dll für den Fahrzeugbauer liefert + DLLEXPORT void Info(); + + // die dll kann mehrere Varianten enthalten, es muss mindestens 1 zurückgegeben werden + DLLEXPORT uint16_t AnzahlVarianten(); + + // Für jede Variante soll ein kurzer String als Beschreibung zurückgegeben werden + // Die strings werden im Fahrzeugeditor in die Combobox gefüllt + // index beginnt bei 0 für die 1. Variante + DLLEXPORT wchar_t* VariantenName(int32_t index); + + /* Initialisation */ + + // Diese Funktion wird beim Start der Fahrt einmal aufgerufen, um der dll + // mitzuteilen, welche der Varianten berechnet werden soll + // index beginnt bei 0 für die 1. Variante + // Rückgabe ist eine Adresse, über die die dll bei mehrfacher Verwendung erkennen + // kann, welche Instanz gerade gefragt ist. Der hier zurückgegebene Wert wird + // von Zusi bei allen Aufrufen als "Instanz" wieder übergeben + DLLEXPORT void* VarianteAktivieren(int32_t index); + + // Antriebstyp gemäß TCP-Doku 0002 000A 008E 0001 0025 0001 + DLLEXPORT uint8_t LeseAntriebstyp(void* instanz); + + /* Input - Simulation Step */ + + // ruft der Sim einmal pro Rechenschritt für das selbstgefahrene Fahrzeug und + // für Fahrzeuge im Mehrfachtraktionsmodus im selbstgefahrenen Zug auf, + // um die Führerstandsbedienung zu übertragen + DLLEXPORT void Bedienung(void* instanz, AntriebsRenderModus antriebsRenderModus, ProtokollFst* prot, float sp); + + // ruft der Sim einmal pro Rechenschritt auf, dort sollen die Berechnungen erfolgen + // wird nur für das selbstgefahrene Fahrzeug und für Fahrzeuge im + // Mehrfachtraktionsmodus im selbstgefahrenen Zug aufgerufen + DLLEXPORT void Berechnung(void* instanz, double dt, AntriebsRenderModus antriebsRenderModus, Mehrfachtraktionsdaten mehrfachtraktionsdaten); + + // das wird für Fahrzeuge einmal pro Rechenschritt aufgerufen, die im eigenen + // Zug im Modus "eigener Tf" fahren und für alle Fahrzeuge im Autopilotmodus + // es muss hier eine vereinfachte, schnelle Berechnung durchgeführt werden + // komplexe Rechenmanöver können die Performance beeinflussen, da sehe viele Züge + // mit diesem Modus im fahrplan unterwegs sein können + DLLEXPORT void VorspanntraktionsdatenSetzen(void* instanz, float sp, float sollLeistungNormiert); + + /* Input - Event Triggers */ + + // wird vom Sim aufgerufen, wenn ein Nullstellungszwang durch das Antriebssystem + // erfolgen muss + DLLEXPORT void Nullstellungszwang(void* instanz); + + // wird vom Sim aufgerufen, wenn sich der Modus des HS ändern soll + // modus: 0: HS ein, 1: HS aus, 2: Spannung frisch an, 3: HS frisch ein + DLLEXPORT void SetzeHauptschalterzustand(void* instanz, uint8_t modus); + + /* Ouput */ + + // die bei der angegebenen Geschwindigkeit max. mögliche Zugkraft + DLLEXPORT float LeseMaxAntriebskraft(void* instanz, float spAkt); + + // div. Fahrgrößen + DLLEXPORT float LeseAntriebskraft(void* instanz); + DLLEXPORT float LeseAntriebskraftSollNormiert(void* instanz); + DLLEXPORT float LeseOberstrom(void* instanz); + DLLEXPORT float LeseMotorstrom(void* instanz); + DLLEXPORT float LeseMotorspannung(void* instanz); + DLLEXPORT int32_t LeseAchsen(void* instanz); + DLLEXPORT float LeseSollZugkraft(void* instanz); + DLLEXPORT float LeseMotordrehzahl(void* instanz); + DLLEXPORT float LeseMotormoment(void* instanz); + DLLEXPORT float LeseMotorlast(void* instanz); + DLLEXPORT float LeseFahrstufe(void* instanz); + + // C-Druck für Druckluftergänzungsbremse o.ä. soll Druckluft-Bremse überstimmen + // -1 keine Vorgabe + DLLEXPORT float LeseZylSolldruck(void* instanz); + + // muss true zurückgeben, wenn das Schaltwerk auf 0 steht + DLLEXPORT float PruefeFahrstufe0(void* instanz); + + // muss true zurückgeben, wenn aus Sicht des Antriebsmodells ein + // Nullstellungszwang aktiv ist + DLLEXPORT uint8_t NullstellungszwangAktiv(void* instanz); + + // muss true zurückgeben, wenn aus Sicht des Antriebsmodells eine + // Hauptschalterauslösung nötig ist wegen unpassender Fahrleitungsspannung + // Spannungsfaktor ist 1, wenn die Fahrleitungsspannung genau dem Sollwert entspricht + DLLEXPORT uint8_t HauptschalterWgOLEnde(void* instanz, Fahrleitungstyp fahrlTyp, float spannungsfaktor); + + // muss true zurückgeben, wenn aus Sicht des Antriebsmodells eine + // Hauptschalterauslösung wg. Oberstromüberschreitung nötig ist. + // für diesen Antrieb muss sich die dll selbst um die Auswirkungen kümmern + // Die Funktion teilt das hier nur z.B. den anderen Einheiten einer Mehrfachtraktion mit + DLLEXPORT uint8_t HauptschalterWgOberstrom(void* instanz); + + // Angabe gemäß Doku zu Führerstands-ID x0013 + DLLEXPORT uint8_t Hauptschalterstatus(void* instanz); + + // Zustand angeben für Luftpresser-Steuerung + DLLEXPORT uint8_t HauptschalterDrin(void* instanz); + DLLEXPORT uint8_t DieselmotorLaeuft(void* instanz); + +#ifdef __cplusplus +} +#endif + +#endif \ No newline at end of file diff --git a/dllmain.cpp b/dllmain.cpp new file mode 100644 index 0000000..f08e9c6 --- /dev/null +++ b/dllmain.cpp @@ -0,0 +1,262 @@ +/** + * @file Zusi 3 Antrieb DLL Test + * @author Jonathan Pilborough / jonathanp +*/ + +#include "antrieb.h" +#include "AntriebModel.h" + +#include +#include + +#include +#include +#include +#include +#include + +using namespace std; + +static ofstream logOutput; +static vector activeModels; + +// Get Path {{Desktop}}\antrieb.log +bool GetLogPath(string& outFile) +{ + static char path[MAX_PATH + 1]; + if (SHGetSpecialFolderPathA(HWND_DESKTOP, path, CSIDL_DESKTOP, FALSE)) + { + outFile.assign(path); + outFile.append("/antrieb.log"); + return true; + } + else + return false; +} + +void OpenLog() +{ + string logPath; + if (GetLogPath(logPath) && !logOutput.is_open()) + { + logOutput.open(logPath); + logOutput << "Log Started" << endl; + } +} + +BOOL WINAPI DllMain(HINSTANCE hinstDLL, + DWORD fdwReason, + LPVOID lpReserved) +{ + switch (fdwReason) + { + case DLL_PROCESS_ATTACH: + break; + + case DLL_THREAD_ATTACH: + break; + + case DLL_THREAD_DETACH: + break; + + case DLL_PROCESS_DETACH: + logOutput << "DLL Unloaded" << endl; + logOutput.close(); + for (int i = 0; i < activeModels.size(); ++i) + delete activeModels[i]; + break; + } + return true; +} + +void Info() +{ + string info; + GetLogPath(info); + info = "Antrieb Test DLL. Logfile: " + info; + MessageBox(NULL, info.c_str(), "Information", MB_ICONINFORMATION); +} + +uint16_t AnzahlVarianten() +{ + return 2; +} + +wchar_t* VariantenName(int32_t index) +{ + if (index == 0) + { + return L"Fahrstufe"; + } + else if (index == 1) + { + return L"Zugkraft"; + } + else + { + return L"Invalid Variant"; + } +} + +/* Initialisation */ +void* VarianteAktivieren(int32_t index) +{ + unique_ptr model = std::make_unique(index); + activeModels.push_back(model.release()); + + OpenLog(); + logOutput << activeModels.back() << " VarianteAktivieren() " << index << endl; + + return activeModels.back(); +} + +uint8_t LeseAntriebstyp(void* instanz) +{ + logOutput << instanz << " LeseAntriebstyp()" << endl; + return 1; +} + +/* Input - Simulation Step */ +void Bedienung(void* instanz, AntriebsRenderModus antriebsRenderModus, ProtokollFst* prot, float sp) +{ + static ProtokollFst lastProtokoll; + + if (prot->rischa.funktion != lastProtokoll.rischa.funktion) + logOutput << instanz << " Input Rischa" << " " << static_cast(prot->rischa.funktion) << endl; + + if (prot->hauptschalter.funktion != lastProtokoll.hauptschalter.funktion) + logOutput << instanz << " Input Hauptschalter" << " " << static_cast(prot->hauptschalter.funktion) << endl; + + if (prot->schaltstufenSteller.parameter != lastProtokoll.schaltstufenSteller.parameter) + logOutput << instanz << " Input Fahrstufe" << " " << prot->schaltstufenSteller.parameter << endl; + + if (prot->zugkraftSteller.parameter != lastProtokoll.zugkraftSteller.parameter) + logOutput << instanz << " Input Zugkraft" << " " << prot->zugkraftSteller.parameter << endl; + + memcpy(&lastProtokoll, prot, sizeof(ProtokollFst)); + + static_cast(instanz)->Bedienung(antriebsRenderModus, prot, sp); +} + +void Berechnung(void* instanz, double dt, AntriebsRenderModus antriebsRenderModus, Mehrfachtraktionsdaten mehrfachtraktionsdaten) +{ + static_cast(instanz)->Berechnung(dt, antriebsRenderModus, mehrfachtraktionsdaten); +} + +void VorspanntraktionsdatenSetzen(void* instanz, float sp, float sollLeistungNormiert) +{ + static_cast(instanz)->VorspanntraktionsdatenSetzen(sp, sollLeistungNormiert); +} + +/* Input - Event Triggers */ +void Nullstellungszwang(void* instanz) +{ + logOutput << instanz << " Nullstellungszwang()" << endl; +} + +void SetzeHauptschalterzustand(void* instanz, uint8_t modus) +{ + logOutput << instanz << " SetzeHauptschalterzustand() " << " -> " << static_cast(modus) << endl; +} + +/* Output */ + +float LeseMaxAntriebskraft(void* instanz, float spAkt) +{ + return static_cast(instanz)->LeseMaxAntriebskraft(spAkt); +} + +float LeseAntriebskraft(void* instanz) +{ + return static_cast(instanz)->LeseAntriebskraft(); +} + +float LeseAntriebskraftSollNormiert(void* instanz) +{ + return 0; +} + +float LeseOberstrom(void* instanz) +{ + return 0; +} + +float LeseMotorstrom(void* instanz) +{ + return 0; +} + +float LeseMotorspannung(void* instanz) +{ + return 0; +} + +int32_t LeseAchsen(void* instanz) +{ + return 0; +} + +float LeseSollZugkraft(void* instanz) +{ + return 0; +} + +float LeseMotordrehzahl(void* instanz) +{ + return 0; +} + +float LeseMotormoment(void* instanz) +{ + return 0; +} + +float LeseMotorlast(void* instanz) +{ + return 0; +} + +float LeseFahrstufe(void* instanz) +{ + return static_cast(instanz)->LeseFahrstufe(); +} + +float LeseZylSolldruck(void* instanz) +{ + return -1; +} + +float PruefeFahrstufe0(void* instanz) +{ + return true; +} + +uint8_t NullstellungszwangAktiv(void* instanz) +{ + return false; +} + +uint8_t HauptschalterWgOLEnde(void* instanz, Fahrleitungstyp fahrlTyp, float spannungsfaktor) +{ + return false; +} + +uint8_t HauptschalterWgOberstrom(void* instanz) +{ + return false; +} + +uint8_t Hauptschalterstatus(void* instanz) +{ + return 0; //Hauptschalter ein +} + +uint8_t HauptschalterDrin(void* instanz) +{ + return true; +} + +uint8_t DieselmotorLaeuft(void* instanz) +{ + return false; +}