Initial version

AntriebModel.cpp

@@ -0,0 +1,86 @@
+/**
+ * @file Zusi 3 Antrieb DLL Test
+ * @author Jonathan Pilborough / jonathanp
+*/
+
+#include "AntriebModel.h"
+
+#include <cmath>
+
+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<float>(ZUGKRAFT_MAX);
+}
+
+float AntriebModel::LeseAntriebskraft() const
+{
+	return mZugKraft;
+}
+
+float AntriebModel::LeseFahrstufe() const
+{
+	return mFahrstufe;
+}

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

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})

antrieb.h

@@ -0,0 +1,304 @@
+/**
+ * @file Zusi 3 Antrieb DLL Test
+ * @author Jonathan Pilborough / jonathanp
+*/
+
+#ifndef ANTRIEB_H
+#define ANTRIEB_H
+
+#include <stdint.h>
+
+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

dllmain.cpp

@@ -0,0 +1,262 @@
+/**
+ * @file Zusi 3 Antrieb DLL Test
+ * @author Jonathan Pilborough / jonathanp
+*/
+
+#include "antrieb.h"
+#include "AntriebModel.h"
+
+#include <windows.h>
+#include <shlobj.h>
+
+#include <fstream>
+#include <vector>
+#include <memory>
+#include <cstring>
+#include <string>
+
+using namespace std;
+
+static ofstream logOutput;
+static vector<AntriebModel*> 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<AntriebModel> model = std::make_unique<AntriebModel>(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<uint32_t>(prot->rischa.funktion) << endl;
+
+	if (prot->hauptschalter.funktion != lastProtokoll.hauptschalter.funktion)
+		logOutput << instanz << " Input Hauptschalter" << " " << static_cast<uint32_t>(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<AntriebModel*>(instanz)->Bedienung(antriebsRenderModus, prot, sp);
+}
+
+void Berechnung(void* instanz, double dt, AntriebsRenderModus antriebsRenderModus, Mehrfachtraktionsdaten mehrfachtraktionsdaten)
+{
+	static_cast<AntriebModel*>(instanz)->Berechnung(dt, antriebsRenderModus, mehrfachtraktionsdaten);
+}
+
+void VorspanntraktionsdatenSetzen(void* instanz, float sp, float sollLeistungNormiert)
+{
+	static_cast<AntriebModel*>(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<uint32_t>(modus) << endl;
+}
+
+/* Output */
+
+float LeseMaxAntriebskraft(void* instanz, float spAkt)
+{
+	return static_cast<AntriebModel*>(instanz)->LeseMaxAntriebskraft(spAkt);
+}
+
+float LeseAntriebskraft(void* instanz)
+{
+	return static_cast<AntriebModel*>(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<AntriebModel*>(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;
+}