diff --git a/.gitignore b/.gitignore index 5d458f21..33ae4d7b 100644 --- a/.gitignore +++ b/.gitignore @@ -64,3 +64,7 @@ MaSzyna.sln MaSzyna.vcxproj MaSzyna.vcxproj.filters *.suo +EU07.tds +MaSzyna.VC.VC.opendb +MaSzyna.VC.db +.vs/ diff --git a/DynObj.cpp b/DynObj.cpp index 8209f140..c0bc7355 100644 --- a/DynObj.cpp +++ b/DynObj.cpp @@ -1763,10 +1763,10 @@ TDynamicObject::Init(string Name, // nazwa pojazdu, np. "EU07-424" // kropkę na koniec int kropka = MoreParams.find("."); // znajdź kropke string ActPar; // na parametry - while (kropka > 0) // jesli sa kropki jeszcze + while (kropka != std::string::npos) // jesli sa kropki jeszcze { int dlugosc = MoreParams.length(); - ActPar = ToUpper(MoreParams.substr(0, kropka - 1)); // pierwszy parametr; + ActPar = ToUpper(MoreParams.substr(0, kropka)); // pierwszy parametr; MoreParams = MoreParams.substr(kropka + 1, dlugosc - kropka); // reszta do dalszej // obrobki kropka = MoreParams.find("."); diff --git a/EU07.bpr b/EU07.bpr index bba60ba9..74206a6d 100644 --- a/EU07.bpr +++ b/EU07.bpr @@ -41,8 +41,7 @@ - + @@ -58,9 +57,9 @@ IncludeVerInfo=1 AutoIncBuild=0 MajorVer=16 -MinorVer=0 -Release=1173 -Build=481 +MinorVer=1 +Release=1174 +Build=483 Debug=1 PreRelease=0 Special=0 @@ -72,13 +71,13 @@ CodePage=1250 [Version Info Keys] CompanyName=EU07 Team FileDescription=MaSzyna EU07-424 -FileVersion=16.0.1173.481 +FileVersion=16.1.1174.483 InternalName=DP+SPKS+asynch+python LegalCopyright= LegalTrademarks= OriginalFilename=eu07.exe ProductName=MaSzyna EU07-424 -ProductVersion=16.0 +ProductVersion=16.1 Comments= [Excluded Packages] diff --git a/Globals.cpp b/Globals.cpp index b9b115a9..4e217ac2 100644 --- a/Globals.cpp +++ b/Globals.cpp @@ -54,9 +54,9 @@ double Global::fLuminance = 1.0; // jasno int Global::iReCompile = 0; // zwiększany, gdy trzeba odświeżyć siatki HWND Global::hWnd = NULL; // uchwyt okna int Global::iCameraLast = -1; -std::string Global::asRelease = "16.0.1172.481"; +std::string Global::asRelease = "16.1.1174.483"; std::string Global::asVersion = - "Compilation 2016-08-24, release " + Global::asRelease + "."; // tutaj, bo wysyłany + "Compilation 2017-01-13, release " + Global::asRelease + "."; // tutaj, bo wysyłany int Global::iViewMode = 0; // co aktualnie widać: 0-kabina, 1-latanie, 2-sprzęgi, 3-dokumenty int Global::iTextMode = 0; // tryb pracy wyświetlacza tekstowego int Global::iScreenMode[12] = {0, 0, 0, 0, 0, 0, diff --git a/Ground.cpp b/Ground.cpp index 5067c0c5..27a812b3 100644 --- a/Ground.cpp +++ b/Ground.cpp @@ -1809,7 +1809,7 @@ TGroundNode * TGround::AddGroundNode(cParser *parser) if (int2 != string::npos) // yB: jesli znalazl kropke, to ja przetwarza jako parametry { int dlugosc = str4.length(); - int1 = atoi(str4.substr(0, int2 - 1).c_str()); // niech sprzegiem bedzie do kropki cos + int1 = atoi(str4.substr(0, int2).c_str()); // niech sprzegiem bedzie do kropki cos str4 = str4.substr(int2 + 1, dlugosc - int2); } else diff --git a/McZapkie/MOVER.h b/McZapkie/MOVER.h index 313b71d0..789be7fb 100644 --- a/McZapkie/MOVER.h +++ b/McZapkie/MOVER.h @@ -10,12 +10,13 @@ http://mozilla.org/MPL/2.0/. #ifndef MoverH #define MoverH //--------------------------------------------------------------------------- -//#include "Mover.hpp" //Q: 20160805 - odlaczenie pliku fizyki .pas od kompilacji +//#include "Mover.hpp" //Q: 20160805 - +//odlaczenie pliku fizyki .pas od kompilacji #include "Oerlikon_ESt.h" #include "hamulce.h" -#include #include "mctools.h" #include +#include /* MaSzyna EU07 locomotive simulator @@ -23,7 +24,6 @@ Copyright (C) 2001-2004 Maciej Czapkiewicz and others */ - /* (C) McZapkie v.2004.02 Co brakuje: @@ -62,9 +62,12 @@ zwiekszenie nacisku przy duzych predkosciach w hamulcach Oerlikona 20. poprawione hamulce elektropneumatyczne 21. poprawione hamowanie przeciwposlizgowe i odluzniacz 22. dodany model mechanicznego napedu recznego (drezyna) -23. poprawiona szybkosc hamowania pomocniczego i przeciwposlizgowego, odlaczanie silnikow, odlaczanie bocznikow -24. wprowadzone systemy zabezpieczenia: SHP, Czuwak, sygnalizacja kabinowa (nie dzialaja w DebugMode). -25. poprawiona predkosc propagacji fali cisnienia (normalizacja przez kwadrat dlugosci) //to jest zdeka liniowe +23. poprawiona szybkosc hamowania pomocniczego i przeciwposlizgowego, odlaczanie silnikow, +odlaczanie bocznikow +24. wprowadzone systemy zabezpieczenia: SHP, Czuwak, sygnalizacja kabinowa (nie dzialaja w +DebugMode). +25. poprawiona predkosc propagacji fali cisnienia (normalizacja przez kwadrat dlugosci) //to jest +zdeka liniowe 26. uwzgledniona masa ladunku, przesuniecie w/m toru ruchu 27. lampy/sygnaly przednie/tylne 28. wprowadzona pozycja odciecia hamulca (yB: tja, ale oerlikona....) @@ -85,23 +88,23 @@ zwiekszenie nacisku przy duzych predkosciach w hamulcach Oerlikona #include "dumb3d.h" using namespace Math3D; -const double Steel2Steel_friction = 0.15; //tarcie statyczne -const double g = 9.81; //przyspieszenie ziemskie -const double SandSpeed = 0.1; //ile kg/s} -const double RVentSpeed = 0.4; //rozpedzanie sie wentylatora obr/s^2} -const double RVentMinI = 50.0; //przy jakim pradzie sie wylaczaja} +const double Steel2Steel_friction = 0.15; // tarcie statyczne +const double g = 9.81; // przyspieszenie ziemskie +const double SandSpeed = 0.1; // ile kg/s} +const double RVentSpeed = 0.4; // rozpedzanie sie wentylatora obr/s^2} +const double RVentMinI = 50.0; // przy jakim pradzie sie wylaczaja} const double Pirazy2 = 6.2831853071794f; #define PI 3.1415926535897f //-- var, const, procedure --------------------------------------------------- static bool const Go = true; -static bool const Hold = false; /*dla CheckLocomotiveParameters*/ -static int const ResArraySize = 64; /*dla silnikow elektrycznych*/ +static bool const Hold = false; /*dla CheckLocomotiveParameters*/ +static int const ResArraySize = 64; /*dla silnikow elektrycznych*/ static int const MotorParametersArraySize = 10; -static int const maxcc = 4; /*max. ilosc odbierakow pradu*/ -//static int const LocalBrakePosNo = 10; /*ilosc nastaw hamulca pomocniczego*/ -//static int const MainBrakeMaxPos = 10; /*max. ilosc nastaw hamulca zasadniczego*/ -static int const ManualBrakePosNo = 20; /*ilosc nastaw hamulca recznego*/ +static int const maxcc = 4; /*max. ilosc odbierakow pradu*/ +// static int const LocalBrakePosNo = 10; /*ilosc nastaw hamulca pomocniczego*/ +// static int const MainBrakeMaxPos = 10; /*max. ilosc nastaw hamulca zasadniczego*/ +static int const ManualBrakePosNo = 20; /*ilosc nastaw hamulca recznego*/ static int const LightsSwitchPosNo = 16; /*uszkodzenia toru*/ @@ -114,38 +117,39 @@ static int const dtrack_nomove = 64; static int const dtrack_norail = 128; /*uszkodzenia taboru*/ -static int const dtrain_thinwheel = 1; /*dla lokomotyw*/ -static int const dtrain_loadshift = 1; /*dla wagonow*/ +static int const dtrain_thinwheel = 1; /*dla lokomotyw*/ +static int const dtrain_loadshift = 1; /*dla wagonow*/ static int const dtrain_wheelwear = 2; static int const dtrain_bearing = 4; static int const dtrain_coupling = 8; -static int const dtrain_ventilator = 16; /*dla lokomotywy el.*/ -static int const dtrain_loaddamage = 16; /*dla wagonow*/ -static int const dtrain_engine = 32; /*dla lokomotyw*/ -static int const dtrain_loaddestroyed = 32;/*dla wagonow*/ +static int const dtrain_ventilator = 16; /*dla lokomotywy el.*/ +static int const dtrain_loaddamage = 16; /*dla wagonow*/ +static int const dtrain_engine = 32; /*dla lokomotyw*/ +static int const dtrain_loaddestroyed = 32; /*dla wagonow*/ static int const dtrain_axle = 64; -static int const dtrain_out = 128; /*wykolejenie*/ +static int const dtrain_out = 128; /*wykolejenie*/ - /*wagi prawdopodobienstwa dla funkcji FuzzyLogic*/ -#define p_elengproblem (1.000000E-02) -#define p_elengdamage (1.000000E-01) -#define p_coupldmg (2.000000E-02) -#define p_derail (1.000000E-03) -#define p_accn (1.000000E-01) -#define p_slippdmg (1.000000E-03) +/*wagi prawdopodobienstwa dla funkcji FuzzyLogic*/ +#define p_elengproblem (1.000000E-02) +#define p_elengdamage (1.000000E-01) +#define p_coupldmg (2.000000E-02) +#define p_derail (1.000000E-03) +#define p_accn (1.000000E-01) +#define p_slippdmg (1.000000E-03) - /*typ sprzegu*/ -static int const ctrain_virtual = 0; //gdy pojazdy na tym samym torze się widzą wzajemnie -static int const ctrain_coupler = 1; //sprzeg fizyczny -static int const ctrain_pneumatic = 2; //przewody hamulcowe -static int const ctrain_controll = 4; //przewody sterujące (ukrotnienie) -static int const ctrain_power = 8; //przewody zasilające (WN) -static int const ctrain_passenger = 16; //mostek przejściowy -static int const ctrain_scndpneumatic = 32; //przewody 8 atm (żółte; zasilanie powietrzem) -static int const ctrain_heating = 64; //przewody ogrzewania WN -static int const ctrain_depot = 128; //nie rozłączalny podczas zwykłych manewrów (międzyczłonowy), we wpisie wartość ujemna +/*typ sprzegu*/ +static int const ctrain_virtual = 0; // gdy pojazdy na tym samym torze się widzą wzajemnie +static int const ctrain_coupler = 1; // sprzeg fizyczny +static int const ctrain_pneumatic = 2; // przewody hamulcowe +static int const ctrain_controll = 4; // przewody sterujące (ukrotnienie) +static int const ctrain_power = 8; // przewody zasilające (WN) +static int const ctrain_passenger = 16; // mostek przejściowy +static int const ctrain_scndpneumatic = 32; // przewody 8 atm (żółte; zasilanie powietrzem) +static int const ctrain_heating = 64; // przewody ogrzewania WN +static int const ctrain_depot = + 128; // nie rozłączalny podczas zwykłych manewrów (międzyczłonowy), we wpisie wartość ujemna - /*typ hamulca elektrodynamicznego*/ +/*typ hamulca elektrodynamicznego*/ static int const dbrake_none = 0; static int const dbrake_passive = 1; static int const dbrake_switch = 2; @@ -153,14 +157,14 @@ static int const dbrake_reversal = 4; static int const dbrake_automatic = 8; /*status czuwaka/SHP*/ -//hunter-091012: rozdzielenie alarmow, dodanie testu czuwaka -static int const s_waiting = 1; //działa -static int const s_aware = 2; //czuwak miga -static int const s_active = 4; //SHP świeci -static int const s_CAalarm = 8; //buczy -static int const s_SHPalarm = 16; //buczy -static int const s_CAebrake = 32; //hamuje -static int const s_SHPebrake = 64; //hamuje +// hunter-091012: rozdzielenie alarmow, dodanie testu czuwaka +static int const s_waiting = 1; // działa +static int const s_aware = 2; // czuwak miga +static int const s_active = 4; // SHP świeci +static int const s_CAalarm = 8; // buczy +static int const s_SHPalarm = 16; // buczy +static int const s_CAebrake = 32; // hamuje +static int const s_SHPebrake = 64; // hamuje static int const s_CAtest = 128; /*dzwieki*/ @@ -173,22 +177,22 @@ static int const sound_relay = 16; static int const sound_manyrelay = 32; static int const sound_brakeacc = 64; -static bool PhysicActivationFlag = false; +static bool PhysicActivationFlag = false; -//szczególne typy pojazdów (inna obsługa) dla zmiennej TrainType -//zamienione na flagi bitowe, aby szybko wybierać grupę (np. EZT+SZT) +// szczególne typy pojazdów (inna obsługa) dla zmiennej TrainType +// zamienione na flagi bitowe, aby szybko wybierać grupę (np. EZT+SZT) static int const dt_Default = 0; static int const dt_EZT = 1; static int const dt_ET41 = 2; static int const dt_ET42 = 4; static int const dt_PseudoDiesel = 8; -static int const dt_ET22 = 0x10; //używane od Megapacka -static int const dt_SN61 = 0x20; //nie używane w warunkach, ale ustawiane z CHK +static int const dt_ET22 = 0x10; // używane od Megapacka +static int const dt_SN61 = 0x20; // nie używane w warunkach, ale ustawiane z CHK static int const dt_EP05 = 0x40; static int const dt_ET40 = 0x80; static int const dt_181 = 0x100; -//stałe dla asynchronów +// stałe dla asynchronów static int const eimc_s_dfic = 0; static int const eimc_s_dfmax = 1; static int const eimc_s_p = 2; @@ -211,7 +215,7 @@ static int const eimc_p_Imax = 20; static int const eimc_p_abed = 21; static int const eimc_p_eped = 22; -//zmienne dla asynchronów +// zmienne dla asynchronów static int const eimv_FMAXMAX = 0; static int const eimv_Fmax = 1; static int const eimv_ks = 2; @@ -241,35 +245,37 @@ static int const bom_MED = 8; enum TProblem // lista problemów taboru, które uniemożliwiają jazdę { // flagi bitowe - pr_Hamuje = 1, // pojazd ma załączony hamulec lub zatarte osie - pr_Pantografy = 2, // pojazd wymaga napompowania pantografów - pr_Ostatni = 0x80000000 // ostatnia flaga bitowa + pr_Hamuje = 1, // pojazd ma załączony hamulec lub zatarte osie + pr_Pantografy = 2, // pojazd wymaga napompowania pantografów + pr_Ostatni = 0x80000000 // ostatnia flaga bitowa }; /*ogolne*/ struct TLocation { - double X; - double Y; - double Z; /*lokacja*/ - inline TLocation() { + double X; + double Y; + double Z; /*lokacja*/ + inline TLocation() + { X, Y, Z = 0.0; } }; struct TRotation { - double Rx; - double Ry; - double Rz; /*rotacja*/ - inline TRotation() { + double Rx; + double Ry; + double Rz; /*rotacja*/ + inline TRotation() + { Rx, Ry, Rz = 0.0; } }; struct TDimension { - double W; - double L; - double H; /*wymiary*/ + double W; + double L; + double H; /*wymiary*/ inline TDimension() { W = 0.0; @@ -280,11 +286,12 @@ struct TDimension struct TCommand { - std::string Command; /*komenda*/ - double Value1; - double Value2; /*argumenty komendy*/ - TLocation Location; - inline TCommand() { + std::string Command; /*komenda*/ + double Value1; + double Value2; /*argumenty komendy*/ + TLocation Location; + inline TCommand() + { Command = ""; Value1, Value2 = 0.0; Location = TLocation(); @@ -293,25 +300,27 @@ struct TCommand /*tory*/ struct TTrackShape -{/*ksztalt odcinka - promien, dlugosc, nachylenie, przechylka*/ - double R; - double Len; - double dHtrack; - double dHrail; - inline TTrackShape() { +{ /*ksztalt odcinka - promien, dlugosc, nachylenie, przechylka*/ + double R; + double Len; + double dHtrack; + double dHrail; + inline TTrackShape() + { R, Len, dHrail, dHtrack = 0.0; } }; struct TTrackParam -{/*parametry odcinka - szerokosc, tarcie statyczne, kategoria, obciazalnosc w t/os, uszkodzenia*/ - double Width; - double friction; - int CategoryFlag; - int QualityFlag; - int DamageFlag; - double Velmax; /*dla uzytku maszynisty w ai_driver*/ - inline TTrackParam() { +{ /*parametry odcinka - szerokosc, tarcie statyczne, kategoria, obciazalnosc w t/os, uszkodzenia*/ + double Width; + double friction; + int CategoryFlag; + int QualityFlag; + int DamageFlag; + double Velmax; /*dla uzytku maszynisty w ai_driver*/ + inline TTrackParam() + { Width, friction, Velmax = 0.0; CategoryFlag, QualityFlag, DamageFlag = 0; } @@ -319,11 +328,12 @@ struct TTrackParam struct TTractionParam { - double TractionVoltage; /*napiecie*/ - double TractionFreq; /*czestotliwosc*/ - double TractionMaxCurrent; /*obciazalnosc*/ - double TractionResistivity; /*rezystancja styku*/ - inline TTractionParam() { + double TractionVoltage; /*napiecie*/ + double TractionFreq; /*czestotliwosc*/ + double TractionMaxCurrent; /*obciazalnosc*/ + double TractionResistivity; /*rezystancja styku*/ + inline TTractionParam() + { TractionVoltage, TractionFreq = 0.0; TractionMaxCurrent, TractionResistivity = 0.0; } @@ -331,45 +341,141 @@ struct TTractionParam /*powyzsze parametry zwiazane sa z torem po ktorym aktualnie pojazd jedzie*/ /*typy hamulcow zespolonych*/ -enum TBrakeSystem { Individual, Pneumatic, ElectroPneumatic }; +enum TBrakeSystem +{ + Individual, + Pneumatic, + ElectroPneumatic +}; /*podtypy hamulcow zespolonych*/ -enum TBrakeSubSystem { ss_None, ss_W, ss_K, ss_KK, ss_Hik, ss_ESt, ss_KE, ss_LSt, ss_MT, ss_Dako }; -enum TBrakeValve { NoValve, W, W_Lu_VI, W_Lu_L, W_Lu_XR, K, Kg, Kp, Kss, Kkg, Kkp, Kks, Hikg1, Hikss, Hikp1, KE, SW, EStED, NESt3, ESt3, LSt, ESt4, ESt3AL2, EP1, EP2, M483, CV1_L_TR, CV1, CV1_R, Other }; -enum TBrakeHandle { NoHandle, West, FV4a, M394, M254, FVel1, FVel6, D2, Knorr, FD1, BS2, testH, St113, MHZ_P, MHZ_T, MHZ_EN57 }; +enum TBrakeSubSystem +{ + ss_None, + ss_W, + ss_K, + ss_KK, + ss_Hik, + ss_ESt, + ss_KE, + ss_LSt, + ss_MT, + ss_Dako +}; +enum TBrakeValve +{ + NoValve, + W, + W_Lu_VI, + W_Lu_L, + W_Lu_XR, + K, + Kg, + Kp, + Kss, + Kkg, + Kkp, + Kks, + Hikg1, + Hikss, + Hikp1, + KE, + SW, + EStED, + NESt3, + ESt3, + LSt, + ESt4, + ESt3AL2, + EP1, + EP2, + M483, + CV1_L_TR, + CV1, + CV1_R, + Other +}; +enum TBrakeHandle +{ + NoHandle, + West, + FV4a, + M394, + M254, + FVel1, + FVel6, + D2, + Knorr, + FD1, + BS2, + testH, + St113, + MHZ_P, + MHZ_T, + MHZ_EN57 +}; /*typy hamulcow indywidualnych*/ -enum TLocalBrake { NoBrake, ManualBrake, PneumaticBrake, HydraulicBrake }; +enum TLocalBrake +{ + NoBrake, + ManualBrake, + PneumaticBrake, + HydraulicBrake +}; /*dla osob/towar: opoznienie hamowania/odhamowania*/ typedef double TBrakeDelayTable[4]; struct TBrakePressure { - double PipePressureVal; - double BrakePressureVal; - double FlowSpeedVal; - TBrakeSystem BrakeType; - inline TBrakePressure() { + double PipePressureVal; + double BrakePressureVal; + double FlowSpeedVal; + TBrakeSystem BrakeType; + inline TBrakePressure() + { BrakeType = Pneumatic; PipePressureVal, BrakePressureVal, FlowSpeedVal = 0.0; } }; -typedef std::map TBrakePressureTable; - +typedef std::map TBrakePressureTable; /*typy napedow*/ -enum TEngineTypes { None, Dumb, WheelsDriven, ElectricSeriesMotor, ElectricInductionMotor, DieselEngine, SteamEngine, DieselElectric }; +enum TEngineTypes +{ + None, + Dumb, + WheelsDriven, + ElectricSeriesMotor, + ElectricInductionMotor, + DieselEngine, + SteamEngine, + DieselElectric +}; /*postac dostarczanej energii*/ -enum TPowerType { NoPower, BioPower, MechPower, ElectricPower, SteamPower }; +enum TPowerType +{ + NoPower, + BioPower, + MechPower, + ElectricPower, + SteamPower +}; /*rodzaj paliwa*/ -enum TFuelType { Undefined, Coal, Oil }; +enum TFuelType +{ + Undefined, + Coal, + Oil +}; /*rodzaj rusztu*/ -struct TGrateType { - TFuelType FuelType; - double GrateSurface; - double FuelTransportSpeed; - double IgnitionTemperature; - double MaxTemperature; - //inline TGrateType() { +struct TGrateType +{ + TFuelType FuelType; + double GrateSurface; + double FuelTransportSpeed; + double IgnitionTemperature; + double MaxTemperature; + // inline TGrateType() { // FuelType = Undefined; // GrateSurface = 0.0; // FuelTransportSpeed = 0.0; @@ -378,13 +484,15 @@ struct TGrateType { //} }; /*rodzaj kotla*/ -struct TBoilerType { - double BoilerVolume; - double BoilerHeatSurface; - double SuperHeaterSurface; - double MaxWaterVolume; double MinWaterVolume; - double MaxPressure; - //inline TBoilerType() { +struct TBoilerType +{ + double BoilerVolume; + double BoilerHeatSurface; + double SuperHeaterSurface; + double MaxWaterVolume; + double MinWaterVolume; + double MaxPressure; + // inline TBoilerType() { // BoilerVolume = 0.0; // BoilerHeatSurface = 0.0; // SuperHeaterSurface = 0.0; @@ -394,30 +502,42 @@ struct TBoilerType { //} }; /*rodzaj odbieraka pradu*/ -struct TCurrentCollector { - long CollectorsNo; //musi być tu, bo inaczej się kopie - double MinH; double MaxH; //zakres ruchu pantografu, nigdzie nie używany - double CSW; //szerokość części roboczej (styku) ślizgacza - double MinV; double MaxV; //minimalne i maksymalne akceptowane napięcie - double OVP; //czy jest przekaznik nadnapieciowy - double InsetV; //minimalne napięcie wymagane do załączenia - double MinPress; //minimalne ciśnienie do załączenia WS - double MaxPress; //maksymalne ciśnienie za reduktorem - //inline TCurrentCollector() { +struct TCurrentCollector +{ + long CollectorsNo; // musi być tu, bo inaczej się kopie + double MinH; + double MaxH; // zakres ruchu pantografu, nigdzie nie używany + double CSW; // szerokość części roboczej (styku) ślizgacza + double MinV; + double MaxV; // minimalne i maksymalne akceptowane napięcie + double OVP; // czy jest przekaznik nadnapieciowy + double InsetV; // minimalne napięcie wymagane do załączenia + double MinPress; // minimalne ciśnienie do załączenia WS + double MaxPress; // maksymalne ciśnienie za reduktorem + // inline TCurrentCollector() { // CollectorsNo = 0; // MinH, MaxH, CSW, MinV, MaxV = 0.0; // OVP, InsetV, MinPress, MaxPress = 0.0; //} }; /*typy źródeł mocy*/ -enum TPowerSource { NotDefined, InternalSource, Transducer, Generator, Accumulator, CurrentCollector, PowerCable, Heater }; - +enum TPowerSource +{ + NotDefined, + InternalSource, + Transducer, + Generator, + Accumulator, + CurrentCollector, + PowerCable, + Heater +}; struct _mover__1 { - double MaxCapacity; - TPowerSource RechargeSource; - //inline _mover__1() { + double MaxCapacity; + TPowerSource RechargeSource; + // inline _mover__1() { // MaxCapacity = 0.0; // RechargeSource = NotDefined; //} @@ -425,9 +545,9 @@ struct _mover__1 struct _mover__2 { - TPowerType PowerTrans; - double SteamPressure; - //inline _mover__2() { + TPowerType PowerTrans; + double SteamPressure; + // inline _mover__2() { // SteamPressure = 0.0; // PowerTrans = NoPower; //} @@ -435,56 +555,47 @@ struct _mover__2 struct _mover__3 { - TGrateType Grate; - TBoilerType Boiler; + TGrateType Grate; + TBoilerType Boiler; }; /*parametry źródeł mocy*/ struct TPowerParameters { - double MaxVoltage; - double MaxCurrent; - double IntR; - TPowerSource SourceType; - union - { - struct - { - _mover__3 RHeater; - - }; - struct - { - _mover__2 RPowerCable; - - }; - struct - { - TCurrentCollector CollectorParameters; - - }; - struct - { - _mover__1 RAccumulator; - - }; - struct - { - TEngineTypes GeneratorEngine; - - }; - struct - { - double InputVoltage; - - }; - struct - { - TPowerType PowerType; - - }; - - }; + double MaxVoltage; + double MaxCurrent; + double IntR; + TPowerSource SourceType; + union { + struct + { + _mover__3 RHeater; + }; + struct + { + _mover__2 RPowerCable; + }; + struct + { + TCurrentCollector CollectorParameters; + }; + struct + { + _mover__1 RAccumulator; + }; + struct + { + TEngineTypes GeneratorEngine; + }; + struct + { + double InputVoltage; + }; + struct + { + TPowerType PowerType; + }; + }; inline TPowerParameters() { MaxVoltage = 0.0; @@ -499,12 +610,12 @@ struct TPowerParameters /*dla lokomotyw elektrycznych:*/ struct TScheme { - int Relay; /*numer pozycji rozruchu samoczynnego*/ - double R; /*opornik rozruchowy*/ /*dla dizla napelnienie*/ - int Bn; - int Mn; /*ilosc galezi i silnikow w galezi*/ /*dla dizla Mn: czy luz czy nie*/ - bool AutoSwitch; /*czy dana pozycja nastawniana jest recznie czy autom.*/ - int ScndAct; /*jesli ma bocznik w nastawniku, to ktory bocznik na ktorej pozycji*/ + int Relay; /*numer pozycji rozruchu samoczynnego*/ + double R; /*opornik rozruchowy*/ /*dla dizla napelnienie*/ + int Bn; + int Mn; /*ilosc galezi i silnikow w galezi*/ /*dla dizla Mn: czy luz czy nie*/ + bool AutoSwitch; /*czy dana pozycja nastawniana jest recznie czy autom.*/ + int ScndAct; /*jesli ma bocznik w nastawniku, to ktory bocznik na ktorej pozycji*/ inline TScheme() { Relay = 0; @@ -518,37 +629,38 @@ struct TScheme typedef TScheme TSchemeTable[ResArraySize + 1]; /*tablica rezystorow rozr.*/ struct TDEScheme { - double RPM; /*obroty diesla*/ - double GenPower; /*moc maksymalna*/ - double Umax; /*napiecie maksymalne*/ - double Imax; /*prad maksymalny*/ + double RPM; /*obroty diesla*/ + double GenPower; /*moc maksymalna*/ + double Umax; /*napiecie maksymalne*/ + double Imax; /*prad maksymalny*/ }; typedef TDEScheme TDESchemeTable[33]; /*tablica rezystorow rozr.*/ struct TShuntScheme { - double Umin; - double Umax; - double Pmin; - double Pmax; + double Umin; + double Umax; + double Pmin; + double Pmax; }; typedef TShuntScheme TShuntSchemeTable[33]; struct TMPTRelay -{/*lista przekaznikow bocznikowania*/ - double Iup; - double Idown; +{ /*lista przekaznikow bocznikowania*/ + double Iup; + double Idown; }; typedef TMPTRelay TMPTRelayTable[8]; struct TMotorParameters { - double mfi; - double mIsat; - double mfi0; // aproksymacja M(I) silnika} {dla dizla mIsat=przekladnia biegu - double fi; - double Isat; - double fi0; // aproksymacja E(n)=fi*n} {dla dizla fi, mfi: predkosci przelozenia biegu <-> - bool AutoSwitch; - TMotorParameters() { + double mfi; + double mIsat; + double mfi0; // aproksymacja M(I) silnika} {dla dizla mIsat=przekladnia biegu + double fi; + double Isat; + double fi0; // aproksymacja E(n)=fi*n} {dla dizla fi, mfi: predkosci przelozenia biegu <-> + bool AutoSwitch; + TMotorParameters() + { mfi = 0.0; mIsat = 0.0; mfi0 = 0.0; @@ -561,588 +673,668 @@ struct TMotorParameters struct TSecuritySystem { - int SystemType; /*0: brak, 1: czuwak aktywny, 2: SHP/sygnalizacja kabinowa*/ - double AwareDelay; // czas powtarzania czuwaka - double AwareMinSpeed; // minimalna prędkość załączenia czuwaka, normalnie 10% Vmax - double SoundSignalDelay; - double EmergencyBrakeDelay; - int Status; /*0: wylaczony, 1: wlaczony, 2: czuwak, 4: shp, 8: alarm, 16: hamowanie awaryjne*/ - double SystemTimer; - double SystemSoundCATimer; - double SystemSoundSHPTimer; - double SystemBrakeCATimer; - double SystemBrakeSHPTimer; - double SystemBrakeCATestTimer; // hunter-091012 - int VelocityAllowed; - int NextVelocityAllowed; /*predkosc pokazywana przez sygnalizacje kabinowa*/ - bool RadioStop; // czy jest RadioStop + int SystemType; /*0: brak, 1: czuwak aktywny, 2: SHP/sygnalizacja kabinowa*/ + double AwareDelay; // czas powtarzania czuwaka + double AwareMinSpeed; // minimalna prędkość załączenia czuwaka, normalnie 10% Vmax + double SoundSignalDelay; + double EmergencyBrakeDelay; + int Status; /*0: wylaczony, 1: wlaczony, 2: czuwak, 4: shp, 8: alarm, 16: hamowanie awaryjne*/ + double SystemTimer; + double SystemSoundCATimer; + double SystemSoundSHPTimer; + double SystemBrakeCATimer; + double SystemBrakeSHPTimer; + double SystemBrakeCATestTimer; // hunter-091012 + int VelocityAllowed; + int NextVelocityAllowed; /*predkosc pokazywana przez sygnalizacje kabinowa*/ + bool RadioStop; // czy jest RadioStop }; struct TTransmision -{//liczba zebow przekladni - int NToothM; - int NToothW; - double Ratio; - TTransmision() { +{ // liczba zebow przekladni + int NToothM; + int NToothW; + double Ratio; + TTransmision() + { NToothM, NToothW = 0; Ratio = 1.0; } }; -enum TCouplerType { NoCoupler, Articulated, Bare, Chain, Screw, Automatic }; +enum TCouplerType +{ + NoCoupler, + Articulated, + Bare, + Chain, + Screw, + Automatic +}; - -class TMoverParameters; // wyforwardowanie klasy coby typ byl widoczny w ponizszej strukturze -struct TCoupling { - /*parametry*/ - double SpringKB; double SpringKC; double beta; /*stala sprezystosci zderzaka/sprzegu, %tlumiennosci */ - double DmaxB; double FmaxB; double DmaxC; double FmaxC; /*tolerancja scisku/rozciagania, sila rozerwania*/ - TCouplerType CouplerType; /*typ sprzegu*/ - /*zmienne*/ - int CouplingFlag; /*0 - wirtualnie, 1 - sprzegi, 2 - pneumatycznie, 4 - sterowanie, 8 - kabel mocy*/ - int AllowedFlag; //Ra: znaczenie jak wyżej, maska dostępnych - bool Render; /*ABu: czy rysowac jak zaczepiony sprzeg*/ - double CoupleDist; /*ABu: optymalizacja - liczenie odleglosci raz na klatkę, bez iteracji*/ - TMoverParameters* Connected; /*co jest podlaczone*/ - int ConnectedNr; //Ra: od której strony podłączony do (Connected): 0=przód, 1=tył - double CForce; /*sila z jaka dzialal*/ - double Dist; /*strzalka ugiecia zderzaków*/ - bool CheckCollision; /*czy sprawdzac sile czy pedy*/ +class TMoverParameters; // wyforwardowanie klasy coby typ byl widoczny w ponizszej strukturze +struct TCoupling +{ + /*parametry*/ + double SpringKB; + double SpringKC; + double beta; /*stala sprezystosci zderzaka/sprzegu, %tlumiennosci */ + double DmaxB; + double FmaxB; + double DmaxC; + double FmaxC; /*tolerancja scisku/rozciagania, sila rozerwania*/ + TCouplerType CouplerType; /*typ sprzegu*/ + /*zmienne*/ + int CouplingFlag; /*0 - wirtualnie, 1 - sprzegi, 2 - pneumatycznie, 4 - sterowanie, 8 - kabel + mocy*/ + int AllowedFlag; // Ra: znaczenie jak wyżej, maska dostępnych + bool Render; /*ABu: czy rysowac jak zaczepiony sprzeg*/ + double CoupleDist; /*ABu: optymalizacja - liczenie odleglosci raz na klatkę, bez iteracji*/ + TMoverParameters *Connected; /*co jest podlaczone*/ + int ConnectedNr; // Ra: od której strony podłączony do (Connected): 0=przód, 1=tył + double CForce; /*sila z jaka dzialal*/ + double Dist; /*strzalka ugiecia zderzaków*/ + bool CheckCollision; /*czy sprawdzac sile czy pedy*/ }; class TMoverParameters -{ // Ra: wrapper na kod pascalowy, przejmujący jego funkcje Q: 20160824 - juz nie wrapper a klasa bazowa :) -public: +{ // Ra: wrapper na kod pascalowy, przejmujący jego funkcje Q: 20160824 - juz nie wrapper a klasa + // bazowa :) + public: + double dMoveLen; + std::string filename; + /*---opis lokomotywy, wagonu itp*/ + /*--opis serii--*/ + int CategoryFlag; /*1 - pociag, 2 - samochod, 4 - statek, 8 - samolot*/ + /*--sekcja stalych typowych parametrow*/ + std::string TypeName; /*nazwa serii/typu*/ + // TrainType: string; {typ: EZT/elektrowoz - Winger 040304} + int TrainType; /*Ra: powinno być szybciej niż string*/ + TEngineTypes EngineType; /*typ napedu*/ + TPowerParameters EnginePowerSource; /*zrodlo mocy dla silnikow*/ + TPowerParameters + SystemPowerSource; /*zrodlo mocy dla systemow sterowania/przetwornic/sprezarek*/ + TPowerParameters HeatingPowerSource; /*zrodlo mocy dla ogrzewania*/ + TPowerParameters AlterHeatPowerSource; /*alternatywne zrodlo mocy dla ogrzewania*/ + TPowerParameters LightPowerSource; /*zrodlo mocy dla oswietlenia*/ + TPowerParameters AlterLightPowerSource; /*alternatywne mocy dla oswietlenia*/ + double Vmax; + double Mass; + double Power; /*max. predkosc kontrukcyjna, masa wlasna, moc*/ + double Mred; /*Ra: zredukowane masy wirujące; potrzebne do obliczeń hamowania*/ + double TotalMass; /*wyliczane przez ComputeMass*/ + double HeatingPower; + double LightPower; /*moc pobierana na ogrzewanie/oswietlenie*/ + double BatteryVoltage; /*Winger - baterie w elektrykach*/ + bool Battery; /*Czy sa zalavzone baterie*/ + bool EpFuse; /*Czy sa zalavzone baterie*/ + bool Signalling; /*Czy jest zalaczona sygnalizacja hamowania ostatniego wagonu*/ + bool DoorSignalling; /*Czy jest zalaczona sygnalizacja blokady drzwi*/ + bool Radio; /*Czy jest zalaczony radiotelefon*/ + double NominalBatteryVoltage; /*Winger - baterie w elektrykach*/ + TDimension Dim; /*wymiary*/ + double Cx; /*wsp. op. aerodyn.*/ + double Floor; // poziom podłogi dla ładunków + double WheelDiameter; /*srednica kol napednych*/ + double WheelDiameterL; // Ra: srednica kol tocznych przednich + double WheelDiameterT; // Ra: srednica kol tocznych tylnych + double TrackW; /*nominalna szerokosc toru [m]*/ + double AxleInertialMoment; /*moment bezwladnosci zestawu kolowego*/ + std::string AxleArangement; /*uklad osi np. Bo'Bo' albo 1'C*/ + int NPoweredAxles; /*ilosc osi napednych liczona z powyzszego*/ + int NAxles; /*ilosc wszystkich osi j.w.*/ + int BearingType; /*lozyska: 0 - slizgowe, 1 - toczne*/ + double ADist; + double BDist; /*odlegosc osi oraz czopow skretu*/ + /*hamulce:*/ + int NBpA; /*ilosc el. ciernych na os: 0 1 2 lub 4*/ + int SandCapacity; /*zasobnik piasku [kg]*/ + TBrakeSystem BrakeSystem; /*rodzaj hamulca zespolonego*/ + TBrakeSubSystem BrakeSubsystem; + TBrakeValve BrakeValve; + TBrakeHandle BrakeHandle; + TBrakeHandle BrakeLocHandle; + double MBPM; /*masa najwiekszego cisnienia*/ - double dMoveLen; - std::string filename; - /*---opis lokomotywy, wagonu itp*/ - /*--opis serii--*/ - int CategoryFlag; /*1 - pociag, 2 - samochod, 4 - statek, 8 - samolot*/ - /*--sekcja stalych typowych parametrow*/ - std::string TypeName; /*nazwa serii/typu*/ - //TrainType: string; {typ: EZT/elektrowoz - Winger 040304} - int TrainType; /*Ra: powinno być szybciej niż string*/ - TEngineTypes EngineType; /*typ napedu*/ - TPowerParameters EnginePowerSource; /*zrodlo mocy dla silnikow*/ - TPowerParameters SystemPowerSource; /*zrodlo mocy dla systemow sterowania/przetwornic/sprezarek*/ - TPowerParameters HeatingPowerSource; /*zrodlo mocy dla ogrzewania*/ - TPowerParameters AlterHeatPowerSource; /*alternatywne zrodlo mocy dla ogrzewania*/ - TPowerParameters LightPowerSource; /*zrodlo mocy dla oswietlenia*/ - TPowerParameters AlterLightPowerSource;/*alternatywne mocy dla oswietlenia*/ - double Vmax; double Mass; double Power; /*max. predkosc kontrukcyjna, masa wlasna, moc*/ - double Mred; /*Ra: zredukowane masy wirujące; potrzebne do obliczeń hamowania*/ - double TotalMass; /*wyliczane przez ComputeMass*/ - double HeatingPower; double LightPower; /*moc pobierana na ogrzewanie/oswietlenie*/ - double BatteryVoltage; /*Winger - baterie w elektrykach*/ - bool Battery; /*Czy sa zalavzone baterie*/ - bool EpFuse; /*Czy sa zalavzone baterie*/ - bool Signalling; /*Czy jest zalaczona sygnalizacja hamowania ostatniego wagonu*/ - bool DoorSignalling; /*Czy jest zalaczona sygnalizacja blokady drzwi*/ - bool Radio; /*Czy jest zalaczony radiotelefon*/ - double NominalBatteryVoltage; /*Winger - baterie w elektrykach*/ - TDimension Dim; /*wymiary*/ - double Cx; /*wsp. op. aerodyn.*/ - double Floor; //poziom podłogi dla ładunków - double WheelDiameter; /*srednica kol napednych*/ - double WheelDiameterL; //Ra: srednica kol tocznych przednich - double WheelDiameterT; //Ra: srednica kol tocznych tylnych - double TrackW; /*nominalna szerokosc toru [m]*/ - double AxleInertialMoment; /*moment bezwladnosci zestawu kolowego*/ - std::string AxleArangement; /*uklad osi np. Bo'Bo' albo 1'C*/ - int NPoweredAxles; /*ilosc osi napednych liczona z powyzszego*/ - int NAxles; /*ilosc wszystkich osi j.w.*/ - int BearingType; /*lozyska: 0 - slizgowe, 1 - toczne*/ - double ADist; double BDist; /*odlegosc osi oraz czopow skretu*/ - /*hamulce:*/ - int NBpA; /*ilosc el. ciernych na os: 0 1 2 lub 4*/ - int SandCapacity; /*zasobnik piasku [kg]*/ - TBrakeSystem BrakeSystem;/*rodzaj hamulca zespolonego*/ - TBrakeSubSystem BrakeSubsystem; - TBrakeValve BrakeValve; - TBrakeHandle BrakeHandle; - TBrakeHandle BrakeLocHandle; - double MBPM; /*masa najwiekszego cisnienia*/ + TBrake *Hamulec; + TDriverHandle *Handle; + TDriverHandle *LocHandle; + TReservoir *Pipe; + TReservoir *Pipe2; - TBrake *Hamulec; - TDriverHandle *Handle; - TDriverHandle *LocHandle; - TReservoir *Pipe; TReservoir *Pipe2; + TLocalBrake LocalBrake; /*rodzaj hamulca indywidualnego*/ + TBrakePressureTable BrakePressureTable; /*wyszczegolnienie cisnien w rurze*/ + TBrakePressure BrakePressureActual; // wartości ważone dla aktualnej pozycji kranu + int ASBType; /*0: brak hamulca przeciwposlizgowego, 1: reczny, 2: automat*/ + int TurboTest; + double MaxBrakeForce; /*maksymalna sila nacisku hamulca*/ + double MaxBrakePress[5]; // pomocniczy, proz, sred, lad, pp + double P2FTrans; + double TrackBrakeForce; /*sila nacisku hamulca szynowego*/ + int BrakeMethod; /*flaga rodzaju hamulca*/ + /*max. cisnienie w cyl. ham., stala proporcjonalnosci p-K*/ + double HighPipePress; + double LowPipePress; + double DeltaPipePress; + /*max. i min. robocze cisnienie w przewodzie glownym oraz roznica miedzy nimi*/ + double CntrlPipePress; // ciśnienie z zbiorniku sterującym + double BrakeVolume; + double BrakeVVolume; + double VeselVolume; + /*pojemnosc powietrza w ukladzie hamulcowym, w ukladzie glownej sprezarki [m^3] */ + int BrakeCylNo; /*ilosc cylindrow ham.*/ + double BrakeCylRadius; + double BrakeCylDist; + double BrakeCylMult[3]; + int LoadFlag; + /*promien cylindra, skok cylindra, przekladnia hamulcowa*/ + double BrakeCylSpring; /*suma nacisku sprezyn powrotnych, kN*/ + double BrakeSlckAdj; /*opor nastawiacza skoku tloka, kN*/ + double BrakeRigEff; /*sprawnosc przekladni dzwigniowej*/ + double RapidMult; /*przelozenie rapidu*/ + int BrakeValveSize; + std::string BrakeValveParams; + double Spg; + double MinCompressor; + double MaxCompressor; + double CompressorSpeed; + /*cisnienie wlaczania, zalaczania sprezarki, wydajnosc sprezarki*/ + TBrakeDelayTable BrakeDelay; /*opoznienie hamowania/odhamowania t/o*/ + int BrakeCtrlPosNo; /*ilosc pozycji hamulca*/ + /*nastawniki:*/ + int MainCtrlPosNo; /*ilosc pozycji nastawnika*/ + int ScndCtrlPosNo; + int LightsPosNo; + int LightsDefPos; + bool LightsWrap; + int Lights[2][17]; // pozycje świateł, przód - tył, 1 .. 16 + bool ScndInMain; /*zaleznosc bocznika od nastawnika*/ + bool MBrake; /*Czy jest hamulec reczny*/ + double StopBrakeDecc; + TSecuritySystem SecuritySystem; - TLocalBrake LocalBrake; /*rodzaj hamulca indywidualnego*/ - TBrakePressureTable BrakePressureTable; /*wyszczegolnienie cisnien w rurze*/ - TBrakePressure BrakePressureActual; //wartości ważone dla aktualnej pozycji kranu - int ASBType; /*0: brak hamulca przeciwposlizgowego, 1: reczny, 2: automat*/ - int TurboTest; - double MaxBrakeForce; /*maksymalna sila nacisku hamulca*/ - double MaxBrakePress[5]; //pomocniczy, proz, sred, lad, pp - double P2FTrans; - double TrackBrakeForce; /*sila nacisku hamulca szynowego*/ - int BrakeMethod; /*flaga rodzaju hamulca*/ - /*max. cisnienie w cyl. ham., stala proporcjonalnosci p-K*/ - double HighPipePress; double LowPipePress; double DeltaPipePress; - /*max. i min. robocze cisnienie w przewodzie glownym oraz roznica miedzy nimi*/ - double CntrlPipePress; //ciśnienie z zbiorniku sterującym - double BrakeVolume; double BrakeVVolume; double VeselVolume; - /*pojemnosc powietrza w ukladzie hamulcowym, w ukladzie glownej sprezarki [m^3] */ - int BrakeCylNo; /*ilosc cylindrow ham.*/ - double BrakeCylRadius; double BrakeCylDist; - double BrakeCylMult[3]; - int LoadFlag; - /*promien cylindra, skok cylindra, przekladnia hamulcowa*/ - double BrakeCylSpring; /*suma nacisku sprezyn powrotnych, kN*/ - double BrakeSlckAdj; /*opor nastawiacza skoku tloka, kN*/ - double BrakeRigEff; /*sprawnosc przekladni dzwigniowej*/ - double RapidMult; /*przelozenie rapidu*/ - int BrakeValveSize; - std::string BrakeValveParams; - double Spg; - double MinCompressor; double MaxCompressor; double CompressorSpeed; - /*cisnienie wlaczania, zalaczania sprezarki, wydajnosc sprezarki*/ - TBrakeDelayTable BrakeDelay; /*opoznienie hamowania/odhamowania t/o*/ - int BrakeCtrlPosNo; /*ilosc pozycji hamulca*/ - /*nastawniki:*/ - int MainCtrlPosNo; /*ilosc pozycji nastawnika*/ - int ScndCtrlPosNo; - int LightsPosNo; int LightsDefPos; - bool LightsWrap; - int Lights[2][17]; // pozycje świateł, przód - tył, 1 .. 16 - bool ScndInMain; /*zaleznosc bocznika od nastawnika*/ - bool MBrake; /*Czy jest hamulec reczny*/ - double StopBrakeDecc; - TSecuritySystem SecuritySystem; + /*-sekcja parametrow dla lokomotywy elektrycznej*/ + TSchemeTable + RList; /*lista rezystorow rozruchowych i polaczen silnikow, dla dizla: napelnienia*/ + int RlistSize; + TMotorParameters MotorParam[MotorParametersArraySize + 1]; + /*rozne parametry silnika przy bocznikowaniach*/ + /*dla lokomotywy spalinowej z przekladnia mechaniczna: przelozenia biegow*/ + TTransmision Transmision; + // record {liczba zebow przekladni} + // NToothM, NToothW : byte; + // Ratio: real; {NToothW/NToothM} + // end; + double NominalVoltage; /*nominalne napiecie silnika*/ + double WindingRes; + double u; // wspolczynnik tarcia yB + // wywalic!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + double CircuitRes; /*rezystancje silnika i obwodu*/ + int IminLo; + int IminHi; /*prady przelacznika automatycznego rozruchu, uzywane tez przez ai_driver*/ + int ImaxLo; + int ImaxHi; /*maksymalny prad niskiego i wysokiego rozruchu*/ + double nmax; /*maksymalna dop. ilosc obrotow /s*/ + double InitialCtrlDelay; + double CtrlDelay; /* -//- -//- miedzy kolejnymi poz.*/ + double CtrlDownDelay; /* -//- -//- przy schodzeniu z poz.*/ /*hunter-101012*/ + int FastSerialCircuit; + /*0 - po kolei zamyka styczniki az do osiagniecia szeregowej, 1 - natychmiastowe wejscie na szeregowa*/ /*hunter-111012*/ + int AutoRelayType; /*0 -brak, 1 - jest, 2 - opcja*/ + bool CoupledCtrl; /*czy mainctrl i scndctrl sa sprzezone*/ + // CouplerNr: TCouplerNr; {ABu: nr sprzegu podlaczonego w drugim obiekcie} + bool IsCoupled; /*czy jest sprzezony ale jedzie z tylu*/ + int DynamicBrakeType; /*patrz dbrake_**/ + int RVentType; /*0 - brak, 1 - jest, 2 - automatycznie wlaczany*/ + double RVentnmax; /*maks. obroty wentylatorow oporow rozruchowych*/ + double RVentCutOff; /*rezystancja wylaczania wentylatorow dla RVentType=2*/ + int CompressorPower; /*0: bezp. z obwodow silnika, 1: z przetwornicy, reczne, 2: w przetwornicy, + stale, 5: z silnikowego*/ + int SmallCompressorPower; /*Winger ZROBIC*/ + bool Trafo; /*pojazd wyposażony w transformator*/ - /*-sekcja parametrow dla lokomotywy elektrycznej*/ - TSchemeTable RList; /*lista rezystorow rozruchowych i polaczen silnikow, dla dizla: napelnienia*/ - int RlistSize; - TMotorParameters MotorParam[MotorParametersArraySize + 1]; - /*rozne parametry silnika przy bocznikowaniach*/ - /*dla lokomotywy spalinowej z przekladnia mechaniczna: przelozenia biegow*/ - TTransmision Transmision; - // record {liczba zebow przekladni} - // NToothM, NToothW : byte; - // Ratio: real; {NToothW/NToothM} - // end; - double NominalVoltage; /*nominalne napiecie silnika*/ - double WindingRes; - double u; //wspolczynnik tarcia yB wywalic!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! - double CircuitRes; /*rezystancje silnika i obwodu*/ - int IminLo; int IminHi; /*prady przelacznika automatycznego rozruchu, uzywane tez przez ai_driver*/ - int ImaxLo; int ImaxHi; /*maksymalny prad niskiego i wysokiego rozruchu*/ - double nmax; /*maksymalna dop. ilosc obrotow /s*/ - double InitialCtrlDelay; double CtrlDelay; /* -//- -//- miedzy kolejnymi poz.*/ - double CtrlDownDelay; /* -//- -//- przy schodzeniu z poz.*/ /*hunter-101012*/ - int FastSerialCircuit;/*0 - po kolei zamyka styczniki az do osiagniecia szeregowej, 1 - natychmiastowe wejscie na szeregowa*/ /*hunter-111012*/ - int AutoRelayType; /*0 -brak, 1 - jest, 2 - opcja*/ - bool CoupledCtrl; /*czy mainctrl i scndctrl sa sprzezone*/ - //CouplerNr: TCouplerNr; {ABu: nr sprzegu podlaczonego w drugim obiekcie} - bool IsCoupled; /*czy jest sprzezony ale jedzie z tylu*/ - int DynamicBrakeType; /*patrz dbrake_**/ - int RVentType; /*0 - brak, 1 - jest, 2 - automatycznie wlaczany*/ - double RVentnmax; /*maks. obroty wentylatorow oporow rozruchowych*/ - double RVentCutOff; /*rezystancja wylaczania wentylatorow dla RVentType=2*/ - int CompressorPower; /*0: bezp. z obwodow silnika, 1: z przetwornicy, reczne, 2: w przetwornicy, stale, 5: z silnikowego*/ - int SmallCompressorPower; /*Winger ZROBIC*/ - bool Trafo; /*pojazd wyposażony w transformator*/ + /*-sekcja parametrow dla lokomotywy spalinowej z przekladnia mechaniczna*/ + double dizel_Mmax; + double dizel_nMmax; + double dizel_Mnmax; + double dizel_nmax; + double dizel_nominalfill; + /*parametry aproksymacji silnika spalinowego*/ + double dizel_Mstand; /*moment oporow ruchu silnika dla enrot=0*/ + /* dizel_auto_min, dizel_auto_max: real; {predkosc obrotowa przelaczania + * automatycznej skrzyni biegow*/ + double dizel_nmax_cutoff; /*predkosc obrotowa zadzialania ogranicznika predkosci*/ + double dizel_nmin; /*najmniejsza dopuszczalna predkosc obrotowa*/ + double dizel_minVelfullengage; /*najmniejsza predkosc przy jezdzie ze sprzeglem bez poslizgu*/ + double dizel_AIM; /*moment bezwladnosci walu itp*/ + double dizel_engageDia; + double dizel_engageMaxForce; + double dizel_engagefriction; /*parametry sprzegla*/ - /*-sekcja parametrow dla lokomotywy spalinowej z przekladnia mechaniczna*/ - double dizel_Mmax; double dizel_nMmax; double dizel_Mnmax; double dizel_nmax; double dizel_nominalfill; - /*parametry aproksymacji silnika spalinowego*/ - double dizel_Mstand; /*moment oporow ruchu silnika dla enrot=0*/ - /* dizel_auto_min, dizel_auto_max: real; {predkosc obrotowa przelaczania automatycznej skrzyni biegow*/ - double dizel_nmax_cutoff; /*predkosc obrotowa zadzialania ogranicznika predkosci*/ - double dizel_nmin; /*najmniejsza dopuszczalna predkosc obrotowa*/ - double dizel_minVelfullengage; /*najmniejsza predkosc przy jezdzie ze sprzeglem bez poslizgu*/ - double dizel_AIM; /*moment bezwladnosci walu itp*/ - double dizel_engageDia; double dizel_engageMaxForce; double dizel_engagefriction; /*parametry sprzegla*/ + /*- dla lokomotyw spalinowo-elektrycznych -*/ + double AnPos; // pozycja sterowania dokladnego (analogowego) + bool AnalogCtrl; // + bool AnMainCtrl; // + bool ShuntModeAllow; + bool ShuntMode; - /*- dla lokomotyw spalinowo-elektrycznych -*/ - double AnPos; // pozycja sterowania dokladnego (analogowego) - bool AnalogCtrl; // - bool AnMainCtrl; // - bool ShuntModeAllow; - bool ShuntMode; + bool Flat; + double Vhyp; + TDESchemeTable DElist; + double Vadd; + TMPTRelayTable MPTRelay; + int RelayType; + TShuntSchemeTable SST; + double PowerCorRatio; // Wspolczynnik korekcyjny - bool Flat; - double Vhyp; - TDESchemeTable DElist; - double Vadd; - TMPTRelayTable MPTRelay; - int RelayType; - TShuntSchemeTable SST; - double PowerCorRatio; //Wspolczynnik korekcyjny + /*- dla uproszczonego modelu silnika (dumb) oraz dla drezyny*/ + double Ftmax; + /*- dla lokomotyw z silnikami indukcyjnymi -*/ + double eimc[26]; - /*- dla uproszczonego modelu silnika (dumb) oraz dla drezyny*/ - double Ftmax; + /*-dla wagonow*/ + long MaxLoad; /*masa w T lub ilosc w sztukach - ladownosc*/ + std::string LoadAccepted; + std::string LoadQuantity; /*co moze byc zaladowane, jednostki miary*/ + double OverLoadFactor; /*ile razy moze byc przekroczona ladownosc*/ + double LoadSpeed; + double UnLoadSpeed; /*szybkosc na- i rozladunku jednostki/s*/ + int DoorOpenCtrl; + int DoorCloseCtrl; /*0: przez pasazera, 1: przez maszyniste, 2: samoczynne (zamykanie)*/ + double DoorStayOpen; /*jak dlugo otwarte w przypadku DoorCloseCtrl=2*/ + bool DoorClosureWarning; /*czy jest ostrzeganie przed zamknieciem*/ + double DoorOpenSpeed; + double DoorCloseSpeed; /*predkosc otwierania i zamykania w j.u. */ + double DoorMaxShiftL; + double DoorMaxShiftR; + double DoorMaxPlugShift; /*szerokosc otwarcia lub kat*/ + int DoorOpenMethod; /*sposob otwarcia - 1: przesuwne, 2: obrotowe, 3: trójelementowe*/ + double PlatformSpeed; /*szybkosc stopnia*/ + double PlatformMaxShift; /*wysuniecie stopnia*/ + int PlatformOpenMethod; /*sposob animacji stopnia*/ + bool ScndS; /*Czy jest bocznikowanie na szeregowej*/ - /*- dla lokomotyw z silnikami indukcyjnymi -*/ - double eimc[26]; + /*--sekcja zmiennych*/ + /*--opis konkretnego egzemplarza taboru*/ + TLocation Loc; // pozycja pojazdów do wyznaczenia odległości pomiędzy sprzęgami + TRotation Rot; + std::string Name; /*nazwa wlasna*/ + TCoupling Couplers[2]; // urzadzenia zderzno-sprzegowe, polaczenia miedzy wagonami + double HVCouplers[2][2]; // przewod WN + int ScanCounter; /*pomocnicze do skanowania sprzegow*/ + bool EventFlag; /*!o true jesli cos nietypowego sie wydarzy*/ + int SoundFlag; /*!o patrz stale sound_ */ + double DistCounter; /*! licznik kilometrow */ + double V; // predkosc w [m/s] względem sprzęgów (dodania gdy jedzie w stronę 0) + double Vel; // moduł prędkości w [km/h], używany przez AI + double AccS; // efektywne przyspieszenie styczne w [m/s^2] (wszystkie siły) + double AccN; // przyspieszenie normalne w [m/s^2] + double AccV; + double nrot; + /*! rotacja kol [obr/s]*/ + double EnginePower; /*! chwilowa moc silnikow*/ + double dL; + double Fb; + double Ff; /*przesuniecie, sila hamowania i tarcia*/ + double FTrain; + double FStand; /*! sila pociagowa i oporow ruchu*/ + double FTotal; /*! calkowita sila dzialajaca na pojazd*/ + double UnitBrakeForce; /*!s siła hamowania przypadająca na jeden element*/ + double Ntotal; /*!s siła nacisku klockow*/ + bool SlippingWheels; + bool SandDose; /*! poslizg kol, sypanie piasku*/ + double Sand; /*ilosc piasku*/ + double BrakeSlippingTimer; /*pomocnicza zmienna do wylaczania przeciwposlizgu*/ + double dpBrake; + double dpPipe; + double dpMainValve; + double dpLocalValve; + /*! przyrosty cisnienia w kroku czasowym*/ + double ScndPipePress; /*cisnienie w przewodzie zasilajacym*/ + double BrakePress; /*!o cisnienie w cylindrach hamulcowych*/ + double LocBrakePress; /*!o cisnienie w cylindrach hamulcowych z pomocniczego*/ + double PipeBrakePress; /*!o cisnienie w cylindrach hamulcowych z przewodu*/ + double PipePress; /*!o cisnienie w przewodzie glownym*/ + double EqvtPipePress; /*!o cisnienie w przewodzie glownym skladu*/ + double Volume; /*objetosc spr. powietrza w zbiorniku hamulca*/ + double CompressedVolume; /*objetosc spr. powietrza w ukl. zasilania*/ + double PantVolume; /*objetosc spr. powietrza w ukl. pantografu*/ + double Compressor; /*! cisnienie w ukladzie zasilajacym*/ + bool CompressorFlag; /*!o czy wlaczona sprezarka*/ + bool PantCompFlag; /*!o czy wlaczona sprezarka pantografow*/ + bool CompressorAllow; /*! zezwolenie na uruchomienie sprezarki NBMX*/ + bool ConverterFlag; /*! czy wlaczona przetwornica NBMX*/ + bool ConverterAllow; /*zezwolenie na prace przetwornicy NBMX*/ + int BrakeCtrlPos; /*nastawa hamulca zespolonego*/ + double BrakeCtrlPosR; /*nastawa hamulca zespolonego - plynna dla FV4a*/ + double BrakeCtrlPos2; /*nastawa hamulca zespolonego - kapturek dla FV4a*/ + int LocalBrakePos; /*nastawa hamulca indywidualnego*/ + int ManualBrakePos; /*nastawa hamulca recznego*/ + double LocalBrakePosA; + int BrakeStatus; /*0 - odham, 1 - ham., 2 - uszk., 4 - odluzniacz, 8 - antyposlizg, 16 - uzyte + EP, 32 - pozycja R, 64 - powrot z R*/ + bool EmergencyBrakeFlag; /*hamowanie nagle*/ + int BrakeDelayFlag; /*nastawa opoznienia ham. osob/towar/posp/exp 0/1/2/4*/ + int BrakeDelays; /*nastawy mozliwe do uzyskania*/ + int BrakeOpModeFlag; /*nastawa trybu pracy PS/PN/EP/MED 1/2/4/8*/ + int BrakeOpModes; /*nastawy mozliwe do uzyskania*/ + bool DynamicBrakeFlag; /*czy wlaczony hamulec elektrodymiczny*/ + // NapUdWsp: integer; + double LimPipePress; /*stabilizator cisnienia*/ + double ActFlowSpeed; /*szybkosc stabilizatora*/ - /*-dla wagonow*/ - long MaxLoad; /*masa w T lub ilosc w sztukach - ladownosc*/ - std::string LoadAccepted; std::string LoadQuantity; /*co moze byc zaladowane, jednostki miary*/ - double OverLoadFactor; /*ile razy moze byc przekroczona ladownosc*/ - double LoadSpeed; double UnLoadSpeed;/*szybkosc na- i rozladunku jednostki/s*/ - int DoorOpenCtrl; int DoorCloseCtrl; /*0: przez pasazera, 1: przez maszyniste, 2: samoczynne (zamykanie)*/ - double DoorStayOpen; /*jak dlugo otwarte w przypadku DoorCloseCtrl=2*/ - bool DoorClosureWarning; /*czy jest ostrzeganie przed zamknieciem*/ - double DoorOpenSpeed; double DoorCloseSpeed; /*predkosc otwierania i zamykania w j.u. */ - double DoorMaxShiftL; double DoorMaxShiftR; double DoorMaxPlugShift;/*szerokosc otwarcia lub kat*/ - int DoorOpenMethod; /*sposob otwarcia - 1: przesuwne, 2: obrotowe, 3: trójelementowe*/ - double PlatformSpeed; /*szybkosc stopnia*/ - double PlatformMaxShift; /*wysuniecie stopnia*/ - int PlatformOpenMethod; /*sposob animacji stopnia*/ - bool ScndS; /*Czy jest bocznikowanie na szeregowej*/ + int DamageFlag; // kombinacja bitowa stalych dtrain_* } + int EngDmgFlag; // kombinacja bitowa stalych usterek} + int DerailReason; // przyczyna wykolejenia - /*--sekcja zmiennych*/ - /*--opis konkretnego egzemplarza taboru*/ - TLocation Loc; //pozycja pojazdów do wyznaczenia odległości pomiędzy sprzęgami - TRotation Rot; - std::string Name; /*nazwa wlasna*/ - TCoupling Couplers[2]; //urzadzenia zderzno-sprzegowe, polaczenia miedzy wagonami - double HVCouplers[2][2]; //przewod WN - int ScanCounter; /*pomocnicze do skanowania sprzegow*/ - bool EventFlag; /*!o true jesli cos nietypowego sie wydarzy*/ - int SoundFlag; /*!o patrz stale sound_ */ - double DistCounter; /*! licznik kilometrow */ - double V; //predkosc w [m/s] względem sprzęgów (dodania gdy jedzie w stronę 0) - double Vel; //moduł prędkości w [km/h], używany przez AI - double AccS; //efektywne przyspieszenie styczne w [m/s^2] (wszystkie siły) - double AccN; //przyspieszenie normalne w [m/s^2] - double AccV; - double nrot; - /*! rotacja kol [obr/s]*/ - double EnginePower; /*! chwilowa moc silnikow*/ - double dL; double Fb; double Ff; /*przesuniecie, sila hamowania i tarcia*/ - double FTrain; double FStand; /*! sila pociagowa i oporow ruchu*/ - double FTotal; /*! calkowita sila dzialajaca na pojazd*/ - double UnitBrakeForce; /*!s siła hamowania przypadająca na jeden element*/ - double Ntotal; /*!s siła nacisku klockow*/ - bool SlippingWheels; bool SandDose; /*! poslizg kol, sypanie piasku*/ - double Sand; /*ilosc piasku*/ - double BrakeSlippingTimer; /*pomocnicza zmienna do wylaczania przeciwposlizgu*/ - double dpBrake; double dpPipe; double dpMainValve; double dpLocalValve; - /*! przyrosty cisnienia w kroku czasowym*/ - double ScndPipePress; /*cisnienie w przewodzie zasilajacym*/ - double BrakePress; /*!o cisnienie w cylindrach hamulcowych*/ - double LocBrakePress; /*!o cisnienie w cylindrach hamulcowych z pomocniczego*/ - double PipeBrakePress; /*!o cisnienie w cylindrach hamulcowych z przewodu*/ - double PipePress; /*!o cisnienie w przewodzie glownym*/ - double EqvtPipePress; /*!o cisnienie w przewodzie glownym skladu*/ - double Volume; /*objetosc spr. powietrza w zbiorniku hamulca*/ - double CompressedVolume; /*objetosc spr. powietrza w ukl. zasilania*/ - double PantVolume; /*objetosc spr. powietrza w ukl. pantografu*/ - double Compressor; /*! cisnienie w ukladzie zasilajacym*/ - bool CompressorFlag; /*!o czy wlaczona sprezarka*/ - bool PantCompFlag; /*!o czy wlaczona sprezarka pantografow*/ - bool CompressorAllow; /*! zezwolenie na uruchomienie sprezarki NBMX*/ - bool ConverterFlag; /*! czy wlaczona przetwornica NBMX*/ - bool ConverterAllow; /*zezwolenie na prace przetwornicy NBMX*/ - int BrakeCtrlPos; /*nastawa hamulca zespolonego*/ - double BrakeCtrlPosR; /*nastawa hamulca zespolonego - plynna dla FV4a*/ - double BrakeCtrlPos2; /*nastawa hamulca zespolonego - kapturek dla FV4a*/ - int LocalBrakePos; /*nastawa hamulca indywidualnego*/ - int ManualBrakePos; /*nastawa hamulca recznego*/ - double LocalBrakePosA; - int BrakeStatus; /*0 - odham, 1 - ham., 2 - uszk., 4 - odluzniacz, 8 - antyposlizg, 16 - uzyte EP, 32 - pozycja R, 64 - powrot z R*/ - bool EmergencyBrakeFlag; /*hamowanie nagle*/ - int BrakeDelayFlag; /*nastawa opoznienia ham. osob/towar/posp/exp 0/1/2/4*/ - int BrakeDelays; /*nastawy mozliwe do uzyskania*/ - int BrakeOpModeFlag; /*nastawa trybu pracy PS/PN/EP/MED 1/2/4/8*/ - int BrakeOpModes; /*nastawy mozliwe do uzyskania*/ - bool DynamicBrakeFlag; /*czy wlaczony hamulec elektrodymiczny*/ - // NapUdWsp: integer; - double LimPipePress; /*stabilizator cisnienia*/ - double ActFlowSpeed; /*szybkosc stabilizatora*/ + // EndSignalsFlag: byte; {ABu 060205: zmiany - koncowki: 1/16 - swiatla prz/tyl, 2/31 - blachy + // prz/tyl} + // HeadSignalsFlag: byte; {ABu 060205: zmiany - swiatla: 1/2/4 - przod, 16/32/63 - tyl} + TCommand CommandIn; + /*komenda przekazywana przez PutCommand*/ + /*i wykonywana przez RunInternalCommand*/ + std::string CommandOut; /*komenda przekazywana przez ExternalCommand*/ + std::string CommandLast; // Ra: ostatnio wykonana komenda do podglądu + double ValueOut; /*argument komendy która ma byc przekazana na zewnatrz*/ + TTrackShape RunningShape; /*geometria toru po ktorym jedzie pojazd*/ + TTrackParam RunningTrack; /*parametry toru po ktorym jedzie pojazd*/ + double OffsetTrackH; + double OffsetTrackV; /*przesuniecie poz. i pion. w/m osi toru*/ - int DamageFlag; //kombinacja bitowa stalych dtrain_* } - int EngDmgFlag; //kombinacja bitowa stalych usterek} - int DerailReason; //przyczyna wykolejenia + /*-zmienne dla lokomotyw*/ + bool Mains; /*polozenie glownego wylacznika*/ + int MainCtrlPos; /*polozenie glownego nastawnika*/ + int ScndCtrlPos; /*polozenie dodatkowego nastawnika*/ + int LightsPos; + int ActiveDir; // czy lok. jest wlaczona i w ktorym kierunku: + // względem wybranej kabiny: -1 - do tylu, +1 - do przodu, 0 - wylaczona + int CabNo; // numer kabiny, z której jest sterowanie: 1 lub -1; w przeciwnym razie brak + // sterowania - rozrzad + int DirAbsolute; // zadany kierunek jazdy względem sprzęgów (1=w strone 0,-1=w stronę 1) + int ActiveCab; // numer kabiny, w ktorej jest obsada (zwykle jedna na skład) + double LastSwitchingTime; /*czas ostatniego przelaczania czegos*/ + // WarningSignal: byte; {0: nie trabi, 1,2: trabi} + bool DepartureSignal; /*sygnal odjazdu*/ + bool InsideConsist; + /*-zmienne dla lokomotywy elektrycznej*/ + TTractionParam RunningTraction; /*parametry sieci trakcyjnej najblizej lokomotywy*/ + double enrot; + double Im; + double Itot; + double IHeating; + double ITraction; + double TotalCurrent; + double Mm; + double Mw; + double Fw; + double Ft; + /*ilosc obrotow, prad silnika i calkowity, momenty, sily napedne*/ + // Ra: Im jest ujemny, jeśli lok jedzie w stronę sprzęgu 1 + // a ujemne powinien być przy odwróconej polaryzacji sieci... + // w wielu miejscach jest używane abs(Im) + int Imin; + int Imax; /*prad przelaczania automatycznego rozruchu, prad bezpiecznika*/ + double Voltage; /*aktualne napiecie sieci zasilajacej*/ + int MainCtrlActualPos; /*wskaznik RList*/ + int ScndCtrlActualPos; /*wskaznik MotorParam*/ + bool DelayCtrlFlag; // czy czekanie na 1. pozycji na załączenie? + double LastRelayTime; /*czas ostatniego przelaczania stycznikow*/ + bool AutoRelayFlag; /*mozna zmieniac jesli AutoRelayType=2*/ + bool FuseFlag; /*!o bezpiecznik nadmiarowy*/ + bool ConvOvldFlag; /*! nadmiarowy przetwornicy i ogrzewania*/ + bool StLinFlag; /*!o styczniki liniowe*/ + bool ResistorsFlag; /*!o jazda rezystorowa*/ + double RventRot; /*!s obroty wentylatorow rozruchowych*/ + bool UnBrake; /*w EZT - nacisniete odhamowywanie*/ + double PantPress; /*Cisnienie w zbiornikach pantografow*/ + bool s_CAtestebrake; // hunter-091012: zmienna dla testu ca - //EndSignalsFlag: byte; {ABu 060205: zmiany - koncowki: 1/16 - swiatla prz/tyl, 2/31 - blachy prz/tyl} - //HeadSignalsFlag: byte; {ABu 060205: zmiany - swiatla: 1/2/4 - przod, 16/32/63 - tyl} - TCommand CommandIn; - /*komenda przekazywana przez PutCommand*/ - /*i wykonywana przez RunInternalCommand*/ - std::string CommandOut; /*komenda przekazywana przez ExternalCommand*/ - std::string CommandLast; //Ra: ostatnio wykonana komenda do podglądu - double ValueOut; /*argument komendy która ma byc przekazana na zewnatrz*/ + /*-zmienne dla lokomotywy spalinowej z przekladnia mechaniczna*/ + double dizel_fill; /*napelnienie*/ + double dizel_engagestate; /*sprzeglo skrzyni biegow: 0 - luz, 1 - wlaczone, 0.5 - wlaczone 50% + (z poslizgiem)*/ + double dizel_engage; /*sprzeglo skrzyni biegow: aktualny docisk*/ + double dizel_automaticgearstatus; /*0 - bez zmiany, -1 zmiana na nizszy +1 zmiana na wyzszy*/ + bool dizel_enginestart; /*czy trwa rozruch silnika*/ + double dizel_engagedeltaomega; /*roznica predkosci katowych tarcz sprzegla*/ - TTrackShape RunningShape;/*geometria toru po ktorym jedzie pojazd*/ - TTrackParam RunningTrack;/*parametry toru po ktorym jedzie pojazd*/ - double OffsetTrackH; double OffsetTrackV; /*przesuniecie poz. i pion. w/m osi toru*/ + /*- zmienne dla lokomotyw z silnikami indukcyjnymi -*/ + double eimv[21]; - /*-zmienne dla lokomotyw*/ - bool Mains; /*polozenie glownego wylacznika*/ - int MainCtrlPos; /*polozenie glownego nastawnika*/ - int ScndCtrlPos; /*polozenie dodatkowego nastawnika*/ - int LightsPos; - int ActiveDir; //czy lok. jest wlaczona i w ktorym kierunku: - //względem wybranej kabiny: -1 - do tylu, +1 - do przodu, 0 - wylaczona - int CabNo; //numer kabiny, z której jest sterowanie: 1 lub -1; w przeciwnym razie brak sterowania - rozrzad - int DirAbsolute; //zadany kierunek jazdy względem sprzęgów (1=w strone 0,-1=w stronę 1) - int ActiveCab; //numer kabiny, w ktorej jest obsada (zwykle jedna na skład) - double LastSwitchingTime; /*czas ostatniego przelaczania czegos*/ - //WarningSignal: byte; {0: nie trabi, 1,2: trabi} - bool DepartureSignal; /*sygnal odjazdu*/ - bool InsideConsist; - /*-zmienne dla lokomotywy elektrycznej*/ - TTractionParam RunningTraction;/*parametry sieci trakcyjnej najblizej lokomotywy*/ - double enrot; double Im; double Itot; double IHeating; double ITraction; double TotalCurrent; double Mm; double Mw; double Fw; double Ft; - /*ilosc obrotow, prad silnika i calkowity, momenty, sily napedne*/ - //Ra: Im jest ujemny, jeśli lok jedzie w stronę sprzęgu 1 - //a ujemne powinien być przy odwróconej polaryzacji sieci... - //w wielu miejscach jest używane abs(Im) - int Imin; int Imax; /*prad przelaczania automatycznego rozruchu, prad bezpiecznika*/ - double Voltage; /*aktualne napiecie sieci zasilajacej*/ - int MainCtrlActualPos; /*wskaznik RList*/ - int ScndCtrlActualPos; /*wskaznik MotorParam*/ - bool DelayCtrlFlag; //czy czekanie na 1. pozycji na załączenie? - double LastRelayTime; /*czas ostatniego przelaczania stycznikow*/ - bool AutoRelayFlag; /*mozna zmieniac jesli AutoRelayType=2*/ - bool FuseFlag; /*!o bezpiecznik nadmiarowy*/ - bool ConvOvldFlag; /*! nadmiarowy przetwornicy i ogrzewania*/ - bool StLinFlag; /*!o styczniki liniowe*/ - bool ResistorsFlag; /*!o jazda rezystorowa*/ - double RventRot; /*!s obroty wentylatorow rozruchowych*/ - bool UnBrake; /*w EZT - nacisniete odhamowywanie*/ - double PantPress; /*Cisnienie w zbiornikach pantografow*/ - bool s_CAtestebrake; //hunter-091012: zmienna dla testu ca + /*-zmienne dla drezyny*/ + double PulseForce; /*przylozona sila*/ + double PulseForceTimer; + int PulseForceCount; + /*dla drezyny, silnika spalinowego i parowego*/ + double eAngle; - /*-zmienne dla lokomotywy spalinowej z przekladnia mechaniczna*/ - double dizel_fill; /*napelnienie*/ - double dizel_engagestate; /*sprzeglo skrzyni biegow: 0 - luz, 1 - wlaczone, 0.5 - wlaczone 50% (z poslizgiem)*/ - double dizel_engage; /*sprzeglo skrzyni biegow: aktualny docisk*/ - double dizel_automaticgearstatus; /*0 - bez zmiany, -1 zmiana na nizszy +1 zmiana na wyzszy*/ - bool dizel_enginestart; /*czy trwa rozruch silnika*/ - double dizel_engagedeltaomega; /*roznica predkosci katowych tarcz sprzegla*/ + /*-dla wagonow*/ + long Load; /*masa w T lub ilosc w sztukach - zaladowane*/ + std::string LoadType; /*co jest zaladowane*/ + int LoadStatus; //+1=trwa rozladunek,+2=trwa zaladunek,+4=zakończono,0=zaktualizowany model + double LastLoadChangeTime; // raz (roz)ładowania - /*- zmienne dla lokomotyw z silnikami indukcyjnymi -*/ - double eimv[21]; + bool DoorBlocked; // Czy jest blokada drzwi + bool DoorLeftOpened; // stan drzwi + bool DoorRightOpened; + bool PantFrontUp; // stan patykow 'Winger 160204 + bool PantRearUp; + bool PantFrontSP; // dzwiek patykow 'Winger 010304 + bool PantRearSP; + int PantFrontStart; // stan patykow 'Winger 160204 + int PantRearStart; + double PantFrontVolt; // pantograf pod napieciem? 'Winger 160404 + double PantRearVolt; + std::string PantSwitchType; + std::string ConvSwitchType; - /*-zmienne dla drezyny*/ - double PulseForce; /*przylozona sila*/ - double PulseForceTimer; - int PulseForceCount; + bool Heating; // ogrzewanie 'Winger 020304 + int DoubleTr; // trakcja ukrotniona - przedni pojazd 'Winger 160304 - /*dla drezyny, silnika spalinowego i parowego*/ - double eAngle; + bool PhysicActivation; - /*-dla wagonow*/ - long Load; /*masa w T lub ilosc w sztukach - zaladowane*/ - std::string LoadType; /*co jest zaladowane*/ - int LoadStatus; //+1=trwa rozladunek,+2=trwa zaladunek,+4=zakończono,0=zaktualizowany model - double LastLoadChangeTime; //raz (roz)ładowania + /*ABu: stale dla wyznaczania sil (i nie tylko) po optymalizacji*/ + double FrictConst1; + double FrictConst2s; + double FrictConst2d; + double TotalMassxg; /*TotalMass*g*/ - bool DoorBlocked; //Czy jest blokada drzwi - bool DoorLeftOpened; //stan drzwi - bool DoorRightOpened; - bool PantFrontUp; //stan patykow 'Winger 160204 - bool PantRearUp; - bool PantFrontSP; //dzwiek patykow 'Winger 010304 - bool PantRearSP; - int PantFrontStart; //stan patykow 'Winger 160204 - int PantRearStart; - double PantFrontVolt; //pantograf pod napieciem? 'Winger 160404 - double PantRearVolt; - std::string PantSwitchType; - std::string ConvSwitchType; + vector3 vCoulpler[2]; // powtórzenie współrzędnych sprzęgów z DynObj :/ + vector3 DimHalf; // połowy rozmiarów do obliczeń geometrycznych + // int WarningSignal; //0: nie trabi, 1,2: trabi syreną o podanym numerze + int WarningSignal; // tymczasowo 8bit, ze względu na funkcje w MTools + double fBrakeCtrlPos; // płynna nastawa hamulca zespolonego + bool bPantKurek3; // kurek trójdrogowy (pantografu): true=połączenie z ZG, false=połączenie z + // małą sprężarką + int iProblem; // flagi problemów z taborem, aby AI nie musiało porównywać; 0=może jechać + int iLights[2]; // bity zapalonych świateł tutaj, żeby dało się liczyć pobór prądu + private: + double CouplerDist(int Coupler); - bool Heating; //ogrzewanie 'Winger 020304 - int DoubleTr; //trakcja ukrotniona - przedni pojazd 'Winger 160304 + public: + TMoverParameters(double VelInitial, std::string TypeNameInit, std::string NameInit, + int LoadInitial, std::string LoadTypeInitial, int Cab); + // obsługa sprzęgów + double Distance(const TLocation &Loc1, const TLocation &Loc2, const TDimension &Dim1, + const TDimension &Dim2); + double Distance(const vector3 &Loc1, const vector3 &Loc2, const vector3 &Dim1, + const vector3 &Dim2); + // bool AttachA(int ConnectNo, int ConnectToNr, TMoverParameters *ConnectTo, int CouplingType, + // bool Forced = false); + bool Attach(int ConnectNo, int ConnectToNr, TMoverParameters *ConnectTo, int CouplingType, + bool Forced = false); + int DettachStatus(int ConnectNo); + bool Dettach(int ConnectNo); + void SetCoupleDist(); + bool DirectionForward(); + void BrakeLevelSet(double b); + bool BrakeLevelAdd(double b); + bool IncBrakeLevel(); // wersja na użytek AI + bool DecBrakeLevel(); + bool ChangeCab(int direction); + bool CurrentSwitch(int direction); + void UpdateBatteryVoltage(double dt); + double ComputeMovement(double dt, double dt1, const TTrackShape &Shape, TTrackParam &Track, + TTractionParam &ElectricTraction, const TLocation &NewLoc, + TRotation &NewRot); // oblicza przesuniecie pojazdu + double + FastComputeMovement(double dt, const TTrackShape &Shape, TTrackParam &Track, + const TLocation &NewLoc, + TRotation &NewRot); // oblicza przesuniecie pojazdu - wersja zoptymalizowana + double ShowEngineRotation(int VehN); - bool PhysicActivation; + // Q ******************************************************************************************* + double GetTrainsetVoltage(void); + bool Physic_ReActivation(void); + double LocalBrakeRatio(void); + double ManualBrakeRatio(void); + double PipeRatio(void); /*ile napelniac*/ + double RealPipeRatio(void); /*jak szybko*/ + double BrakeVP(void); - /*ABu: stale dla wyznaczania sil (i nie tylko) po optymalizacji*/ - double FrictConst1; - double FrictConst2s; - double FrictConst2d; - double TotalMassxg; /*TotalMass*g*/ + /*! przesylanie komend sterujacych*/ + bool SendCtrlBroadcast(std::string CtrlCommand, double ctrlvalue); + bool SendCtrlToNext(std::string CtrlCommand, double ctrlvalue, double dir); + bool SetInternalCommand(std::string NewCommand, double NewValue1, double NewValue2); + double GetExternalCommand(std::string &Command); + bool RunCommand(std::string Command, double CValue1, double CValue2); + bool RunInternalCommand(void); + void PutCommand(std::string NewCommand, double NewValue1, double NewValue2, + const TLocation &NewLocation); + bool CabActivisation(void); + bool CabDeactivisation(void); - vector3 vCoulpler[2]; // powtórzenie współrzędnych sprzęgów z DynObj :/ - vector3 DimHalf; // połowy rozmiarów do obliczeń geometrycznych - // int WarningSignal; //0: nie trabi, 1,2: trabi syreną o podanym numerze - int WarningSignal; // tymczasowo 8bit, ze względu na funkcje w MTools - double fBrakeCtrlPos; // płynna nastawa hamulca zespolonego - bool bPantKurek3; // kurek trójdrogowy (pantografu): true=połączenie z ZG, false=połączenie z małą sprężarką - int iProblem; // flagi problemów z taborem, aby AI nie musiało porównywać; 0=może jechać - int iLights[2]; // bity zapalonych świateł tutaj, żeby dało się liczyć pobór prądu -private: - double CouplerDist(int Coupler); + /*! funkcje zwiekszajace/zmniejszajace nastawniki*/ + /*! glowny nastawnik:*/ + bool IncMainCtrl(int CtrlSpeed); + bool DecMainCtrl(int CtrlSpeed); + /*! pomocniczy nastawnik:*/ + bool IncScndCtrl(int CtrlSpeed); + bool DecScndCtrl(int CtrlSpeed); -public: - TMoverParameters(double VelInitial, std::string TypeNameInit, std::string NameInit, int LoadInitial, std::string LoadTypeInitial, int Cab); - // obsługa sprzęgów - double Distance(const TLocation &Loc1, const TLocation &Loc2, const TDimension &Dim1, const TDimension &Dim2); - double Distance(const vector3 &Loc1, const vector3 &Loc2, const vector3 &Dim1, const vector3 &Dim2); - //bool AttachA(int ConnectNo, int ConnectToNr, TMoverParameters *ConnectTo, int CouplingType, bool Forced = false); - bool Attach(int ConnectNo, int ConnectToNr, TMoverParameters *ConnectTo, int CouplingType, bool Forced = false); - int DettachStatus(int ConnectNo); - bool Dettach(int ConnectNo); - void SetCoupleDist(); - bool DirectionForward(); - void BrakeLevelSet(double b); - bool BrakeLevelAdd(double b); - bool IncBrakeLevel(); // wersja na użytek AI - bool DecBrakeLevel(); - bool ChangeCab(int direction); - bool CurrentSwitch(int direction); - void UpdateBatteryVoltage(double dt); - double ComputeMovement(double dt, double dt1, const TTrackShape &Shape, TTrackParam &Track, TTractionParam &ElectricTraction, const TLocation &NewLoc, TRotation &NewRot); //oblicza przesuniecie pojazdu - double FastComputeMovement(double dt, const TTrackShape &Shape, TTrackParam &Track, const TLocation &NewLoc, TRotation &NewRot); //oblicza przesuniecie pojazdu - wersja zoptymalizowana - double ShowEngineRotation(int VehN); + bool AddPulseForce(int Multipler); /*dla drezyny*/ - // Q ******************************************************************************************* - double GetTrainsetVoltage(void); - bool Physic_ReActivation(void); - double LocalBrakeRatio(void); - double ManualBrakeRatio(void); - double PipeRatio(void);/*ile napelniac*/ - double RealPipeRatio(void);/*jak szybko*/ - double BrakeVP(void); + bool SandDoseOn(void); /*wlacza/wylacza sypanie piasku*/ - /*! przesylanie komend sterujacych*/ - bool SendCtrlBroadcast(std::string CtrlCommand, double ctrlvalue); - bool SendCtrlToNext(std::string CtrlCommand, double ctrlvalue, double dir); - bool SetInternalCommand(std::string NewCommand, double NewValue1, double NewValue2); - double GetExternalCommand(std::string &Command); - bool RunCommand(std::string Command, double CValue1, double CValue2); - bool RunInternalCommand(void); - void PutCommand(std::string NewCommand, double NewValue1, double NewValue2, const TLocation &NewLocation); - bool CabActivisation(void); - bool CabDeactivisation(void); + /*! zbijanie czuwaka/SHP*/ + void SSReset(void); + bool SecuritySystemReset(void); + void SecuritySystemCheck(double dt); - /*! funkcje zwiekszajace/zmniejszajace nastawniki*/ - /*! glowny nastawnik:*/ - bool IncMainCtrl(int CtrlSpeed); - bool DecMainCtrl(int CtrlSpeed); - /*! pomocniczy nastawnik:*/ - bool IncScndCtrl(int CtrlSpeed); - bool DecScndCtrl(int CtrlSpeed); + bool BatterySwitch(bool State); + bool EpFuseSwitch(bool State); + /*! stopnie hamowania - hamulec zasadniczy*/ + bool IncBrakeLevelOld(void); + bool DecBrakeLevelOld(void); + bool IncLocalBrakeLevel(int CtrlSpeed); + bool DecLocalBrakeLevel(int CtrlSpeed); + /*! ABu 010205: - skrajne polozenia ham. pomocniczego*/ + bool IncLocalBrakeLevelFAST(void); + bool DecLocalBrakeLevelFAST(void); + bool IncManualBrakeLevel(int CtrlSpeed); + bool DecManualBrakeLevel(int CtrlSpeed); + bool DynamicBrakeSwitch(bool Switch); + bool EmergencyBrakeSwitch(bool Switch); + bool AntiSlippingBrake(void); + bool BrakeReleaser(int state); + bool SwitchEPBrake(int state); + bool AntiSlippingButton(void); /*! reczny wlacznik urzadzen antyposlizgowych*/ - bool AddPulseForce(int Multipler);/*dla drezyny*/ + /*funkcje dla ukladow pneumatycznych*/ + bool IncBrakePress(double &brake, double PressLimit, double dp); + bool DecBrakePress(double &brake, double PressLimit, double dp); + bool BrakeDelaySwitch(int BDS); /*! przelaczanie nastawy opoznienia*/ + bool IncBrakeMult(void); /*przelaczanie prozny/ladowny*/ + bool DecBrakeMult(void); + /*pomocnicze funkcje dla ukladow pneumatycznych*/ + void UpdateBrakePressure(double dt); + void UpdatePipePressure(double dt); + void CompressorCheck(double dt); /*wlacza, wylacza kompresor, laduje zbiornik*/ + void UpdatePantVolume(double dt); // Ra + void UpdateScndPipePressure(double dt); + double GetDVc(double dt); - bool SandDoseOn(void);/*wlacza/wylacza sypanie piasku*/ + /*funkcje obliczajace sily*/ + void ComputeConstans(void); // ABu: wczesniejsze wyznaczenie stalych dla liczenia sil + double ComputeMass(void); + void ComputeTotalForce(double dt, double dt1, bool FullVer); + double Adhesive(double staticfriction); + double TractionForce(double dt); + double FrictionForce(double R, int TDamage); + double BrakeForce(const TTrackParam &Track); + double CouplerForce(int CouplerN, double dt); + void CollisionDetect(int CouplerN, double dt); + /*obrot kol uwzgledniajacy poslizg*/ + double ComputeRotatingWheel(double WForce, double dt, double n); - /*! zbijanie czuwaka/SHP*/ - void SSReset(void); - bool SecuritySystemReset(void); - void SecuritySystemCheck(double dt); + /*--funkcje dla lokomotyw*/ + bool DirectionBackward(void); /*! kierunek ruchu*/ + bool MainSwitch(bool State); /*! wylacznik glowny*/ + bool ConverterSwitch(bool State); /*! wl/wyl przetwornicy*/ + bool CompressorSwitch(bool State); /*! wl/wyl sprezarki*/ - bool BatterySwitch(bool State); - bool EpFuseSwitch(bool State); + /*-funkcje typowe dla lokomotywy elektrycznej*/ + void ConverterCheck(); // przetwornica + bool FuseOn(void); // bezpiecznik nadamiary + bool FuseFlagCheck(void); // sprawdzanie flagi nadmiarowego + void FuseOff(void); // wylaczenie nadmiarowego + int ShowCurrent(int AmpN); // pokazuje bezwgl. wartosc pradu na wybranym amperomierzu + int ShowCurrentP(int AmpN); // pokazuje bezwgl. wartosc pradu w wybranym pojezdzie //Q 20160722 - /*! stopnie hamowania - hamulec zasadniczy*/ - bool IncBrakeLevelOld(void); - bool DecBrakeLevelOld(void); - bool IncLocalBrakeLevel(int CtrlSpeed); - bool DecLocalBrakeLevel(int CtrlSpeed); - /*! ABu 010205: - skrajne polozenia ham. pomocniczego*/ - bool IncLocalBrakeLevelFAST(void); - bool DecLocalBrakeLevelFAST(void); - bool IncManualBrakeLevel(int CtrlSpeed); - bool DecManualBrakeLevel(int CtrlSpeed); - bool DynamicBrakeSwitch(bool Switch); - bool EmergencyBrakeSwitch(bool Switch); - bool AntiSlippingBrake(void); - bool BrakeReleaser(int state); - bool SwitchEPBrake(int state); - bool AntiSlippingButton(void); /*! reczny wlacznik urzadzen antyposlizgowych*/ + /*!o pokazuje bezwgl. wartosc obrotow na obrotomierzu jednego z 3 pojazdow*/ + /*function ShowEngineRotation(VehN:int): integer; //Ra 2014-06: przeniesione do C++*/ + /*funkcje uzalezniajace sile pociagowa od predkosci: v2n, n2r, current, momentum*/ + double v2n(void); + double current(double n, double U); + double Momentum(double I); + double MomentumF(double I, double Iw, int SCP); - /*funkcje dla ukladow pneumatycznych*/ - bool IncBrakePress(double &brake, double PressLimit, double dp); - bool DecBrakePress(double &brake, double PressLimit, double dp); - bool BrakeDelaySwitch(int BDS);/*! przelaczanie nastawy opoznienia*/ - bool IncBrakeMult(void);/*przelaczanie prozny/ladowny*/ - bool DecBrakeMult(void); - /*pomocnicze funkcje dla ukladow pneumatycznych*/ - void UpdateBrakePressure(double dt); - void UpdatePipePressure(double dt); - void CompressorCheck(double dt);/*wlacza, wylacza kompresor, laduje zbiornik*/ - void UpdatePantVolume(double dt); //Ra - void UpdateScndPipePressure(double dt); - double GetDVc(double dt); + bool CutOffEngine(void); // odlaczenie udszkodzonych silnikow + /*funkcje automatycznego rozruchu np EN57*/ + bool MaxCurrentSwitch(bool State); // przelacznik pradu wysokiego rozruchu + bool MinCurrentSwitch(bool State); // przelacznik pradu automatycznego rozruchu + bool AutoRelaySwitch(bool State); // przelacznik automatycznego rozruchu + bool AutoRelayCheck(void); // symulacja automatycznego rozruchu - /*funkcje obliczajace sily*/ - void ComputeConstans(void);//ABu: wczesniejsze wyznaczenie stalych dla liczenia sil - double ComputeMass(void); - void ComputeTotalForce(double dt, double dt1, bool FullVer); - double Adhesive(double staticfriction); - double TractionForce(double dt); - double FrictionForce(double R, int TDamage); - double BrakeForce(const TTrackParam &Track); - double CouplerForce(int CouplerN, double dt); - void CollisionDetect(int CouplerN, double dt); - /*obrot kol uwzgledniajacy poslizg*/ - double ComputeRotatingWheel(double WForce, double dt, double n); + bool ResistorsFlagCheck(void); // sprawdzenie kontrolki oporow rozruchowych NBMX + bool PantFront(bool State); // obsluga pantografou przedniego + bool PantRear(bool State); // obsluga pantografu tylnego - /*--funkcje dla lokomotyw*/ - bool DirectionBackward(void);/*! kierunek ruchu*/ - bool MainSwitch(bool State);/*! wylacznik glowny*/ - bool ConverterSwitch(bool State);/*! wl/wyl przetwornicy*/ - bool CompressorSwitch(bool State);/*! wl/wyl sprezarki*/ + /*-funkcje typowe dla lokomotywy spalinowej z przekladnia mechaniczna*/ + bool dizel_EngageSwitch(double state); + bool dizel_EngageChange(double dt); + bool dizel_AutoGearCheck(void); + double dizel_fillcheck(int mcp); + double dizel_Momentum(double dizel_fill, double n, double dt); + bool dizel_Update(double dt); - /*-funkcje typowe dla lokomotywy elektrycznej*/ - void ConverterCheck(); // przetwornica - bool FuseOn(void); //bezpiecznik nadamiary - bool FuseFlagCheck(void); // sprawdzanie flagi nadmiarowego - void FuseOff(void); // wylaczenie nadmiarowego - int ShowCurrent(int AmpN); //pokazuje bezwgl. wartosc pradu na wybranym amperomierzu - int ShowCurrentP(int AmpN); //pokazuje bezwgl. wartosc pradu w wybranym pojezdzie //Q 20160722 + /* funckje dla wagonow*/ + bool LoadingDone(double LSpeed, std::string LoadInit); + bool DoorLeft(bool State); // obsluga drzwi lewych + bool DoorRight(bool State); // obsluga drzwi prawych + bool DoorBlockedFlag(void); // sprawdzenie blokady drzwi - /*!o pokazuje bezwgl. wartosc obrotow na obrotomierzu jednego z 3 pojazdow*/ - /*function ShowEngineRotation(VehN:int): integer; //Ra 2014-06: przeniesione do C++*/ - /*funkcje uzalezniajace sile pociagowa od predkosci: v2n, n2r, current, momentum*/ - double v2n(void); - double current(double n, double U); - double Momentum(double I); - double MomentumF(double I, double Iw, int SCP); + /* funkcje dla samochodow*/ + bool ChangeOffsetH(double DeltaOffset); - bool CutOffEngine(void); //odlaczenie udszkodzonych silnikow - /*funkcje automatycznego rozruchu np EN57*/ - bool MaxCurrentSwitch(bool State); //przelacznik pradu wysokiego rozruchu - bool MinCurrentSwitch(bool State); //przelacznik pradu automatycznego rozruchu - bool AutoRelaySwitch(bool State); //przelacznik automatycznego rozruchu - bool AutoRelayCheck(void);//symulacja automatycznego rozruchu - - bool ResistorsFlagCheck(void); //sprawdzenie kontrolki oporow rozruchowych NBMX - bool PantFront(bool State); //obsluga pantografou przedniego - bool PantRear(bool State); //obsluga pantografu tylnego - - /*-funkcje typowe dla lokomotywy spalinowej z przekladnia mechaniczna*/ - bool dizel_EngageSwitch(double state); - bool dizel_EngageChange(double dt); - bool dizel_AutoGearCheck(void); - double dizel_fillcheck(int mcp); - double dizel_Momentum(double dizel_fill, double n, double dt); - bool dizel_Update(double dt); - - /* funckje dla wagonow*/ - bool LoadingDone(double LSpeed, std::string LoadInit); - bool DoorLeft(bool State); //obsluga drzwi lewych - bool DoorRight(bool State); //obsluga drzwi prawych - bool DoorBlockedFlag(void); //sprawdzenie blokady drzwi - - /* funkcje dla samochodow*/ - bool ChangeOffsetH(double DeltaOffset); - - /*funkcje ladujace pliki opisujace pojazd*/ - bool LoadFIZ(std::string chkpath); //Q 20160717 bool LoadChkFile(std::string chkpath); - bool readMPT(int ln, std::string line); //Q 20160717 - bool readRLIST(int ln, std::string line); //Q 20160718 - bool readBPT(int ln, std::string line); //Q 20160721 - void BrakeValveDecode(std::string s); //Q 20160719 - void BrakeSubsystemDecode(); //Q 20160719 - void PowerParamDecode(std::string lines, std::string prefix, TPowerParameters &PowerParamDecode); //Q 20160719 - TPowerSource PowerSourceDecode(std::string s); //Q 20160719 - TPowerType PowerDecode(std::string s); //Q 20160719 - TEngineTypes EngineDecode(std::string s); //Q 20160721 - bool CheckLocomotiveParameters(bool ReadyFlag, int Dir); - std::string EngineDescription(int what); + /*funkcje ladujace pliki opisujace pojazd*/ + bool LoadFIZ(std::string chkpath); // Q 20160717 bool LoadChkFile(std::string chkpath); + bool readMPT(int ln, std::string line); // Q 20160717 + bool readRLIST(int ln, std::string line); // Q 20160718 + bool readBPT(int ln, std::string line); // Q 20160721 + void BrakeValveDecode(std::string s); // Q 20160719 + void BrakeSubsystemDecode(); // Q 20160719 + void PowerParamDecode(std::string lines, std::string prefix, + TPowerParameters &PowerParamDecode); // Q 20160719 + TPowerSource PowerSourceDecode(std::string s); // Q 20160719 + TPowerType PowerDecode(std::string s); // Q 20160719 + TEngineTypes EngineDecode(std::string s); // Q 20160721 + bool CheckLocomotiveParameters(bool ReadyFlag, int Dir); + std::string EngineDescription(int what); }; extern double Distance(TLocation Loc1, TLocation Loc2, TDimension Dim1, TDimension Dim2); diff --git a/McZapkie/Mover.cpp b/McZapkie/Mover.cpp index 9b1be6fd..3084d6b0 100644 --- a/McZapkie/Mover.cpp +++ b/McZapkie/Mover.cpp @@ -7,26 +7,26 @@ obtain one at http://mozilla.org/MPL/2.0/. */ -#include #include -#include -#include // std::ifstream -#include -#include -#include -#include // sprintf() -#include -#include +#include #include +#include // std::ifstream +#include +#include +#include +#include +#include // sprintf() #include +#include +#include -#include "Mover.h" #include "../globals.h" +#include "Mover.h" //#include "../qutils.h" -#include "mctools.h" #include "../logs.h" -#include "hamulce.h" #include "Oerlikon_ESt.h" +#include "hamulce.h" +#include "mctools.h" //--------------------------------------------------------------------------- #pragma package(smart_init) @@ -54,35 +54,35 @@ inline double sqr(double val) // SQR() zle liczylo w current() ... double ComputeCollision(double &v1, double &v2, double m1, double m2, double beta, bool vc) { // oblicza zmiane predkosci i przyrost pedu wskutek kolizji - if (v1 < v2 && vc) - return 0; - else - { - double sum = m1 + m2; - double w1 = ((m1 - m2) * v1 + 2 * m2 * v2) / sum; - double w2 = ((m2 - m1) * v2 + 2 * m1 * v1) / sum; - v1 = w1 * sqrt(1 - beta); // niejawna zmiana predkosci wskutek zderzenia - v2 = w2 * sqrt(1 - beta); - return m1 * (w2 - w1) * (1 - beta); - } + if (v1 < v2 && vc) + return 0; + else + { + double sum = m1 + m2; + double w1 = ((m1 - m2) * v1 + 2 * m2 * v2) / sum; + double w2 = ((m2 - m1) * v2 + 2 * m1 * v1) / sum; + v1 = w1 * sqrt(1 - beta); // niejawna zmiana predkosci wskutek zderzenia + v2 = w2 * sqrt(1 - beta); + return m1 * (w2 - w1) * (1 - beta); + } } int DirPatch(int Coupler1, int Coupler2) { // poprawka dla liczenia sil przy ustawieniu przeciwnym obiektow - return (Coupler1 != Coupler2 ? 1 : -1); + return (Coupler1 != Coupler2 ? 1 : -1); } int DirF(int CouplerN) { - switch (CouplerN) - { - case 0: - return -1; - case 1: - return 1; - default: - return 0; - } + switch (CouplerN) + { + case 0: + return -1; + case 1: + return 1; + default: + return 0; + } } // ************************************************************************************************* @@ -189,21 +189,21 @@ double TMoverParameters::current(double n, double U) { if (DynamicBrakeType > 1) { - // if DynamicBrakeType<>dbrake_automatic then - // MotorCurrent:=-fi*n/Rz {hamowanie silnikiem na oporach rozruchowych} - /* begin - U:=0; - Isf:=Isat; - Delta:=SQR(Isf*Rz+Mn*fi*n-U)+4*U*Isf*Rz; - MotorCurrent:=(U-Isf*Rz-Mn*fi*n+SQRT(Delta))/(2*Rz) - end*/ - if ((DynamicBrakeType == dbrake_switch) && (TrainType == dt_ET42)) - { // z Megapacka - Rz = WindingRes + R; - MotorCurrent = - -MotorParam[SP].fi * n / Rz; //{hamowanie silnikiem na oporach rozruchowych} - } - } + // if DynamicBrakeType<>dbrake_automatic then + // MotorCurrent:=-fi*n/Rz {hamowanie silnikiem na oporach rozruchowych} + /* begin + U:=0; + Isf:=Isat; + Delta:=SQR(Isf*Rz+Mn*fi*n-U)+4*U*Isf*Rz; + MotorCurrent:=(U-Isf*Rz-Mn*fi*n+SQRT(Delta))/(2*Rz) + end*/ + if ((DynamicBrakeType == dbrake_switch) && (TrainType == dt_ET42)) + { // z Megapacka + Rz = WindingRes + R; + MotorCurrent = -MotorParam[SP].fi * n / + Rz; //{hamowanie silnikiem na oporach rozruchowych} + } + } else MotorCurrent = 0; // odciecie pradu od silnika } @@ -240,37 +240,37 @@ double TMoverParameters::current(double n, double U) } // writepaslog("MotorCurrent ", FloatToStr(MotorCurrent)); - if ((DynamicBrakeType == dbrake_switch) && ((BrakePress > 2.0) || (PipePress < 3.6))) - { - Im = 0; - MotorCurrent = 0; - // Im:=0; - Itot = 0; - } - else - Im = MotorCurrent; + if ((DynamicBrakeType == dbrake_switch) && ((BrakePress > 2.0) || (PipePress < 3.6))) + { + Im = 0; + MotorCurrent = 0; + // Im:=0; + Itot = 0; + } + else + Im = MotorCurrent; EnginePower = abs(Itot) * (1 + RList[MainCtrlActualPos].Mn) * abs(U); // awarie MotorCurrent = abs(Im); // zmienna pomocnicza - if (MotorCurrent > 0) - { - if (FuzzyLogic(abs(n), nmax * 1.1, p_elengproblem)) - if (MainSwitch(false)) - EventFlag = true; /*zbyt duze obroty - wywalanie wskutek ognia okreznego*/ - if (TestFlag(DamageFlag, dtrain_engine)) - if (FuzzyLogic(MotorCurrent, (double)ImaxLo / 10.0, p_elengproblem)) - if (MainSwitch(false)) - EventFlag = true; /*uszkodzony silnik (uplywy)*/ - if ((FuzzyLogic(abs(Im), Imax * 2, p_elengproblem) || - FuzzyLogic(abs(n), nmax * 1.11, p_elengproblem))) - /* or FuzzyLogic(Abs(U/Mn),2*NominalVoltage,1)) then */ /*poprawic potem*/ - if ((SetFlag(DamageFlag, dtrain_engine))) - EventFlag = true; - /*! dorobic grzanie oporow rozruchowych i silnika*/ - } + if (MotorCurrent > 0) + { + if (FuzzyLogic(abs(n), nmax * 1.1, p_elengproblem)) + if (MainSwitch(false)) + EventFlag = true; /*zbyt duze obroty - wywalanie wskutek ognia okreznego*/ + if (TestFlag(DamageFlag, dtrain_engine)) + if (FuzzyLogic(MotorCurrent, (double)ImaxLo / 10.0, p_elengproblem)) + if (MainSwitch(false)) + EventFlag = true; /*uszkodzony silnik (uplywy)*/ + if ((FuzzyLogic(abs(Im), Imax * 2, p_elengproblem) || + FuzzyLogic(abs(n), nmax * 1.11, p_elengproblem))) + /* or FuzzyLogic(Abs(U/Mn),2*NominalVoltage,1)) then */ /*poprawic potem*/ + if ((SetFlag(DamageFlag, dtrain_engine))) + EventFlag = true; + /*! dorobic grzanie oporow rozruchowych i silnika*/ + } return Im; } @@ -282,11 +282,10 @@ TMoverParameters::TMoverParameters(double VelInitial, std::string TypeNameInit, std::string NameInit, int LoadInitial, std::string LoadTypeInitial, int Cab) //: T_MoverParameters(VelInitial, TypeNameInit, - //NameInit, LoadInitial, LoadTypeInitial, Cab) +// NameInit, LoadInitial, LoadTypeInitial, Cab) { int b, k; - WriteLog( - "------------------------------------------------------"); + WriteLog("------------------------------------------------------"); WriteLog("init default physic values for " + NameInit + ", [" + TypeNameInit + "], [" + LoadTypeInitial + "]"); Dim = TDimension(); @@ -384,44 +383,43 @@ TMoverParameters::TMoverParameters(double VelInitial, std::string TypeNameInit, nmax = 0.0; Voltage = 0.0; - HeatingPowerSource = TPowerParameters(); - //HeatingPowerSource.MaxVoltage = 0.0; - //HeatingPowerSource.MaxCurrent = 0.0; - //HeatingPowerSource.IntR = 0.001; - //HeatingPowerSource.SourceType = NotDefined; - //HeatingPowerSource.PowerType = NoPower; - //HeatingPowerSource.RPowerCable.PowerTrans = NoPower; + // HeatingPowerSource.MaxVoltage = 0.0; + // HeatingPowerSource.MaxCurrent = 0.0; + // HeatingPowerSource.IntR = 0.001; + // HeatingPowerSource.SourceType = NotDefined; + // HeatingPowerSource.PowerType = NoPower; + // HeatingPowerSource.RPowerCable.PowerTrans = NoPower; AlterHeatPowerSource = TPowerParameters(); - //AlterHeatPowerSource.MaxVoltage = 0.0; - //AlterHeatPowerSource.MaxCurrent = 0.0; - //AlterHeatPowerSource.IntR = 0.001; - //AlterHeatPowerSource.SourceType = NotDefined; - //AlterHeatPowerSource.PowerType = NoPower; - //AlterHeatPowerSource.RPowerCable.PowerTrans = NoPower; + // AlterHeatPowerSource.MaxVoltage = 0.0; + // AlterHeatPowerSource.MaxCurrent = 0.0; + // AlterHeatPowerSource.IntR = 0.001; + // AlterHeatPowerSource.SourceType = NotDefined; + // AlterHeatPowerSource.PowerType = NoPower; + // AlterHeatPowerSource.RPowerCable.PowerTrans = NoPower; LightPowerSource = TPowerParameters(); - //LightPowerSource.MaxVoltage = 0.0; - //LightPowerSource.MaxCurrent = 0.0; - //LightPowerSource.IntR = 0.001; - //LightPowerSource.SourceType = NotDefined; - //LightPowerSource.PowerType = NoPower; - //LightPowerSource.RPowerCable.PowerTrans = NoPower; + // LightPowerSource.MaxVoltage = 0.0; + // LightPowerSource.MaxCurrent = 0.0; + // LightPowerSource.IntR = 0.001; + // LightPowerSource.SourceType = NotDefined; + // LightPowerSource.PowerType = NoPower; + // LightPowerSource.RPowerCable.PowerTrans = NoPower; AlterLightPowerSource = TPowerParameters(); - //AlterLightPowerSource.MaxVoltage = 0.0; - //AlterLightPowerSource.MaxCurrent = 0.0; - //AlterLightPowerSource.IntR = 0.001; - //AlterLightPowerSource.SourceType = NotDefined; - //AlterLightPowerSource.PowerType = NoPower; - //AlterLightPowerSource.RPowerCable.PowerTrans = NoPower; + // AlterLightPowerSource.MaxVoltage = 0.0; + // AlterLightPowerSource.MaxCurrent = 0.0; + // AlterLightPowerSource.IntR = 0.001; + // AlterLightPowerSource.SourceType = NotDefined; + // AlterLightPowerSource.PowerType = NoPower; + // AlterLightPowerSource.RPowerCable.PowerTrans = NoPower; TypeName = TypeNameInit; HighPipePress = 0.0; LowPipePress = 0.0; DeltaPipePress = 0.0; - EqvtPipePress = 0.0; + EqvtPipePress = 0.0; CntrlPipePress = 0.0; BrakeCylNo = 0; BrakeCylRadius = 0.0; @@ -471,7 +469,7 @@ TMoverParameters::TMoverParameters(double VelInitial, std::string TypeNameInit, dizel_engageMaxForce = 6000.0; dizel_engagefriction = 0.5; TurboTest = 0; - + DoorOpenCtrl = 0; DoorCloseCtrl = 0; DoorStayOpen = 0.0; @@ -493,10 +491,10 @@ TMoverParameters::TMoverParameters(double VelInitial, std::string TypeNameInit, CompressorPower = 1.0; SmallCompressorPower = 0.0; - for (b = 0; b < 26; b++) - eimc[b] = 0.0; - eimc[eimc_p_eped] = 1.5; - StopBrakeDecc = 0.0; + for (b = 0; b < 26; b++) + eimc[b] = 0.0; + eimc[eimc_p_eped] = 1.5; + StopBrakeDecc = 0.0; ScndInMain = false; @@ -549,7 +547,7 @@ TMoverParameters::TMoverParameters(double VelInitial, std::string TypeNameInit, DelayCtrlFlag = false; AutoRelayFlag = false; - LightsPos = 0; + LightsPos = 0; Heating = false; Mains = false; ActiveDir = 0; // kierunek nie ustawiony @@ -634,12 +632,12 @@ TMoverParameters::TMoverParameters(double VelInitial, std::string TypeNameInit, Ft = 0.0; Ff = 0.0; Fb = 0.0; - dL = 0.0; + dL = 0.0; FTotal = 0.0; FStand = 0.0; FTrain = 0.0; - UnitBrakeForce = 0.0; - Ntotal = 0.0; + UnitBrakeForce = 0.0; + Ntotal = 0.0; AccS = 0.0; AccN = 0.0; AccV = 0.0; @@ -667,8 +665,8 @@ TMoverParameters::TMoverParameters(double VelInitial, std::string TypeNameInit, dizel_engagedeltaomega = 0.0; PhysicActivation = true; - for (b = 0; b < 21; b++) - eimv[b] = 0.0; + for (b = 0; b < 21; b++) + eimv[b] = 0.0; RunningShape.R = 0.0; RunningShape.Len = 1.0; @@ -691,12 +689,12 @@ TMoverParameters::TMoverParameters(double VelInitial, std::string TypeNameInit, OffsetTrackV = 0.0; CommandIn = TCommand(); - //CommandIn.Command = ""; - //CommandIn.Value1 = 0.0; - //CommandIn.Value2 = 0.0; - //CommandIn.Location.X = 0.0; - //CommandIn.Location.Y = 0.0; - //CommandIn.Location.Z = 0.0; + // CommandIn.Command = ""; + // CommandIn.Value1 = 0.0; + // CommandIn.Value2 = 0.0; + // CommandIn.Location.X = 0.0; + // CommandIn.Location.Y = 0.0; + // CommandIn.Location.Z = 0.0; CommandLast, CommandOut = ""; ValueOut = 0.0; // czesciowo stale, czesciowo zmienne} @@ -768,7 +766,7 @@ double TMoverParameters::CouplerDist(int Coupler) }; bool TMoverParameters::Attach(int ConnectNo, int ConnectToNr, TMoverParameters *ConnectTo, - int CouplingType, bool Forced) + int CouplingType, bool Forced) { //łączenie do swojego sprzęgu (ConnectNo) pojazdu (ConnectTo) stroną (ConnectToNr) // Ra: zwykle wykonywane dwukrotnie, dla każdego pojazdu oddzielnie // Ra: trzeba by odróżnić wymóg dociśnięcia od uszkodzenia sprzęgu przy podczepianiu AI do @@ -811,7 +809,7 @@ bool TMoverParameters::Attach(int ConnectNo, int ConnectToNr, TMoverParameters * }; // to jest już niepotrzebne bo nie ma Delphi -//bool TMoverParameters::Attach(int ConnectNo, int ConnectToNr, TMoverParameters *ConnectTo, +// bool TMoverParameters::Attach(int ConnectNo, int ConnectToNr, TMoverParameters *ConnectTo, // int CouplingType, bool Forced) //{ //łączenie do (ConnectNo) pojazdu (ConnectTo) stroną (ConnectToNr) // return Attach(ConnectNo, ConnectToNr, (TMoverParameters *)ConnectTo, CouplingType, Forced); @@ -1205,13 +1203,13 @@ double TMoverParameters::LocalBrakeRatio(void) LBR = Handle->GetEP(BrakeCtrlPosR); else LBR = 0; - else - { - if (LocalBrakePosNo > 0) - LBR = (double)LocalBrakePos / LocalBrakePosNo; - else - LBR = 0; - } + else + { + if (LocalBrakePosNo > 0) + LBR = (double)LocalBrakePos / LocalBrakePosNo; + else + LBR = 0; + } // if (TestFlag(BrakeStatus, b_antislip)) // LBR = Max0R(LBR, PipeRatio) + 0.4; return LBR; @@ -1276,10 +1274,10 @@ double TMoverParameters::PipeRatio(void) else pr = (HighPipePress - 1.0 / 3.0 * DeltaPipePress - Max0R(LowPipePress, PipePress)) / (DeltaPipePress * 2.0 / 3.0); - //if (not TestFlag(BrakeStatus, b_Ractive)) + // if (not TestFlag(BrakeStatus, b_Ractive)) // and(BrakeMethod and 1 = 0) and TestFlag(BrakeDelays, bdelay_R) and (Power < 1) and // (BrakeCtrlPos < 1) then pr : = Min0R(0.5, pr); - //if (Compressor > 0.5) + // if (Compressor > 0.5) // then pr : = pr * 1.333; // dziwny rapid wywalamy } else @@ -1364,21 +1362,22 @@ double TMoverParameters::ComputeMovement(double dt, double dt1, const TTrackShap const TLocation &NewLoc, TRotation &NewRot) { const double Vepsilon = 1e-5; - const double Aepsilon = 1e-3; // ASBSpeed=0.8; + const double Aepsilon = 1e-3; // ASBSpeed=0.8; int b; double Vprev, AccSprev, d, hvc; // T_MoverParameters::ComputeMovement(dt, dt1, Shape, Track, ElectricTraction, NewLoc, NewRot); // // najpierw kawalek z funkcji w pliku mover.pas - TotalCurrent = 0; - hvc = Max0R(Max0R(PantFrontVolt, PantRearVolt), ElectricTraction.TractionVoltage * 0.9); + TotalCurrent = 0; + hvc = Max0R(Max0R(PantFrontVolt, PantRearVolt), ElectricTraction.TractionVoltage * 0.9); for (b = 0; b < 2; b++) // przekazywanie napiec if (((Couplers[b].CouplingFlag & ctrain_power) == ctrain_power) || (((Couplers[b].CouplingFlag & ctrain_heating) == ctrain_heating) && (Heating))) { HVCouplers[1 - b][1] = - Max0R(abs(hvc), Couplers[b].Connected->HVCouplers[Couplers[b].ConnectedNr][1] - - HVCouplers[b][0] * 0.02); + Max0R(abs(hvc), + Couplers[b].Connected->HVCouplers[Couplers[b].ConnectedNr][1] - + HVCouplers[b][0] * 0.02); } else HVCouplers[1 - b][1] = abs(hvc) - HVCouplers[b][0] * 0.02; @@ -1388,35 +1387,33 @@ double TMoverParameters::ComputeMovement(double dt, double dt1, const TTrackShap hvc = HVCouplers[0][1] + HVCouplers[1][1]; if ((abs(PantFrontVolt) + abs(PantRearVolt) < 1) && - (hvc > 1)) // bez napiecia, ale jest cos na sprzegach: - { - for (b = 0; b < 2; ++b) // przekazywanie pradow - if (((Couplers[b].CouplingFlag & ctrain_power) == ctrain_power) || - (((Couplers[b].CouplingFlag & ctrain_heating) == ctrain_heating) && - (Heating))) // jesli spiety - { - HVCouplers[b][0] = - Couplers[b].Connected->HVCouplers[1 - Couplers[b].ConnectedNr][0] + - Itot * HVCouplers[b][1] / hvc; // obciążenie rozkladane stosownie do napiec - } - else // pierwszy pojazd - { - HVCouplers[b][0] = Itot * HVCouplers[b][1] / hvc; - } - } - else - { - if (((Couplers[0].CouplingFlag & ctrain_power) == ctrain_power) || - (((Couplers[0].CouplingFlag & ctrain_heating) == ctrain_heating) && (Heating))) - TotalCurrent += - Couplers[0].Connected->HVCouplers[1 - Couplers[0].ConnectedNr][0]; - if (((Couplers[1].CouplingFlag & ctrain_power) == ctrain_power) || - (((Couplers[1].CouplingFlag & ctrain_heating) == ctrain_heating) && (Heating))) - TotalCurrent += - Couplers[1].Connected->HVCouplers[1 - Couplers[1].ConnectedNr][0]; - HVCouplers[0][0] = 0; - HVCouplers[1][0] = 0; - } + (hvc > 1)) // bez napiecia, ale jest cos na sprzegach: + { + for (b = 0; b < 2; ++b) // przekazywanie pradow + if (((Couplers[b].CouplingFlag & ctrain_power) == ctrain_power) || + (((Couplers[b].CouplingFlag & ctrain_heating) == ctrain_heating) && + (Heating))) // jesli spiety + { + HVCouplers[b][0] = + Couplers[b].Connected->HVCouplers[1 - Couplers[b].ConnectedNr][0] + + Itot * HVCouplers[b][1] / hvc; // obciążenie rozkladane stosownie do napiec + } + else // pierwszy pojazd + { + HVCouplers[b][0] = Itot * HVCouplers[b][1] / hvc; + } + } + else + { + if (((Couplers[0].CouplingFlag & ctrain_power) == ctrain_power) || + (((Couplers[0].CouplingFlag & ctrain_heating) == ctrain_heating) && (Heating))) + TotalCurrent += Couplers[0].Connected->HVCouplers[1 - Couplers[0].ConnectedNr][0]; + if (((Couplers[1].CouplingFlag & ctrain_power) == ctrain_power) || + (((Couplers[1].CouplingFlag & ctrain_heating) == ctrain_heating) && (Heating))) + TotalCurrent += Couplers[1].Connected->HVCouplers[1 - Couplers[1].ConnectedNr][0]; + HVCouplers[0][0] = 0; + HVCouplers[1][0] = 0; + } ClearPendingExceptions(); // ma byc if (!TestFlag(DamageFlag, dtrain_out)) @@ -1425,11 +1422,11 @@ double TMoverParameters::ComputeMovement(double dt, double dt1, const TTrackShap RunningTrack = Track; RunningTraction = ElectricTraction; - //if (!DynamicBrakeFlag) + // if (!DynamicBrakeFlag) // RunningTraction.TractionVoltage = ElectricTraction.TractionVoltage /*- // abs(ElectricTraction.TractionResistivity * // (Itot + HVCouplers[0][0] + HVCouplers[1][0]))*/; - //else + // else // RunningTraction.TractionVoltage = // ElectricTraction.TractionVoltage /*- // abs(ElectricTraction.TractionResistivity * Itot * @@ -2139,11 +2136,11 @@ bool TMoverParameters::IncScndCtrl(int CtrlSpeed) if (LastRelayTime > CtrlDelay) LastRelayTime = 0; - if ((OK) && (EngineType == ElectricInductionMotor)) - if ((Vmax < 250)) - ScndCtrlActualPos = Round(Vel + 0.5); - else - ScndCtrlActualPos = Round(Vel * 1.0 / 2 + 0.5); + if ((OK) && (EngineType == ElectricInductionMotor)) + if ((Vmax < 250)) + ScndCtrlActualPos = Round(Vel + 0.5); + else + ScndCtrlActualPos = Round(Vel * 1.0 / 2 + 0.5); return OK; } @@ -2193,8 +2190,8 @@ bool TMoverParameters::DecScndCtrl(int CtrlSpeed) if (LastRelayTime > CtrlDownDelay) LastRelayTime = 0; - if ((OK) && (EngineType == ElectricInductionMotor)) - ScndCtrlActualPos = 0; + if ((OK) && (EngineType == ElectricInductionMotor)) + ScndCtrlActualPos = 0; return OK; } @@ -2203,7 +2200,7 @@ bool TMoverParameters::DecScndCtrl(int CtrlSpeed) // Q: 20160710 // załączenie rozrządu // ************************************************************************************************* -bool TMoverParameters::CabActivisation(void) +bool TMoverParameters::CabActivisation(void) { bool OK = false; @@ -2221,7 +2218,7 @@ bool TMoverParameters::CabActivisation(void) // Q: 20160710 // wyłączenie rozrządu // ************************************************************************************************* -bool TMoverParameters::CabDeactivisation(void) +bool TMoverParameters::CabDeactivisation(void) { bool OK = false; @@ -2350,8 +2347,8 @@ void TMoverParameters::SecuritySystemCheck(double dt) // Ra: z CA/SHP w EZT jest ten problem, że w rozrządczym nie ma kierunku, a w silnikowym nie ma // obsady // poza tym jest zdefiniowany we wszystkich 3 członach EN57 - if ((!Radio)) - EmergencyBrakeSwitch(false); + if ((!Radio)) + EmergencyBrakeSwitch(false); if ((SecuritySystem.SystemType > 0) && (SecuritySystem.Status > 0) && (Battery)) // Ra: EZT ma teraz czuwak w rozrządczym @@ -2420,7 +2417,7 @@ void TMoverParameters::SecuritySystemCheck(double dt) } else if (!Battery) { // wyłączenie baterii deaktywuje sprzęt - EmergencyBrakeSwitch(false); + EmergencyBrakeSwitch(false); // SecuritySystem.Status = 0; //deaktywacja czuwaka } } @@ -2537,9 +2534,9 @@ bool TMoverParameters::MainSwitch(bool State) { dizel_enginestart = State; } - if (((TrainType == dt_EZT) && (!State))) - ConvOvldFlag = true; - // if (State=false) then //jeśli wyłączony + if (((TrainType == dt_EZT) && (!State))) + ConvOvldFlag = true; + // if (State=false) then //jeśli wyłączony // begin // SetFlag(SoundFlag,sound_relay); //hunter-091012: przeniesione do Train.cpp, zeby sie // nie zapetlal @@ -2638,8 +2635,8 @@ bool TMoverParameters::IncBrakeLevelOld(void) (BrakePressureTable[BrakeCtrlPos - 1].PipePressureVal > 0)) LimPipePress = PipePress; - //ten kawałek jest bez sensu gdyż nic nie robił. Zakomntowałem. GF 20161124 - //if (BrakeSystem == ElectroPneumatic) + // ten kawałek jest bez sensu gdyż nic nie robił. Zakomntowałem. GF 20161124 + // if (BrakeSystem == ElectroPneumatic) // if (BrakeSubsystem != ss_K) // { // if ((BrakeCtrlPos * BrakeCtrlPos) == 1) @@ -2681,7 +2678,7 @@ bool TMoverParameters::DecBrakeLevelOld(void) { BrakeCtrlPos--; // BrakeCtrlPosR:=BrakeCtrlPos; - //if (EmergencyBrakeFlag) + // if (EmergencyBrakeFlag) //{ // EmergencyBrakeFlag = false; //!!! // SendCtrlToNext("Emergency_brake", 0, CabNo); @@ -2712,8 +2709,8 @@ bool TMoverParameters::DecBrakeLevelOld(void) // (BrakePressureTable[BrakeCtrlPos+1].PipePressureVal > 0)) // LimPipePress:=PipePress; - // to nic nie robi. Zakomentowałem. GF 20161124 - //if (BrakeSystem == ElectroPneumatic) + // to nic nie robi. Zakomentowałem. GF 20161124 + // if (BrakeSystem == ElectroPneumatic) // if (BrakeSubsystem != ss_K) // { // if ((BrakeCtrlPos * BrakeCtrlPos) == 1) @@ -2949,7 +2946,7 @@ bool TMoverParameters::AntiSlippingBrake(void) // ************************************************************************************************* bool TMoverParameters::BrakeReleaser(int state) { - bool OK = true; //false tylko jeśli nie uda się wysłać, GF 20161124 + bool OK = true; // false tylko jeśli nie uda się wysłać, GF 20161124 Hamulec->Releaser(state); if (CabNo != 0) // rekurencyjne wysłanie do następnego OK = SendCtrlToNext("BrakeReleaser", state, CabNo); @@ -3047,17 +3044,17 @@ bool TMoverParameters::BrakeDelaySwitch(int BDS) { bool rBDS; // if (BrakeCtrlPosNo > 0) - if (BrakeHandle == MHZ_EN57) - { - if ((BDS != BrakeOpModeFlag) && ((BDS & BrakeOpModes) > 0)) - { - BrakeOpModeFlag = BDS; - rBDS = true; - } - else - rBDS = false; - } - else if (Hamulec->SetBDF(BDS)) + if (BrakeHandle == MHZ_EN57) + { + if ((BDS != BrakeOpModeFlag) && ((BDS & BrakeOpModes) > 0)) + { + BrakeOpModeFlag = BDS; + rBDS = true; + } + else + rBDS = false; + } + else if (Hamulec->SetBDF(BDS)) { BrakeDelayFlag = BDS; rBDS = true; @@ -3124,8 +3121,8 @@ bool TMoverParameters::DecBrakeMult(void) // ************************************************************************************************* void TMoverParameters::UpdateBrakePressure(double dt) { - //const double LBDelay = 5.0; // stala czasowa hamulca - //double Rate, Speed, dp, sm; + // const double LBDelay = 5.0; // stala czasowa hamulca + // double Rate, Speed, dp, sm; dpLocalValve = 0; dpBrake = 0; @@ -3156,10 +3153,11 @@ void TMoverParameters::CompressorCheck(double dt) (DElist[MainCtrlPos].RPM / DElist[MainCtrlPosNo].RPM); else { - CompressedVolume += - dt * CompressorSpeed * (2.0 * MaxCompressor - Compressor) / MaxCompressor; - TotalCurrent += 0.0015 - * Voltage; // tymczasowo tylko obciążenie sprężarki, tak z 5A na sprężarkę + CompressedVolume += dt * CompressorSpeed * + (2.0 * MaxCompressor - Compressor) / MaxCompressor; + TotalCurrent += + 0.0015 * + Voltage; // tymczasowo tylko obciążenie sprężarki, tak z 5A na sprężarkę } else { @@ -3192,8 +3190,8 @@ void TMoverParameters::CompressorCheck(double dt) CompressorFlag = false; // bez tamtego członu nie zadziała } else - CompressorFlag = (CompressorAllow) && - ((ConverterFlag) || (CompressorPower == 0)) && (Mains); + CompressorFlag = + (CompressorAllow) && ((ConverterFlag) || (CompressorPower == 0)) && (Mains); if (Compressor > MaxCompressor) // wyłącznik ciśnieniowy jest niezależny od sposobu zasilania CompressorFlag = false; @@ -3221,8 +3219,8 @@ void TMoverParameters::CompressorCheck(double dt) CompressorFlag = false; // bez tamtego członu nie zadziała } else - CompressorFlag = (CompressorAllow) && - ((ConverterFlag) || (CompressorPower == 0)) && (Mains); + CompressorFlag = + (CompressorAllow) && ((ConverterFlag) || (CompressorPower == 0)) && (Mains); if (CompressorFlag) // jeśli została załączona LastSwitchingTime = 0; // to trzeba ograniczyć ponowne włączenie } @@ -3242,15 +3240,16 @@ void TMoverParameters::CompressorCheck(double dt) if ((CompressorPower == 5) && (Couplers[1].Connected != NULL)) Couplers[1].Connected->TotalCurrent += 0.0015 * Couplers[1].Connected->Voltage; // tymczasowo tylko obciążenie - // sprężarki, tak z 5A na - // sprężarkę + // sprężarki, tak z 5A na + // sprężarkę else if ((CompressorPower == 4) && (Couplers[0].Connected != NULL)) Couplers[0].Connected->TotalCurrent += 0.0015 * Couplers[0].Connected->Voltage; // tymczasowo tylko obciążenie - // sprężarki, tak z 5A na - // sprężarkę + // sprężarki, tak z 5A na + // sprężarkę else - TotalCurrent += 0.0015 * + TotalCurrent += + 0.0015 * Voltage; // tymczasowo tylko obciążenie sprężarki, tak z 5A na sprężarkę } } @@ -3279,9 +3278,8 @@ void TMoverParameters::UpdatePipePressure(double dt) // with BrakePressureTable[BrakeCtrlPos] do { if ((EngineType != ElectricInductionMotor)) - dpLocalValve = - LocHandle->GetPF(Max0R(LocalBrakePos / LocalBrakePosNo, LocalBrakePosA), - Hamulec->GetBCP(), ScndPipePress, dt, 0); + dpLocalValve = LocHandle->GetPF(Max0R(LocalBrakePos / LocalBrakePosNo, LocalBrakePosA), + Hamulec->GetBCP(), ScndPipePress, dt, 0); else dpLocalValve = LocHandle->GetPF(LocalBrakePosA, Hamulec->GetBCP(), ScndPipePress, dt, 0); @@ -3293,14 +3291,14 @@ void TMoverParameters::UpdatePipePressure(double dt) temp = ScndPipePress; Handle->SetReductor(BrakeCtrlPos2); - if ((BrakeOpModeFlag != bom_PS)) - if ((BrakeOpModeFlag < bom_EP) || ((Handle->GetPos(bh_EB) - 0.5) < BrakeCtrlPosR) || - (BrakeHandle != MHZ_EN57)) - dpMainValve = Handle->GetPF(BrakeCtrlPosR, PipePress, temp, dt, EqvtPipePress); - else - dpMainValve = Handle->GetPF(0, PipePress, temp, dt, EqvtPipePress); - - if (dpMainValve < 0) // && (PipePressureVal > 0.01) //50 + if ((BrakeOpModeFlag != bom_PS)) + if ((BrakeOpModeFlag < bom_EP) || ((Handle->GetPos(bh_EB) - 0.5) < BrakeCtrlPosR) || + (BrakeHandle != MHZ_EN57)) + dpMainValve = Handle->GetPF(BrakeCtrlPosR, PipePress, temp, dt, EqvtPipePress); + else + dpMainValve = Handle->GetPF(0, PipePress, temp, dt, EqvtPipePress); + + if (dpMainValve < 0) // && (PipePressureVal > 0.01) //50 if (Compressor > ScndPipePress) { CompressedVolume = CompressedVolume + dpMainValve / 1500.0; @@ -3312,9 +3310,8 @@ void TMoverParameters::UpdatePipePressure(double dt) // if(EmergencyBrakeFlag)and(BrakeCtrlPosNo=0)then //ulepszony hamulec bezp. if ((EmergencyBrakeFlag) || (TestFlag(SecuritySystem.Status, s_SHPebrake)) || - (TestFlag(SecuritySystem.Status, s_CAebrake)) || - (s_CAtestebrake == true) || - (TestFlag(EngDmgFlag, 32)) /* or (not Battery)*/) // ulepszony hamulec bezp. + (TestFlag(SecuritySystem.Status, s_CAebrake)) || (s_CAtestebrake == true) || + (TestFlag(EngDmgFlag, 32)) /* or (not Battery)*/) // ulepszony hamulec bezp. dpMainValve = dpMainValve + PF(0, PipePress, 0.15) * dt; // 0.2*Spg Pipe->Flow(-dpMainValve); @@ -3356,12 +3353,12 @@ void TMoverParameters::UpdatePipePressure(double dt) for (int b = 0; b < 2; b++) if (((TrainType & (dt_ET41 | dt_ET42)) != 0) && (Couplers[b].Connected != NULL)) // nie podoba mi się to rozwiązanie, chyba trzeba - // dodać jakiś wpis do fizyki na to + // dodać jakiś wpis do fizyki na to if (((Couplers[b].Connected->TrainType & (dt_ET41 | dt_ET42)) != 0) && ((Couplers[b].CouplingFlag & 36) == 36)) LocBrakePress = Max0R(Couplers[b].Connected->LocHandle->GetCP(), LocBrakePress); - //if ((DynamicBrakeFlag) && (EngineType == ElectricInductionMotor)) + // if ((DynamicBrakeFlag) && (EngineType == ElectricInductionMotor)) //{ // //if (Vel > 10) // // LocBrakePress = 0; @@ -3371,12 +3368,12 @@ void TMoverParameters::UpdatePipePressure(double dt) //(Hamulec as TLSt).SetLBP(LocBrakePress); Hamulec->SetLBP(LocBrakePress); - if ((BrakeValve == EStED)) - if (MBPM < 2) - Hamulec->PLC(MaxBrakePress[LoadFlag]); - else - Hamulec->PLC(TotalMass); - break; + if ((BrakeValve == EStED)) + if (MBPM < 2) + Hamulec->PLC(MaxBrakePress[LoadFlag]); + else + Hamulec->PLC(TotalMass); + break; } case CV1_L_TR: @@ -3388,10 +3385,10 @@ void TMoverParameters::UpdatePipePressure(double dt) } case EP2: - { - Hamulec->PLC(TotalMass); - break; - } + { + Hamulec->PLC(TotalMass); + break; + } case ESt3AL2: case NESt3: case ESt4: @@ -3562,11 +3559,12 @@ double TMoverParameters::GetDVc(double dt) c->Physic_ReActivation(); c->Pipe->Flow(-dv2); } - //if ((Couplers[1].Connected != NULL) && (Couplers[0].Connected != NULL)) + // if ((Couplers[1].Connected != NULL) && (Couplers[0].Connected != NULL)) // if ((TestFlag(Couplers[0].CouplingFlag, ctrain_pneumatic)) && // (TestFlag(Couplers[1].CouplingFlag, ctrain_pneumatic))) // { - // dV = 0.05 * dt * PF(Couplers[0].Connected->PipePress, Couplers[1].Connected->PipePress, + // dV = 0.05 * dt * PF(Couplers[0].Connected->PipePress, + // Couplers[1].Connected->PipePress, // (Spg * 0.85) / (1 + 0.03 * Dim.L)) * // 0; // ktoś mi powie jaki jest sens tego bloku jeśli przepływ mnożony przez zero? // Couplers[0].Connected->Pipe->Flow(+dV); @@ -3629,7 +3627,7 @@ void TMoverParameters::ComputeConstans(void) double TMoverParameters::ComputeMass(void) { double M; - LoadType = ToLower(LoadType); // po co zakładać jak można mieć na pewno + LoadType = ToLower(LoadType); // po co zakładać jak można mieć na pewno if (Load > 0) { // zakładamy, że ładunek jest pisany małymi literami if (ToLower(LoadQuantity) == "tonns") @@ -3687,21 +3685,21 @@ void TMoverParameters::ComputeTotalForce(double dt, double dt1, bool FullVer) if (Mains && /*(abs(CabNo) < 2) &&*/ (EngineType == ElectricSeriesMotor)) // potem ulepszyc! pantogtrafy! { // Ra 2014-03: uwzględnienie kierunku jazdy w napięciu na silnikach, a powinien być - // zdefiniowany nawrotnik + // zdefiniowany nawrotnik if (CabNo == 0) Voltage = RunningTraction.TractionVoltage * ActiveDir; else Voltage = RunningTraction.TractionVoltage * DirAbsolute; // ActiveDir*CabNo; } // bo nie dzialalo - else if ((EngineType == ElectricInductionMotor) || - (((Couplers[0].CouplingFlag & ctrain_power) == ctrain_power) || - ((Couplers[1].CouplingFlag & ctrain_power) == - ctrain_power))) // potem ulepszyc! pantogtrafy! - Voltage = - Max0R(Max0R(RunningTraction.TractionVoltage, HVCouplers[0][1]), HVCouplers[1][1]); - else + else if ((EngineType == ElectricInductionMotor) || + (((Couplers[0].CouplingFlag & ctrain_power) == ctrain_power) || + ((Couplers[1].CouplingFlag & ctrain_power) == + ctrain_power))) // potem ulepszyc! pantogtrafy! + Voltage = + Max0R(Max0R(RunningTraction.TractionVoltage, HVCouplers[0][1]), HVCouplers[1][1]); + else Voltage = 0; - //if (Mains && /*(abs(CabNo) < 2) &&*/ ( + // if (Mains && /*(abs(CabNo) < 2) &&*/ ( // EngineType == ElectricInductionMotor)) // potem ulepszyc! pantogtrafy! // Voltage = RunningTraction.TractionVoltage; @@ -3734,9 +3732,8 @@ void TMoverParameters::ComputeTotalForce(double dt, double dt1, bool FullVer) Couplers[b].CForce = 0; // FStand:=Fb+FrictionForce(RunningShape.R,RunningTrack.DamageFlag); FStand += Fb; - FTrain += - TotalMassxg * RunningShape.dHtrack; // doliczenie składowej stycznej grawitacji - //!niejawne przypisanie zmiennej! + FTrain += TotalMassxg * RunningShape.dHtrack; // doliczenie składowej stycznej grawitacji + //! niejawne przypisanie zmiennej! FTotal = FTrain - Sign(V) * FStand; } @@ -3783,13 +3780,13 @@ double TMoverParameters::BrakeForce(const TTrackParam &Track) { case NoBrake: K = 0; - break; + break; case ManualBrake: K = MaxBrakeForce * ManualBrakeRatio(); - break; + break; case HydraulicBrake: K = MaxBrakeForce * LocalBrakeRatio(); - break; + break; case PneumaticBrake: if (Compressor < MaxBrakePress[3]) K = MaxBrakeForce * LocalBrakeRatio() / 2.0; @@ -4110,7 +4107,7 @@ double TMoverParameters::TractionForce(double dt) else dtrans = Transmision.Ratio * MotorParam[ScndCtrlActualPos].mIsat; dmoment = dizel_Momentum(dizel_fill, dtrans * nrot * ActiveDir, dt); // oblicza tez - // enrot + // enrot } eAngle += enrot * dt; @@ -4226,19 +4223,19 @@ double TMoverParameters::TractionForce(double dt) (RList[MainCtrlActualPos].Bn + 1); // zrobione w momencie, żeby nie dawac elektryki w przeliczaniu sił - if (abs(Im) > Imax) - Vhyp += dt; //*(abs(Im) / Imax - 0.9) * 10; // zwieksz czas oddzialywania na PN + if (abs(Im) > Imax) + Vhyp += dt; //*(abs(Im) / Imax - 0.9) * 10; // zwieksz czas oddzialywania na PN else Vhyp = 0; if (Vhyp > CtrlDelay / 2) // jesli czas oddzialywania przekroczony FuseOff(); // wywalanie bezpiecznika z powodu przetezenia silnikow - if ((Mains)) // nie wchodzić w funkcję bez potrzeby - if ((abs(Voltage) < EnginePowerSource.CollectorParameters.MinV) || - (abs(Voltage) * EnginePowerSource.CollectorParameters.OVP > - EnginePowerSource.CollectorParameters.MaxV)) - if (MainSwitch(false)) - EventFlag = true; // wywalanie szybkiego z powodu niewłaściwego napięcia + if ((Mains)) // nie wchodzić w funkcję bez potrzeby + if ((abs(Voltage) < EnginePowerSource.CollectorParameters.MinV) || + (abs(Voltage) * EnginePowerSource.CollectorParameters.OVP > + EnginePowerSource.CollectorParameters.MaxV)) + if (MainSwitch(false)) + EventFlag = true; // wywalanie szybkiego z powodu niewłaściwego napięcia if (((DynamicBrakeType == dbrake_automatic) || (DynamicBrakeType == dbrake_switch)) && (DynamicBrakeFlag)) @@ -4466,7 +4463,7 @@ double TMoverParameters::TractionForce(double dt) ScndCtrlPos = 0; } } // switch RelayType - break; + break; } // DieselElectric case ElectricInductionMotor: @@ -4488,7 +4485,8 @@ double TMoverParameters::TractionForce(double dt) else if (((dtrans < 0.25) && (LocHandle->GetCP() < 0.25) && (AnPos < 0.01)) || ((dtrans < 0.25) && (ShuntModeAllow) && (LocalBrakePos == 0))) DynamicBrakeFlag = false; - else if ((((BrakePress > 0.25) && (dtrans > 0.25) || (LocHandle->GetCP() > 0.25))) || + else if ((((BrakePress > 0.25) && (dtrans > 0.25) || + (LocHandle->GetCP() > 0.25))) || (AnPos > 0.02)) DynamicBrakeFlag = true; dtrans = Hamulec->GetEDBCP() * eimc[eimc_p_abed]; // stala napedu @@ -4510,8 +4508,9 @@ double TMoverParameters::TractionForce(double dt) Hamulec->SetED(Max0R(0.0, Min0R(PosRatio, 1))); // (Hamulec as TLSt).SetLBP(LocBrakePress*(1-PosRatio)); PosRatio = -Max0R(Min0R(dtrans * 1.0 / MaxBrakePress[0], 1), AnPos) * - Max0R(0, Min0R(1, (Vel - eimc[eimc_p_Vh0]) / - (eimc[eimc_p_Vh1] - eimc[eimc_p_Vh0]))); + Max0R(0, Min0R(1, + (Vel - eimc[eimc_p_Vh0]) / + (eimc[eimc_p_Vh1] - eimc[eimc_p_Vh0]))); eimv[eimv_Fzad] = -Max0R(LocalBrakeRatio(), dtrans / MaxBrakePress[0]); tmp = 5; } @@ -4527,7 +4526,8 @@ double TMoverParameters::TractionForce(double dt) else PosRatio = Min0R(PosRatio, Max0R(-1, 0.5 * (ScndCtrlActualPos * 2 - Vel))); - // PosRatio = 1.0 * (PosRatio * 0 + 1) * PosRatio; // 1 * 1 * PosRatio = PosRatio + // PosRatio = 1.0 * (PosRatio * 0 + 1) * PosRatio; // 1 * 1 * PosRatio = + // PosRatio Hamulec->SetED(0); // (Hamulec as TLSt).SetLBP(LocBrakePress); if ((PosRatio > dizel_fill)) @@ -4559,14 +4559,14 @@ double TMoverParameters::TractionForce(double dt) if ((SlippingWheels)) { // PosRatio = -PosRatio * 0; // serio -0 ??? - PosRatio = 0; + PosRatio = 0; tmp = 9; SandDoseOn(); } // przeciwposlizg dizel_fill += Max0R(Min0R(PosRatio - dizel_fill, 0.1), -0.1) * 2 * - (tmp /*2{+4*byte(PosRatioSetED(0); RventRot = 0.0; //(Hamulec as TLSt).SetLBP(LocBrakePress); } - break; + break; } // ElectricInductionMotor case None: { @@ -4697,7 +4694,7 @@ double TMoverParameters::TractionForce(double dt) // ************************************************************************************************* // Q: 20160713 -//Obliczenie predkości obrotowej kół??? +// Obliczenie predkości obrotowej kół??? // ************************************************************************************************* double TMoverParameters::ComputeRotatingWheel(double WForce, double dt, double n) { @@ -4916,13 +4913,13 @@ bool TMoverParameters::ResistorsFlagCheck(void) if (Power > 0.01) RFC = ResistorsFlag; - else // pobor pradu jezeli niema mocy - { - for (int b = 0; b < 2; b++) - if (TestFlag(Couplers[b].CouplingFlag, ctrain_controll)) - if (Couplers[b].Connected->Power > 0.01) - RFC = Couplers[b].Connected->ResistorsFlagCheck(); - } + else // pobor pradu jezeli niema mocy + { + for (int b = 0; b < 2; b++) + if (TestFlag(Couplers[b].CouplingFlag, ctrain_controll)) + if (Couplers[b].Connected->Power > 0.01) + RFC = Couplers[b].Connected->ResistorsFlagCheck(); + } return RFC; } @@ -4974,10 +4971,10 @@ bool TMoverParameters::AutoRelayCheck(void) } ARFASI2 = (!AutoRelayFlag) || ((MotorParam[ScndCtrlActualPos].AutoSwitch) && - (abs(Im) < Imin)); // wszystkie warunki w jednym + (abs(Im) < Imin)); // wszystkie warunki w jednym ARFASI = (!AutoRelayFlag) || ((RList[MainCtrlActualPos].AutoSwitch) && (abs(Im) < Imin)) || - ((!RList[MainCtrlActualPos].AutoSwitch) && - (RList[MainCtrlActualPos].Relay < MainCtrlPos)); // wszystkie warunki w jednym + ((!RList[MainCtrlActualPos].AutoSwitch) && + (RList[MainCtrlActualPos].Relay < MainCtrlPos)); // wszystkie warunki w jednym // brak PSR na tej pozycji działa PSR i prąd poniżej progu // na tej pozycji nie działa PSR i pozycja walu ponizej // chodzi w tym wszystkim o to, żeby można było zatrzymać rozruch na @@ -5374,10 +5371,10 @@ bool TMoverParameters::dizel_AutoGearCheck(void) { case 1: dizel_EngageSwitch(0.5); - break; + break; case 2: dizel_EngageSwitch(1.0); - break; + break; default: dizel_EngageSwitch(0.0); } @@ -5422,7 +5419,7 @@ bool TMoverParameters::dizel_Update(double dt) // oblicza napelnienie, uzwglednia regulator obrotow // ************************************************************************************************* double TMoverParameters::dizel_fillcheck(int mcp) -{ +{ double realfill, nreg; realfill = 0; @@ -5441,13 +5438,13 @@ double TMoverParameters::dizel_fillcheck(int mcp) case 0: case 1: nreg = dizel_nmin; - break; + break; case 2: if (dizel_automaticgearstatus == 0) nreg = dizel_nmax; else nreg = dizel_nmin; - break; + break; default: realfill = 0; // sluczaj } @@ -5488,13 +5485,13 @@ double TMoverParameters::dizel_Momentum(double dizel_fill, double n, double dt) Moment = -dizel_Mstand; if (enrot < dizel_nmin / 10.0) if (eAngle < PI / 2.0) - Moment -= dizel_Mstand; // wstrzymywanie przy malych obrotach + Moment -= dizel_Mstand; // wstrzymywanie przy malych obrotach //!! abs if (abs(abs(n) - enrot) < 0.1) { if ((Moment) > (dizel_engageMaxForce * dizel_engage * dizel_engageDia * friction * 2)) // zerwanie przyczepnosci sprzegla - enrot += dt * Moment / dizel_AIM; + enrot += dt * Moment / dizel_AIM; else { dizel_engagedeltaomega = 0; @@ -5742,8 +5739,8 @@ std::string TMoverParameters::EngineDescription(int what) // Funkcja zwracajaca napiecie dla calego skladu, przydatna dla EZT // ************************************************************************************************* double TMoverParameters::GetTrainsetVoltage(void) -{//ABu: funkcja zwracajaca napiecie dla calego skladu, przydatna dla EZT - return Max0R(HVCouplers[1][1], HVCouplers[0][1]); +{ // ABu: funkcja zwracajaca napiecie dla calego skladu, przydatna dla EZT + return Max0R(HVCouplers[1][1], HVCouplers[0][1]); } // ************************************************************************************************* @@ -5854,7 +5851,7 @@ std::string tS(std::string val) int Pos(std::string str_find, std::string in) { size_t pos = in.find(str_find); - return (pos != string::npos ? pos+1 : 0); + return (pos != string::npos ? pos + 1 : 0); } // ************************************************************************************************* @@ -5921,28 +5918,28 @@ int MARKERROR(int code, std::string type, std::string msg) int s2NPW(string s) { // wylicza ilosc osi napednych z opisu ukladu osi - const char A = 64; - int k; - int NPW = 0; - for (k = 0; k < s.length(); k++) - { - if (s[k] >= (char)65 && s[k] <= (char)90) - NPW += s[k] - A; - } - return NPW; + const char A = 64; + int k; + int NPW = 0; + for (k = 0; k < s.length(); k++) + { + if (s[k] >= (char)65 && s[k] <= (char)90) + NPW += s[k] - A; + } + return NPW; } int s2NNW(string s) { // wylicza ilosc osi nienapedzanych z opisu ukladu osi - const char Zero = 48; - int k; - int NNW = 0; - for (k = 0; k < s.length(); k++) - { - if (s[k] >= (char)49 && s[k] <= (char)57) - NNW += s[k] - Zero; - } - return NNW; + const char Zero = 48; + int k; + int NNW = 0; + for (k = 0; k < s.length(); k++) + { + if (s[k] >= (char)49 && s[k] <= (char)57) + NNW += s[k] - Zero; + } + return NNW; } // ************************************************************************************************* @@ -5962,14 +5959,14 @@ bool TMoverParameters::readMPT(int ln, std::string line) x = Split(line); int s = x.size(); - if ( s < 7 && s > 8) - { - WriteLog("Read MPT: wrong argument number of arguments in line " + to_string(ln -1)); + if (s < 7 && s > 8) + { + WriteLog("Read MPT: wrong argument number of arguments in line " + to_string(ln - 1)); MPTLINE++; - return false; - } + return false; + } - for(int i = 0; i < s; i++) + for (int i = 0; i < s; i++) x[i] = TrimSpace(x[i]); bl = atoi(x[0].c_str()); // numer pozycji @@ -5980,10 +5977,10 @@ bool TMoverParameters::readMPT(int ln, std::string line) MotorParam[bl].fi = atof(x[4].c_str()); MotorParam[bl].Isat = atof(x[5].c_str()); MotorParam[bl].fi0 = atof(x[6].c_str()); - MotorParam[bl].AutoSwitch = s == 8 ? atoi(x[7].c_str()): false; + MotorParam[bl].AutoSwitch = s == 8 ? atoi(x[7].c_str()) : false; //--WriteLog(":::: " + p0 + "," + p1 + "," + p2 + "," + p3 + "," + p4 + "," + p5 + "," + - //p6); + // p6); } MPTLINE++; return true; @@ -6004,15 +6001,15 @@ bool TMoverParameters::readRLIST(int ln, std::string line) line = Tab2Sp(line); // zamieniamy taby na spacje (ile tabow tyle spacji bedzie) xxx = TrimAndReduceSpaces(line.c_str()); // konwertujemy na *char i - // ograniczamy spacje pomiedzy - // parametrami do jednej + // ograniczamy spacje pomiedzy + // parametrami do jednej x = Split(xxx); // split je wskaznik na char jak i std::string int s = x.size(); - if ( s < 5 && s > 6) + if (s < 5 && s > 6) { - WriteLog("Read RLIST: wrong argument number of arguments in line " + to_string(ln - 1)); + WriteLog("Read RLIST: wrong argument number of arguments in line " + to_string(ln - 1)); delete[] xxx; RLISTLINE++; return false; @@ -6032,10 +6029,10 @@ bool TMoverParameters::readRLIST(int ln, std::string line) RList[k].Bn = atoi(x[2].c_str()); // int RList[k].Mn = atoi(x[3].c_str()); // int RList[k].AutoSwitch = (bool)atoi(x[4].c_str()); // p4.ToInt(); - RList[k].ScndAct = s == 6 ? atoi(x[5].c_str()) : 0; //jeśli ma boczniki w nastawniku + RList[k].ScndAct = s == 6 ? atoi(x[5].c_str()) : 0; // jeśli ma boczniki w nastawniku //--WriteLog("RLIST: " + p0 + "," + p1 + "," + p2 + "," + p3 + "," + p4); } - delete[] xxx; + delete[] xxx; RLISTLINE++; return true; } @@ -6080,7 +6077,8 @@ bool TMoverParameters::readBPT(int ln, std::string line) BrakePressureTable[k].BrakeType = Individual; // WriteLog("BPTx: " + p0 + "," + p1 + "," + p2 + "," + p3 + "," + p4); - //WriteLog("BPTk: " + to_string(k) + "," + to_string(BrakePressureTable[k].PipePressureVal) + + // WriteLog("BPTk: " + to_string(k) + "," + to_string(BrakePressureTable[k].PipePressureVal) + // + // "," + to_string(BrakePressureTable[k].BrakePressureVal) + "," + // to_string(BrakePressureTable[k].FlowSpeedVal) + "," + p4); @@ -6147,28 +6145,28 @@ void TMoverParameters::BrakeSubsystemDecode() BrakeSubsystem = ss_None; switch (BrakeValve) { - case W: - case W_Lu_L: - case W_Lu_VI: - case W_Lu_XR: + case W: + case W_Lu_L: + case W_Lu_VI: + case W_Lu_XR: BrakeSubsystem = ss_W; break; - case ESt3: - case ESt3AL2: - case ESt4: - case EP2: - case EP1: + case ESt3: + case ESt3AL2: + case ESt4: + case EP2: + case EP1: BrakeSubsystem = ss_ESt; break; case KE: BrakeSubsystem = ss_KE; break; - case CV1: - case CV1_L_TR: + case CV1: + case CV1_L_TR: BrakeSubsystem = ss_Dako; break; - case LSt: - case EStED: + case LSt: + case EStED: BrakeSubsystem = ss_LSt; break; } @@ -6258,11 +6256,11 @@ void TMoverParameters::PowerParamDecode(std::string lines, std::string prefix, { //--case NotDefined : PowerType = PowerDecode(DUE(ExtractKeyWord(lines,prefix+'PowerType='))); //--case InternalSource : PowerType = - //PowerDecode(DUE(ExtractKeyWord(lines,prefix+'PowerType='))); + // PowerDecode(DUE(ExtractKeyWord(lines,prefix+'PowerType='))); //--case Transducer : InputVoltage = - //s2rE(DUE(ExtractKeyWord(lines,prefix+'TransducerInputV='))); + // s2rE(DUE(ExtractKeyWord(lines,prefix+'TransducerInputV='))); //--case Generator : - //GeneratorEngine:=EngineDecode(DUE(ExtractKeyWord(lines,prefix+'GeneratorEngine='))); + // GeneratorEngine:=EngineDecode(DUE(ExtractKeyWord(lines,prefix+'GeneratorEngine='))); //--case Accumulator: //--{ //-- RAccumulator.MaxCapacity:=s2r(DUE(ExtractKeyWord(lines,prefix+'Cap='))); @@ -6294,7 +6292,7 @@ void TMoverParameters::PowerParamDecode(std::string lines, std::string prefix, // s:=ExtractKeyWord(lines,'MinPress='); //ciśnienie rozłączające WS if (jMinPress == 0) PowerParamDecode.CollectorParameters.MinPress = 2.0; // domyślnie 2 bary do załączenia - // WS + // WS else PowerParamDecode.CollectorParameters.MinPress = (jMinPress); // s:=ExtractKeyWord(lines,'MaxPress='); //maksymalne ciśnienie za reduktorem @@ -6363,17 +6361,17 @@ bool TMoverParameters::LoadFIZ(std::string chkpath) // appdir = ExtractFilePath(ParamStr(0)); ifstream in(file.c_str()); - if (!in.is_open()) - { - WriteLog("E8 - FIZ FILE NOT EXIST."); - return false; - } + if (!in.is_open()) + { + WriteLog("E8 - FIZ FILE NOT EXIST."); + return false; + } bool secBPT = false, secMotorParamTable0 = false, secPower = false, secEngine = false, - secParam = false, secLoad = false, secDimensions = false, - secWheels = false, secBrake = false, secBuffCoupl = false, secCntrl = false, - secSecurity = false, secLight = false, secCircuit = false, secRList = false, - secDList = false, secWWList = false, secffList = false, secTurboPos = false; + secParam = false, secLoad = false, secDimensions = false, secWheels = false, + secBrake = false, secBuffCoupl = false, secCntrl = false, secSecurity = false, + secLight = false, secCircuit = false, secRList = false, secDList = false, + secWWList = false, secffList = false, secTurboPos = false; ConversionError = 0; @@ -6819,7 +6817,7 @@ bool TMoverParameters::LoadFIZ(std::string chkpath) BrakeCylMult[1] = eBCMlo; BrakeCylMult[2] = eBCMhi; P2FTrans = 100.0 * PI * sqr(BrakeCylRadius); // w kN/bar Q: zamieniam SQR() na - // sqr() + // sqr() if ((BrakeCylMult[1] > 0) || (MaxBrakePress[1] > 0)) LoadFlag = 1; else @@ -7283,7 +7281,7 @@ bool TMoverParameters::LoadFIZ(std::string chkpath) // WriteLog("----------------------------------------------------------------------------------------"); WriteLog("CERROR: " + to_string(ConversionError) + ", SUCCES: " + to_string(OK)); // WriteLogSS(); - //WriteLog(""); + // WriteLog(""); return OK; } // LoadFIZ() @@ -7293,285 +7291,285 @@ bool TMoverParameters::LoadFIZ(std::string chkpath) bool TMoverParameters::CheckLocomotiveParameters(bool ReadyFlag, int Dir) { - WriteLog("check locomotive parameters..."); - int b; - bool OK = true; + WriteLog("check locomotive parameters..."); + int b; + bool OK = true; - AutoRelayFlag = (AutoRelayType == 1); + AutoRelayFlag = (AutoRelayType == 1); - Sand = SandCapacity; + Sand = SandCapacity; - // WriteLog("aa = " + AxleArangement + " " + std::string( Pos("o", AxleArangement)) ); + // WriteLog("aa = " + AxleArangement + " " + std::string( Pos("o", AxleArangement)) ); - if ((Pos("o", AxleArangement) > 0) && (EngineType == ElectricSeriesMotor)) - OK = ((RList[1].Bn * RList[1].Mn) == - NPoweredAxles); // test poprawnosci ilosci osi indywidualnie napedzanych - // WriteLogSS("aa ok", BoolToYN(OK)); + if ((Pos("o", AxleArangement) > 0) && (EngineType == ElectricSeriesMotor)) + OK = ((RList[1].Bn * RList[1].Mn) == + NPoweredAxles); // test poprawnosci ilosci osi indywidualnie napedzanych + // WriteLogSS("aa ok", BoolToYN(OK)); - if (BrakeSystem == Individual) - if (BrakeSubsystem != ss_None) - OK = false; //! + if (BrakeSystem == Individual) + if (BrakeSubsystem != ss_None) + OK = false; //! - if ((BrakeVVolume == 0) && (MaxBrakePress[3] > 0) && (BrakeSystem != Individual)) - BrakeVVolume = MaxBrakePress[3] / (5.0 - MaxBrakePress[3]) * - (BrakeCylRadius * BrakeCylRadius * BrakeCylDist * BrakeCylNo * PI) * 1000; - if (BrakeVVolume == 0) - BrakeVVolume = 0.01; + if ((BrakeVVolume == 0) && (MaxBrakePress[3] > 0) && (BrakeSystem != Individual)) + BrakeVVolume = MaxBrakePress[3] / (5.0 - MaxBrakePress[3]) * + (BrakeCylRadius * BrakeCylRadius * BrakeCylDist * BrakeCylNo * PI) * 1000; + if (BrakeVVolume == 0) + BrakeVVolume = 0.01; - // WriteLog("BVV = " + FloatToStr(BrakeVVolume)); + // WriteLog("BVV = " + FloatToStr(BrakeVVolume)); - if ((TestFlag(BrakeDelays, bdelay_G)) && - ((!TestFlag(BrakeDelays, bdelay_R)) || - (Power > 1))) // ustalanie srednicy przewodu glownego (lokomotywa lub napędowy - Spg = 0.792; - else - Spg = 0.507; + if ((TestFlag(BrakeDelays, bdelay_G)) && + ((!TestFlag(BrakeDelays, bdelay_R)) || + (Power > 1))) // ustalanie srednicy przewodu glownego (lokomotywa lub napędowy + Spg = 0.792; + else + Spg = 0.507; - // taki mini automat - powinno byc ladnie dobrze :) - BrakeDelayFlag = bdelay_P; - if ((TestFlag(BrakeDelays, bdelay_G)) && !(TestFlag(BrakeDelays, bdelay_R))) - BrakeDelayFlag = bdelay_G; - if ((TestFlag(BrakeDelays, bdelay_R)) && !(TestFlag(BrakeDelays, bdelay_G))) - BrakeDelayFlag = bdelay_R; + // taki mini automat - powinno byc ladnie dobrze :) + BrakeDelayFlag = bdelay_P; + if ((TestFlag(BrakeDelays, bdelay_G)) && !(TestFlag(BrakeDelays, bdelay_R))) + BrakeDelayFlag = bdelay_G; + if ((TestFlag(BrakeDelays, bdelay_R)) && !(TestFlag(BrakeDelays, bdelay_G))) + BrakeDelayFlag = bdelay_R; - int DefBrakeTable[8] = { 15, 4, 25, 25, 13, 3, 12, 2 }; + int DefBrakeTable[8] = {15, 4, 25, 25, 13, 3, 12, 2}; - if (LoadFlag > 0) - { - if (Load < MaxLoad * 0.45) - { - IncBrakeMult(); - IncBrakeMult(); - DecBrakeMult(); // TODO: przeinesiono do mover.cpp - if (Load < MaxLoad * 0.35) - DecBrakeMult(); - } - if (Load >= MaxLoad * 0.45) - { - IncBrakeMult(); // TODO: przeinesiono do mover.cpp - if (Load >= MaxLoad * 0.55) - IncBrakeMult(); - } - } + if (LoadFlag > 0) + { + if (Load < MaxLoad * 0.45) + { + IncBrakeMult(); + IncBrakeMult(); + DecBrakeMult(); // TODO: przeinesiono do mover.cpp + if (Load < MaxLoad * 0.35) + DecBrakeMult(); + } + if (Load >= MaxLoad * 0.45) + { + IncBrakeMult(); // TODO: przeinesiono do mover.cpp + if (Load >= MaxLoad * 0.55) + IncBrakeMult(); + } + } - if (BrakeOpModes & bom_PS) - BrakeOpModeFlag = bom_PS; - else - BrakeOpModeFlag = bom_PN; + if (BrakeOpModes & bom_PS) + BrakeOpModeFlag = bom_PS; + else + BrakeOpModeFlag = bom_PN; - // yB: jesli pojazdy nie maja zadeklarowanych czasow, to wsadz z przepisow +-16,(6)% - for (b = 1; b < 4; b++) - { - if (BrakeDelay[b] == 0) - BrakeDelay[b] = DefBrakeTable[b]; - BrakeDelay[b] = BrakeDelay[b] * (2.5 + Random(0.0, 0.2)) / 3.0; - } + // yB: jesli pojazdy nie maja zadeklarowanych czasow, to wsadz z przepisow +-16,(6)% + for (b = 1; b < 4; b++) + { + if (BrakeDelay[b] == 0) + BrakeDelay[b] = DefBrakeTable[b]; + BrakeDelay[b] = BrakeDelay[b] * (2.5 + Random(0.0, 0.2)) / 3.0; + } - // WriteLog("SPG = " + FloatToStr(Spg)); + // WriteLog("SPG = " + FloatToStr(Spg)); - switch (BrakeValve) - { - case W: - case K: - { - WriteLog("XBT W, K"); - Hamulec = new TWest(MaxBrakePress[3], BrakeCylRadius, BrakeCylDist, BrakeVVolume, - BrakeCylNo, BrakeDelays, BrakeMethod, NAxles, NBpA); - if (MBPM < 2) // jesli przystawka wazaca - Hamulec->SetLP(0, MaxBrakePress[3], 0); - else - Hamulec->SetLP(Mass, MBPM, MaxBrakePress[1]); - break; - } - case KE: - { - WriteLog("XBT WKE"); - Hamulec = new TKE(MaxBrakePress[3], BrakeCylRadius, BrakeCylDist, BrakeVVolume, BrakeCylNo, - BrakeDelays, BrakeMethod, NAxles, NBpA); - Hamulec->SetRM(RapidMult); - if (MBPM < 2) // jesli przystawka wazaca - Hamulec->SetLP(0, MaxBrakePress[3], 0); - else - Hamulec->SetLP(Mass, MBPM, MaxBrakePress[1]); - break; - } - case NESt3: - case ESt3: - case ESt3AL2: - case ESt4: - { - WriteLog("XBT NESt3, ESt3, ESt3AL2, ESt4"); - Hamulec = new TNESt3(MaxBrakePress[3], BrakeCylRadius, BrakeCylDist, BrakeVVolume, - BrakeCylNo, BrakeDelays, BrakeMethod, NAxles, NBpA); - (static_cast(Hamulec))->SetSize(BrakeValveSize, BrakeValveParams); - if (MBPM < 2) // jesli przystawka wazaca - Hamulec->SetLP(0, MaxBrakePress[3], 0); - else - Hamulec->SetLP(Mass, MBPM, MaxBrakePress[1]); - break; - } + switch (BrakeValve) + { + case W: + case K: + { + WriteLog("XBT W, K"); + Hamulec = new TWest(MaxBrakePress[3], BrakeCylRadius, BrakeCylDist, BrakeVVolume, + BrakeCylNo, BrakeDelays, BrakeMethod, NAxles, NBpA); + if (MBPM < 2) // jesli przystawka wazaca + Hamulec->SetLP(0, MaxBrakePress[3], 0); + else + Hamulec->SetLP(Mass, MBPM, MaxBrakePress[1]); + break; + } + case KE: + { + WriteLog("XBT WKE"); + Hamulec = new TKE(MaxBrakePress[3], BrakeCylRadius, BrakeCylDist, BrakeVVolume, BrakeCylNo, + BrakeDelays, BrakeMethod, NAxles, NBpA); + Hamulec->SetRM(RapidMult); + if (MBPM < 2) // jesli przystawka wazaca + Hamulec->SetLP(0, MaxBrakePress[3], 0); + else + Hamulec->SetLP(Mass, MBPM, MaxBrakePress[1]); + break; + } + case NESt3: + case ESt3: + case ESt3AL2: + case ESt4: + { + WriteLog("XBT NESt3, ESt3, ESt3AL2, ESt4"); + Hamulec = new TNESt3(MaxBrakePress[3], BrakeCylRadius, BrakeCylDist, BrakeVVolume, + BrakeCylNo, BrakeDelays, BrakeMethod, NAxles, NBpA); + (static_cast(Hamulec))->SetSize(BrakeValveSize, BrakeValveParams); + if (MBPM < 2) // jesli przystawka wazaca + Hamulec->SetLP(0, MaxBrakePress[3], 0); + else + Hamulec->SetLP(Mass, MBPM, MaxBrakePress[1]); + break; + } - case LSt: - { - WriteLog("XBT LSt"); - Hamulec = new TLSt(MaxBrakePress[3], BrakeCylRadius, BrakeCylDist, BrakeVVolume, BrakeCylNo, - BrakeDelays, BrakeMethod, NAxles, NBpA); - Hamulec->SetRM(RapidMult); - break; - } - case EStED: - { - WriteLog("XBT EStED"); - Hamulec = new TEStED(MaxBrakePress[3], BrakeCylRadius, BrakeCylDist, BrakeVVolume, - BrakeCylNo, BrakeDelays, BrakeMethod, NAxles, NBpA); - Hamulec->SetRM(RapidMult); - break; - } - case EP2: - { - WriteLog("XBT EP2"); - Hamulec = new TEStEP2(MaxBrakePress[3], BrakeCylRadius, BrakeCylDist, BrakeVVolume, - BrakeCylNo, BrakeDelays, BrakeMethod, NAxles, NBpA); - Hamulec->SetLP(Mass, MBPM, MaxBrakePress[1]); - break; - } + case LSt: + { + WriteLog("XBT LSt"); + Hamulec = new TLSt(MaxBrakePress[3], BrakeCylRadius, BrakeCylDist, BrakeVVolume, BrakeCylNo, + BrakeDelays, BrakeMethod, NAxles, NBpA); + Hamulec->SetRM(RapidMult); + break; + } + case EStED: + { + WriteLog("XBT EStED"); + Hamulec = new TEStED(MaxBrakePress[3], BrakeCylRadius, BrakeCylDist, BrakeVVolume, + BrakeCylNo, BrakeDelays, BrakeMethod, NAxles, NBpA); + Hamulec->SetRM(RapidMult); + break; + } + case EP2: + { + WriteLog("XBT EP2"); + Hamulec = new TEStEP2(MaxBrakePress[3], BrakeCylRadius, BrakeCylDist, BrakeVVolume, + BrakeCylNo, BrakeDelays, BrakeMethod, NAxles, NBpA); + Hamulec->SetLP(Mass, MBPM, MaxBrakePress[1]); + break; + } - case CV1: - { - WriteLog("XBT CV1"); - Hamulec = new TCV1(MaxBrakePress[3], BrakeCylRadius, BrakeCylDist, BrakeVVolume, BrakeCylNo, - BrakeDelays, BrakeMethod, NAxles, NBpA); - break; - } - case CV1_L_TR: - { - WriteLog("XBT CV1_L_T"); - Hamulec = new TCV1L_TR(MaxBrakePress[3], BrakeCylRadius, BrakeCylDist, BrakeVVolume, - BrakeCylNo, BrakeDelays, BrakeMethod, NAxles, NBpA); - break; - } + case CV1: + { + WriteLog("XBT CV1"); + Hamulec = new TCV1(MaxBrakePress[3], BrakeCylRadius, BrakeCylDist, BrakeVVolume, BrakeCylNo, + BrakeDelays, BrakeMethod, NAxles, NBpA); + break; + } + case CV1_L_TR: + { + WriteLog("XBT CV1_L_T"); + Hamulec = new TCV1L_TR(MaxBrakePress[3], BrakeCylRadius, BrakeCylDist, BrakeVVolume, + BrakeCylNo, BrakeDelays, BrakeMethod, NAxles, NBpA); + break; + } - default: - Hamulec = new TBrake(MaxBrakePress[3], BrakeCylRadius, BrakeCylDist, BrakeVVolume, - BrakeCylNo, BrakeDelays, BrakeMethod, NAxles, NBpA); - } + default: + Hamulec = new TBrake(MaxBrakePress[3], BrakeCylRadius, BrakeCylDist, BrakeVVolume, + BrakeCylNo, BrakeDelays, BrakeMethod, NAxles, NBpA); + } - Hamulec->SetASBP(MaxBrakePress[4]); + Hamulec->SetASBP(MaxBrakePress[4]); - switch (BrakeHandle) - { - case FV4a: - Handle = new TFV4aM(); - break; - case FVel6: - Handle = new TFVel6(); - break; - case testH: - Handle = new Ttest(); - break; - case M394: - Handle = new TM394(); - break; - case Knorr: - Handle = new TH14K1(); - break; - case St113: - Handle = new TSt113(); - break; - default: - Handle = new TDriverHandle(); - } + switch (BrakeHandle) + { + case FV4a: + Handle = new TFV4aM(); + break; + case FVel6: + Handle = new TFVel6(); + break; + case testH: + Handle = new Ttest(); + break; + case M394: + Handle = new TM394(); + break; + case Knorr: + Handle = new TH14K1(); + break; + case St113: + Handle = new TSt113(); + break; + default: + Handle = new TDriverHandle(); + } - switch (BrakeLocHandle) - { - case FD1: - { - LocHandle = new TFD1(); - LocHandle->Init(MaxBrakePress[0]); - break; - } - case Knorr: - { - LocHandle = new TH1405(); - LocHandle->Init(MaxBrakePress[0]); - break; - } - default: - LocHandle = new TDriverHandle(); - } + switch (BrakeLocHandle) + { + case FD1: + { + LocHandle = new TFD1(); + LocHandle->Init(MaxBrakePress[0]); + break; + } + case Knorr: + { + LocHandle = new TH1405(); + LocHandle->Init(MaxBrakePress[0]); + break; + } + default: + LocHandle = new TDriverHandle(); + } - Pipe = new TReservoir(); - Pipe2 = new TReservoir(); // zabezpieczenie, bo sie PG wywala... :( - Pipe->CreateCap((Max0R(Dim.L, 14) + 0.5) * Spg * 1); // dlugosc x przekroj x odejscia i takie - // tam - Pipe2->CreateCap((Max0R(Dim.L, 14) + 0.5) * Spg * 1); + Pipe = new TReservoir(); + Pipe2 = new TReservoir(); // zabezpieczenie, bo sie PG wywala... :( + Pipe->CreateCap((Max0R(Dim.L, 14) + 0.5) * Spg * 1); // dlugosc x przekroj x odejscia i takie + // tam + Pipe2->CreateCap((Max0R(Dim.L, 14) + 0.5) * Spg * 1); - if (LightsPosNo > 0) - LightsPos = LightsDefPos; + if (LightsPosNo > 0) + LightsPos = LightsDefPos; - // checking ready flag - // to dac potem do init - if (ReadyFlag) // gotowy do drogi - { - WriteLog("Ready to depart"); - CompressedVolume = VeselVolume * MinCompressor * (9.8) / 10; - ScndPipePress = CompressedVolume / VeselVolume; - PipePress = CntrlPipePress; - BrakePress = 0; - LocalBrakePos = 0; - if (CabNo == 0) - BrakeCtrlPos = Handle->GetPos(bh_NP); - else - BrakeCtrlPos = Handle->GetPos(bh_RP); - MainSwitch(false); - PantFront(true); - PantRear(true); - MainSwitch(true); - ActiveDir = 0; // Dir; //nastawnik kierunkowy - musi być ustawiane osobno! - DirAbsolute = ActiveDir * CabNo; // kierunek jazdy względem sprzęgów - LimPipePress = CntrlPipePress; - } - else - { // zahamowany} - WriteLog("Braked"); - Volume = BrakeVVolume * MaxBrakePress[3]; - CompressedVolume = VeselVolume * MinCompressor * 0.55; - ScndPipePress = 5.1; - PipePress = LowPipePress; - PipeBrakePress = MaxBrakePress[3] / 2; - BrakePress = MaxBrakePress[3] / 2; - LocalBrakePos = 0; - LimPipePress = LowPipePress; - } + // checking ready flag + // to dac potem do init + if (ReadyFlag) // gotowy do drogi + { + WriteLog("Ready to depart"); + CompressedVolume = VeselVolume * MinCompressor * (9.8) / 10; + ScndPipePress = CompressedVolume / VeselVolume; + PipePress = CntrlPipePress; + BrakePress = 0; + LocalBrakePos = 0; + if (CabNo == 0) + BrakeCtrlPos = Handle->GetPos(bh_NP); + else + BrakeCtrlPos = Handle->GetPos(bh_RP); + MainSwitch(false); + PantFront(true); + PantRear(true); + MainSwitch(true); + ActiveDir = 0; // Dir; //nastawnik kierunkowy - musi być ustawiane osobno! + DirAbsolute = ActiveDir * CabNo; // kierunek jazdy względem sprzęgów + LimPipePress = CntrlPipePress; + } + else + { // zahamowany} + WriteLog("Braked"); + Volume = BrakeVVolume * MaxBrakePress[3]; + CompressedVolume = VeselVolume * MinCompressor * 0.55; + ScndPipePress = 5.1; + PipePress = LowPipePress; + PipeBrakePress = MaxBrakePress[3] / 2; + BrakePress = MaxBrakePress[3] / 2; + LocalBrakePos = 0; + LimPipePress = LowPipePress; + } - ActFlowSpeed = 0; - BrakeCtrlPosR = BrakeCtrlPos; + ActFlowSpeed = 0; + BrakeCtrlPosR = BrakeCtrlPos; - if (BrakeLocHandle == Knorr) - LocalBrakePos = 5; + if (BrakeLocHandle == Knorr) + LocalBrakePos = 5; - Pipe->CreatePress(PipePress); - Pipe2->CreatePress(ScndPipePress); - Pipe->Act(); - Pipe2->Act(); + Pipe->CreatePress(PipePress); + Pipe2->CreatePress(ScndPipePress); + Pipe->Act(); + Pipe2->Act(); - EqvtPipePress = PipePress; + EqvtPipePress = PipePress; - Handle->Init(PipePress); + Handle->Init(PipePress); - ComputeConstans(); + ComputeConstans(); - if (TrainType == dt_ET22) - CompressorPower = 0; + if (TrainType == dt_ET22) + CompressorPower = 0; - Hamulec->Init(PipePress, HighPipePress, LowPipePress, BrakePress, BrakeDelayFlag); + Hamulec->Init(PipePress, HighPipePress, LowPipePress, BrakePress, BrakeDelayFlag); - ScndPipePress = Compressor; + ScndPipePress = Compressor; - // WriteLogSS("OK=", BoolTo10(OK)); - // WriteLog(""); + // WriteLogSS("OK=", BoolTo10(OK)); + // WriteLog(""); - return OK; + return OK; } // ************************************************************************************************* @@ -7665,7 +7663,7 @@ bool TMoverParameters::SendCtrlToNext(std::string CtrlCommand, double ctrlvalue, } else // jeśli następny jest ustawiony przeciwnie, zmieniamy kierunek if (Couplers[d].Connected->SetInternalCommand(CtrlCommand, ctrlvalue, -dir)) - OK = (Couplers[d].Connected->RunInternalCommand() && OK); // tu jest rekurencja + OK = (Couplers[d].Connected->RunInternalCommand() && OK); // tu jest rekurencja return OK; } @@ -7687,108 +7685,108 @@ bool TMoverParameters::RunCommand(std::string Command, double CValue1, double CV OK = false; ClearPendingExceptions(); - if (Command == "MainCtrl") - { - if (MainCtrlPosNo >= floor(CValue1)) - MainCtrlPos = floor(CValue1); - OK = SendCtrlToNext(Command, CValue1, CValue2); - } - else if (Command == "ScndCtrl") - { - if ((EngineType == ElectricInductionMotor)) - if ((ScndCtrlPos == 0) && (floor(CValue1) > 0)) - if ((Vmax < 250)) - ScndCtrlActualPos = Round(Vel + 0.5); - else - ScndCtrlActualPos = Round(Vel / 2 + 0.5); - else if ((floor(CValue1) == 0)) - ScndCtrlActualPos = 0; - if (ScndCtrlPosNo >= floor(CValue1)) - ScndCtrlPos = floor(CValue1); - OK = SendCtrlToNext(Command, CValue1, CValue2); - } - /* else if command='BrakeCtrl' then - begin - if BrakeCtrlPosNo>=Trunc(CValue1) then - begin - BrakeCtrlPos:=Trunc(CValue1); - OK:=SendCtrlToNext(command,CValue1,CValue2); - end; - end */ - else if (Command == "Brake") // youBy - jak sie EP hamuje, to trza sygnal wyslac... - { - Hamulec->SetEPS(CValue1); - // fBrakeCtrlPos:=BrakeCtrlPos; //to powinnno być w jednym miejscu, aktualnie w C++!!! - BrakePressureActual = BrakePressureTable[BrakeCtrlPos]; - OK = SendCtrlToNext(Command, CValue1, CValue2); - } // youby - odluzniacz hamulcow, przyda sie - else if (Command == "BrakeReleaser") - { - OK = BrakeReleaser(Round(CValue1)); // samo się przesyła dalej - // OK:=SendCtrlToNext(command,CValue1,CValue2); //to robiło kaskadę 2^n - } - else if (Command == "MainSwitch") - { - if (CValue1 == 1) - { - Mains = true; - if ((EngineType == DieselEngine) && Mains) - dizel_enginestart = true; - } - else - Mains = false; - OK = SendCtrlToNext(Command, CValue1, CValue2); - } - else if (Command == "Direction") - { - ActiveDir = floor(CValue1); - DirAbsolute = ActiveDir * CabNo; - OK = SendCtrlToNext(Command, CValue1, CValue2); - } - else if (Command == "CabActivisation") - { - // OK:=Power>0.01; - switch (static_cast(CValue1 * CValue2)) - { // CValue2 ma zmieniany znak przy niezgodności sprzęgów - case 1: - CabNo = 1; - case -1: - CabNo = -1; - default: - CabNo = 0; // gdy CValue1==0 - } - DirAbsolute = ActiveDir * CabNo; - OK = SendCtrlToNext(Command, CValue1, CValue2); - } - else if (Command == "AutoRelaySwitch") - { - if ((CValue1 == 1) && (AutoRelayType == 2)) - AutoRelayFlag = true; - else - AutoRelayFlag = false; - OK = SendCtrlToNext(Command, CValue1, CValue2); - } - else if (Command == "FuseSwitch") - { - if (((EngineType == ElectricSeriesMotor) || (EngineType == DieselElectric)) && FuseFlag && - (CValue1 == 1) && (MainCtrlActualPos == 0) && (ScndCtrlActualPos == 0) && Mains) - /* if (EngineType=ElectricSeriesMotor) and (CValue1=1) and - (MainCtrlActualPos=0) and (ScndCtrlActualPos=0) and Mains then*/ - FuseFlag = false; /*wlaczenie ponowne obwodu*/ - // if ((EngineType=ElectricSeriesMotor)or(EngineType=DieselElectric)) and not FuseFlag and - // (CValue1=0) and Mains then - // FuseFlag:=true; - OK = SendCtrlToNext(Command, CValue1, CValue2); - } - else if (Command == "ConverterSwitch") /*NBMX*/ - { - if ((CValue1 == 1)) - ConverterAllow = true; - else if ((CValue1 == 0)) - ConverterAllow = false; - OK = SendCtrlToNext(Command, CValue1, CValue2); - } - else if (Command == "BatterySwitch") /*NBMX*/ + if (Command == "MainCtrl") + { + if (MainCtrlPosNo >= floor(CValue1)) + MainCtrlPos = floor(CValue1); + OK = SendCtrlToNext(Command, CValue1, CValue2); + } + else if (Command == "ScndCtrl") + { + if ((EngineType == ElectricInductionMotor)) + if ((ScndCtrlPos == 0) && (floor(CValue1) > 0)) + if ((Vmax < 250)) + ScndCtrlActualPos = Round(Vel + 0.5); + else + ScndCtrlActualPos = Round(Vel / 2 + 0.5); + else if ((floor(CValue1) == 0)) + ScndCtrlActualPos = 0; + if (ScndCtrlPosNo >= floor(CValue1)) + ScndCtrlPos = floor(CValue1); + OK = SendCtrlToNext(Command, CValue1, CValue2); + } + /* else if command='BrakeCtrl' then + begin + if BrakeCtrlPosNo>=Trunc(CValue1) then + begin + BrakeCtrlPos:=Trunc(CValue1); + OK:=SendCtrlToNext(command,CValue1,CValue2); + end; + end */ + else if (Command == "Brake") // youBy - jak sie EP hamuje, to trza sygnal wyslac... + { + Hamulec->SetEPS(CValue1); + // fBrakeCtrlPos:=BrakeCtrlPos; //to powinnno być w jednym miejscu, aktualnie w C++!!! + BrakePressureActual = BrakePressureTable[BrakeCtrlPos]; + OK = SendCtrlToNext(Command, CValue1, CValue2); + } // youby - odluzniacz hamulcow, przyda sie + else if (Command == "BrakeReleaser") + { + OK = BrakeReleaser(Round(CValue1)); // samo się przesyła dalej + // OK:=SendCtrlToNext(command,CValue1,CValue2); //to robiło kaskadę 2^n + } + else if (Command == "MainSwitch") + { + if (CValue1 == 1) + { + Mains = true; + if ((EngineType == DieselEngine) && Mains) + dizel_enginestart = true; + } + else + Mains = false; + OK = SendCtrlToNext(Command, CValue1, CValue2); + } + else if (Command == "Direction") + { + ActiveDir = floor(CValue1); + DirAbsolute = ActiveDir * CabNo; + OK = SendCtrlToNext(Command, CValue1, CValue2); + } + else if (Command == "CabActivisation") + { + // OK:=Power>0.01; + switch (static_cast(CValue1 * CValue2)) + { // CValue2 ma zmieniany znak przy niezgodności sprzęgów + case 1: + CabNo = 1; + case -1: + CabNo = -1; + default: + CabNo = 0; // gdy CValue1==0 + } + DirAbsolute = ActiveDir * CabNo; + OK = SendCtrlToNext(Command, CValue1, CValue2); + } + else if (Command == "AutoRelaySwitch") + { + if ((CValue1 == 1) && (AutoRelayType == 2)) + AutoRelayFlag = true; + else + AutoRelayFlag = false; + OK = SendCtrlToNext(Command, CValue1, CValue2); + } + else if (Command == "FuseSwitch") + { + if (((EngineType == ElectricSeriesMotor) || (EngineType == DieselElectric)) && FuseFlag && + (CValue1 == 1) && (MainCtrlActualPos == 0) && (ScndCtrlActualPos == 0) && Mains) + /* if (EngineType=ElectricSeriesMotor) and (CValue1=1) and + (MainCtrlActualPos=0) and (ScndCtrlActualPos=0) and Mains then*/ + FuseFlag = false; /*wlaczenie ponowne obwodu*/ + // if ((EngineType=ElectricSeriesMotor)or(EngineType=DieselElectric)) and not FuseFlag and + // (CValue1=0) and Mains then + // FuseFlag:=true; + OK = SendCtrlToNext(Command, CValue1, CValue2); + } + else if (Command == "ConverterSwitch") /*NBMX*/ + { + if ((CValue1 == 1)) + ConverterAllow = true; + else if ((CValue1 == 0)) + ConverterAllow = false; + OK = SendCtrlToNext(Command, CValue1, CValue2); + } + else if (Command == "BatterySwitch") /*NBMX*/ { if ((CValue1 == 1)) Battery = true; @@ -7801,223 +7799,223 @@ bool TMoverParameters::RunCommand(std::string Command, double CValue1, double CV OK = SendCtrlToNext(Command, CValue1, CValue2); } // else if command='EpFuseSwitch' then {NBMX} - // begin - // if (CValue1=1) then EpFuse:=true - // else if (CValue1=0) then EpFuse:=false; - // OK:=SendCtrlToNext(command,CValue1,CValue2); - // end + // begin + // if (CValue1=1) then EpFuse:=true + // else if (CValue1=0) then EpFuse:=false; + // OK:=SendCtrlToNext(command,CValue1,CValue2); + // end else if (Command == "CompressorSwitch") /*NBMX*/ - { - if ((CValue1 == 1)) - CompressorAllow = true; - else if ((CValue1 == 0)) - CompressorAllow = false; - OK = SendCtrlToNext(Command, CValue1, CValue2); - } - else if (Command == "DoorOpen") /*NBMX*/ - { // Ra: uwzględnić trzeba jeszcze zgodność sprzęgów - if ((CValue2 > 0)) - { // normalne ustawienie pojazdu - if ((CValue1 == 1) || (CValue1 == 3)) - DoorLeftOpened = true; - if ((CValue1 == 2) || (CValue1 == 3)) - DoorRightOpened = true; - } - else - { // odwrotne ustawienie pojazdu - if ((CValue1 == 2) || (CValue1 == 3)) - DoorLeftOpened = true; - if ((CValue1 == 1) || (CValue1 == 3)) - DoorRightOpened = true; - } - OK = SendCtrlToNext(Command, CValue1, CValue2); - } - else if (Command == "DoorClose") /*NBMX*/ - { // Ra: uwzględnić trzeba jeszcze zgodność sprzęgów - if ((CValue2 > 0)) - { // normalne ustawienie pojazdu - if ((CValue1 == 1) || (CValue1 == 3)) - DoorLeftOpened = false; - if ((CValue1 == 2) || (CValue1 == 3)) - DoorRightOpened = false; - } - else - { // odwrotne ustawienie pojazdu - if ((CValue1 == 2) || (CValue1 == 3)) - DoorLeftOpened = false; - if ((CValue1 == 1) || (CValue1 == 3)) - DoorRightOpened = false; - } - OK = SendCtrlToNext(Command, CValue1, CValue2); - } - else if (Command == "PantFront") /*Winger 160204*/ - { // Ra: uwzględnić trzeba jeszcze zgodność sprzęgów - // Czemu EZT ma być traktowane inaczej? Ukrotnienie ma, a człon może być odwrócony - if ((TrainType == dt_EZT)) - { //'ezt' - if ((CValue1 == 1)) - { - PantFrontUp = true; - PantFrontStart = 0; - } - else if ((CValue1 == 0)) - { - PantFrontUp = false; - PantFrontStart = 1; - } - } - else - { // nie 'ezt' - odwrotne ustawienie pantografów: ^-.-^ zamiast ^-.^- - if ((CValue1 == 1)) - if ((TestFlag(Couplers[1].CouplingFlag, ctrain_controll) && (CValue2 == 1)) || - (TestFlag(Couplers[0].CouplingFlag, ctrain_controll) && (CValue2 == -1))) - { - PantFrontUp = true; - PantFrontStart = 0; - } - else - { - PantRearUp = true; - PantRearStart = 0; - } - else if ((CValue1 == 0)) - if ((TestFlag(Couplers[1].CouplingFlag, ctrain_controll) && (CValue2 == 1)) || - (TestFlag(Couplers[0].CouplingFlag, ctrain_controll) && (CValue2 == -1))) - { - PantFrontUp = false; - PantFrontStart = 1; - } - else - { - PantRearUp = false; - PantRearStart = 1; - } - } - OK = SendCtrlToNext(Command, CValue1, CValue2); - } - else if (Command == "PantRear") /*Winger 160204, ABu 310105 i 030305*/ - { // Ra: uwzględnić trzeba jeszcze zgodność sprzęgów - if ((TrainType == dt_EZT)) - { /*'ezt'*/ - if ((CValue1 == 1)) - { - PantRearUp = true; - PantRearStart = 0; - } - else if ((CValue1 == 0)) - { - PantRearUp = false; - PantRearStart = 1; - } - } - else - { /*nie 'ezt'*/ - if ((CValue1 == 1)) - /*if ostatni polaczony sprz. sterowania*/ - if ((TestFlag(Couplers[1].CouplingFlag, ctrain_controll) && (CValue2 == 1)) || - (TestFlag(Couplers[0].CouplingFlag, ctrain_controll) && (CValue2 == -1))) - { - PantRearUp = true; - PantRearStart = 0; - } - else - { - PantFrontUp = true; - PantFrontStart = 0; - } - else if ((CValue1 == 0)) - if ((TestFlag(Couplers[1].CouplingFlag, ctrain_controll) && (CValue2 == 1)) || - (TestFlag(Couplers[0].CouplingFlag, ctrain_controll) && (CValue2 == -1))) - { - PantRearUp = false; - PantRearStart = 1; - } - else - { - PantFrontUp = false; - PantFrontStart = 1; - } - } - OK = SendCtrlToNext(Command, CValue1, CValue2); - } - else if (Command == "MaxCurrentSwitch") - { - OK = MaxCurrentSwitch(CValue1 == 1); - } - else if (Command == "MinCurrentSwitch") - { - OK = MinCurrentSwitch(CValue1 == 1); - } - /*test komend oddzialywujacych na tabor*/ - else if (Command == "SetDamage") - { - if (CValue2 == 1) - OK = SetFlag(DamageFlag, floor(CValue1)); - if (CValue2 == -1) - OK = SetFlag(DamageFlag, -floor(CValue1)); - } - else if (Command == "Emergency_brake") - { - if (EmergencyBrakeSwitch(floor(CValue1) == 1)) // YB: czy to jest potrzebne? - OK = true; - else - OK = false; - } - else if (Command == "BrakeDelay") - { - BrakeDelayFlag = floor(CValue1); - OK = true; - } - else if (Command == "SandDoseOn") - { - if (SandDoseOn()) - OK = true; - else - OK = false; - } - else if (Command == "CabSignal") /*SHP,Indusi*/ - { // Ra: to powinno działać tylko w członie obsadzonym - if (/*(TrainType=dt_EZT)or*/ (ActiveCab != 0) && (Battery) && - TestFlag(SecuritySystem.SystemType, - 2)) // jeśli kabina jest obsadzona (silnikowy w EZT?) - /*?*/ /* WITH SecuritySystem */ - { - SecuritySystem.VelocityAllowed = floor(CValue1); - SecuritySystem.NextVelocityAllowed = floor(CValue2); - SecuritySystem.SystemSoundSHPTimer = 0; // hunter-091012 - SetFlag(SecuritySystem.Status, s_active); - } - // else OK:=false; - OK = true; // true, gdy można usunąć komendę - } - /*naladunek/rozladunek*/ - else if (Pos("Load=", Command) == 1) - { - OK = false; // będzie powtarzane aż się załaduje - if ((Vel == 0) && (MaxLoad > 0) && - (Load < MaxLoad * (1.0 + OverLoadFactor))) // czy można ładowac? - if (Distance(Loc, CommandIn.Location, Dim, Dim) < 10) // ten peron/rampa - { - testload = ToLower(DUE(Command)); - if (Pos(testload, LoadAccepted) > 0) // nazwa jest obecna w CHK - OK = LoadingDone(Min0R(CValue2, LoadSpeed), testload); // zmienia LoadStatus - } - // if OK then LoadStatus:=0; //nie udalo sie w ogole albo juz skonczone - } - else if (Pos("UnLoad=", Command) == 1) - { - OK = false; // będzie powtarzane aż się rozładuje - if ((Vel == 0) && (Load > 0)) // czy jest co rozladowac? - if (Distance(Loc, CommandIn.Location, Dim, Dim) < 10) // ten peron - { - testload = DUE(Command); // zgodność nazwy ładunku z CHK - if (LoadType == testload) /*mozna to rozladowac*/ - OK = LoadingDone(-Min0R(CValue2, LoadSpeed), testload); - } - // if OK then LoadStatus:=0; - } + { + if ((CValue1 == 1)) + CompressorAllow = true; + else if ((CValue1 == 0)) + CompressorAllow = false; + OK = SendCtrlToNext(Command, CValue1, CValue2); + } + else if (Command == "DoorOpen") /*NBMX*/ + { // Ra: uwzględnić trzeba jeszcze zgodność sprzęgów + if ((CValue2 > 0)) + { // normalne ustawienie pojazdu + if ((CValue1 == 1) || (CValue1 == 3)) + DoorLeftOpened = true; + if ((CValue1 == 2) || (CValue1 == 3)) + DoorRightOpened = true; + } + else + { // odwrotne ustawienie pojazdu + if ((CValue1 == 2) || (CValue1 == 3)) + DoorLeftOpened = true; + if ((CValue1 == 1) || (CValue1 == 3)) + DoorRightOpened = true; + } + OK = SendCtrlToNext(Command, CValue1, CValue2); + } + else if (Command == "DoorClose") /*NBMX*/ + { // Ra: uwzględnić trzeba jeszcze zgodność sprzęgów + if ((CValue2 > 0)) + { // normalne ustawienie pojazdu + if ((CValue1 == 1) || (CValue1 == 3)) + DoorLeftOpened = false; + if ((CValue1 == 2) || (CValue1 == 3)) + DoorRightOpened = false; + } + else + { // odwrotne ustawienie pojazdu + if ((CValue1 == 2) || (CValue1 == 3)) + DoorLeftOpened = false; + if ((CValue1 == 1) || (CValue1 == 3)) + DoorRightOpened = false; + } + OK = SendCtrlToNext(Command, CValue1, CValue2); + } + else if (Command == "PantFront") /*Winger 160204*/ + { // Ra: uwzględnić trzeba jeszcze zgodność sprzęgów + // Czemu EZT ma być traktowane inaczej? Ukrotnienie ma, a człon może być odwrócony + if ((TrainType == dt_EZT)) + { //'ezt' + if ((CValue1 == 1)) + { + PantFrontUp = true; + PantFrontStart = 0; + } + else if ((CValue1 == 0)) + { + PantFrontUp = false; + PantFrontStart = 1; + } + } + else + { // nie 'ezt' - odwrotne ustawienie pantografów: ^-.-^ zamiast ^-.^- + if ((CValue1 == 1)) + if ((TestFlag(Couplers[1].CouplingFlag, ctrain_controll) && (CValue2 == 1)) || + (TestFlag(Couplers[0].CouplingFlag, ctrain_controll) && (CValue2 == -1))) + { + PantFrontUp = true; + PantFrontStart = 0; + } + else + { + PantRearUp = true; + PantRearStart = 0; + } + else if ((CValue1 == 0)) + if ((TestFlag(Couplers[1].CouplingFlag, ctrain_controll) && (CValue2 == 1)) || + (TestFlag(Couplers[0].CouplingFlag, ctrain_controll) && (CValue2 == -1))) + { + PantFrontUp = false; + PantFrontStart = 1; + } + else + { + PantRearUp = false; + PantRearStart = 1; + } + } + OK = SendCtrlToNext(Command, CValue1, CValue2); + } + else if (Command == "PantRear") /*Winger 160204, ABu 310105 i 030305*/ + { // Ra: uwzględnić trzeba jeszcze zgodność sprzęgów + if ((TrainType == dt_EZT)) + { /*'ezt'*/ + if ((CValue1 == 1)) + { + PantRearUp = true; + PantRearStart = 0; + } + else if ((CValue1 == 0)) + { + PantRearUp = false; + PantRearStart = 1; + } + } + else + { /*nie 'ezt'*/ + if ((CValue1 == 1)) + /*if ostatni polaczony sprz. sterowania*/ + if ((TestFlag(Couplers[1].CouplingFlag, ctrain_controll) && (CValue2 == 1)) || + (TestFlag(Couplers[0].CouplingFlag, ctrain_controll) && (CValue2 == -1))) + { + PantRearUp = true; + PantRearStart = 0; + } + else + { + PantFrontUp = true; + PantFrontStart = 0; + } + else if ((CValue1 == 0)) + if ((TestFlag(Couplers[1].CouplingFlag, ctrain_controll) && (CValue2 == 1)) || + (TestFlag(Couplers[0].CouplingFlag, ctrain_controll) && (CValue2 == -1))) + { + PantRearUp = false; + PantRearStart = 1; + } + else + { + PantFrontUp = false; + PantFrontStart = 1; + } + } + OK = SendCtrlToNext(Command, CValue1, CValue2); + } + else if (Command == "MaxCurrentSwitch") + { + OK = MaxCurrentSwitch(CValue1 == 1); + } + else if (Command == "MinCurrentSwitch") + { + OK = MinCurrentSwitch(CValue1 == 1); + } + /*test komend oddzialywujacych na tabor*/ + else if (Command == "SetDamage") + { + if (CValue2 == 1) + OK = SetFlag(DamageFlag, floor(CValue1)); + if (CValue2 == -1) + OK = SetFlag(DamageFlag, -floor(CValue1)); + } + else if (Command == "Emergency_brake") + { + if (EmergencyBrakeSwitch(floor(CValue1) == 1)) // YB: czy to jest potrzebne? + OK = true; + else + OK = false; + } + else if (Command == "BrakeDelay") + { + BrakeDelayFlag = floor(CValue1); + OK = true; + } + else if (Command == "SandDoseOn") + { + if (SandDoseOn()) + OK = true; + else + OK = false; + } + else if (Command == "CabSignal") /*SHP,Indusi*/ + { // Ra: to powinno działać tylko w członie obsadzonym + if (/*(TrainType=dt_EZT)or*/ (ActiveCab != 0) && (Battery) && + TestFlag(SecuritySystem.SystemType, + 2)) // jeśli kabina jest obsadzona (silnikowy w EZT?) + /*?*/ /* WITH SecuritySystem */ + { + SecuritySystem.VelocityAllowed = floor(CValue1); + SecuritySystem.NextVelocityAllowed = floor(CValue2); + SecuritySystem.SystemSoundSHPTimer = 0; // hunter-091012 + SetFlag(SecuritySystem.Status, s_active); + } + // else OK:=false; + OK = true; // true, gdy można usunąć komendę + } + /*naladunek/rozladunek*/ + else if (Pos("Load=", Command) == 1) + { + OK = false; // będzie powtarzane aż się załaduje + if ((Vel == 0) && (MaxLoad > 0) && + (Load < MaxLoad * (1.0 + OverLoadFactor))) // czy można ładowac? + if (Distance(Loc, CommandIn.Location, Dim, Dim) < 10) // ten peron/rampa + { + testload = ToLower(DUE(Command)); + if (Pos(testload, LoadAccepted) > 0) // nazwa jest obecna w CHK + OK = LoadingDone(Min0R(CValue2, LoadSpeed), testload); // zmienia LoadStatus + } + // if OK then LoadStatus:=0; //nie udalo sie w ogole albo juz skonczone + } + else if (Pos("UnLoad=", Command) == 1) + { + OK = false; // będzie powtarzane aż się rozładuje + if ((Vel == 0) && (Load > 0)) // czy jest co rozladowac? + if (Distance(Loc, CommandIn.Location, Dim, Dim) < 10) // ten peron + { + testload = DUE(Command); // zgodność nazwy ładunku z CHK + if (LoadType == testload) /*mozna to rozladowac*/ + OK = LoadingDone(-Min0R(CValue2, LoadSpeed), testload); + } + // if OK then LoadStatus:=0; + } - return OK; // dla true komenda będzie usunięta, dla false wykonana ponownie + return OK; // dla true komenda będzie usunięta, dla false wykonana ponownie } // ************************************************************************************************* diff --git a/McZapkie/hamulce.h b/McZapkie/hamulce.h index a5284d8d..54184585 100644 --- a/McZapkie/hamulce.h +++ b/McZapkie/hamulce.h @@ -1,7 +1,7 @@ #pragma once #ifndef INCLUDED_HAMULCE_H #define INCLUDED_HAMULCE_H - /*fizyka hamulcow dla symulatora*/ +/*fizyka hamulcow dla symulatora*/ /* This Source Code Form is subject to the @@ -15,8 +15,7 @@ http://mozilla.org/MPL/2.0/. MaSzyna EU07 - SPKS Brakes. Copyright (C) 2007-2014 Maciej Cierniak -*/ - +*/ /* (C) youBy @@ -39,805 +38,794 @@ Knorr/West EP - #include "mctools.h" // Pascal unit //#include - - - static int const LocalBrakePosNo = 10; /*ilosc nastaw hamulca recznego lub pomocniczego*/ - static int const MainBrakeMaxPos = 10; /*max. ilosc nastaw hamulca zasadniczego*/ - - /*nastawy hamulca*/ - static int const bdelay_G = 1; //G - static int const bdelay_P = 2; //P - static int const bdelay_R = 4; //R - static int const bdelay_M = 8; //Mg - static int const bdelay_GR = 128; //G-R - - - /*stan hamulca*/ - static int const b_off = 0; //luzowanie - static int const b_hld = 1; //trzymanie - static int const b_on = 2; //napelnianie - static int const b_rfl = 4; //uzupelnianie - static int const b_rls = 8; //odluzniacz - static int const b_ep = 16; //elektropneumatyczny - static int const b_asb = 32; //elektropneumatyczny - static int const b_dmg = 128; //wylaczony z dzialania - - /*uszkodzenia hamulca*/ - static int const df_on = 1; //napelnianie - static int const df_off = 2; //luzowanie - static int const df_br = 4; //wyplyw z ZP - static int const df_vv = 8; //wyplyw z komory wstepnej - static int const df_bc = 16; //wyplyw z silownika - static int const df_cv = 32; //wyplyw z ZS - static int const df_PP = 64; //zawsze niski stopien - static int const df_RR = 128; //zawsze wysoki stopien - - /*indeksy dzwiekow FV4a*/ - static int const s_fv4a_b = 0; //hamowanie - static int const s_fv4a_u = 1; //luzowanie - static int const s_fv4a_e = 2; //hamowanie nagle - static int const s_fv4a_x = 3; //wyplyw sterujacego fala - static int const s_fv4a_t = 4; //wyplyw z czasowego - - /*pary cierne*/ - static int const bp_P10 = 0; - static int const bp_P10Bg = 2; //żeliwo fosforowe P10 - static int const bp_P10Bgu = 1; - static int const bp_LLBg = 4; //komp. b.n.t. - static int const bp_LLBgu = 3; - static int const bp_LBg = 6; //komp. n.t. - static int const bp_LBgu = 5; - static int const bp_KBg = 8; //komp. w.t. - static int const bp_KBgu = 7; - static int const bp_D1 = 9; //tarcze - static int const bp_D2 = 10; - static int const bp_FR513 = 11; //Frenoplast FR513 - static int const bp_Cosid = 12; //jakistam kompozyt :D - static int const bp_PKPBg = 13; //żeliwo PKP - static int const bp_PKPBgu = 14; - static int const bp_MHS = 128; //magnetyczny hamulec szynowy - static int const bp_P10yBg = 15; //żeliwo fosforowe P10 - static int const bp_P10yBgu = 16; - static int const bp_FR510 = 17; //Frenoplast FR510 - - static int const sf_Acc = 1; //przyspieszacz - static int const sf_BR = 2; //przekladnia - static int const sf_CylB = 4; //cylinder - napelnianie - static int const sf_CylU = 8; //cylinder - oproznianie - static int const sf_rel = 16; //odluzniacz - static int const sf_ep = 32; //zawory ep - - static int const bh_MIN = 0; //minimalna pozycja - static int const bh_MAX = 1; //maksymalna pozycja - static int const bh_FS = 2; //napelnianie uderzeniowe //jesli nie ma, to jazda - static int const bh_RP = 3; //jazda - static int const bh_NP = 4; //odciecie - podwojna trakcja - static int const bh_MB = 5; //odciecie - utrzymanie stopnia hamowania/pierwszy 1 stopien hamowania - static int const bh_FB = 6; //pelne - static int const bh_EB = 7; //nagle - static int const bh_EPR = 8; //ep - luzowanie //pelny luz dla ep kątowego - static int const bh_EPN = 9; //ep - utrzymanie //jesli rowne luzowaniu, wtedy sterowanie przyciskiem - static int const bh_EPB = 10; //ep - hamowanie //pelne hamowanie dla ep kątowego - - - static double const SpgD = 0.7917; - static double const SpO = 0.5067; //przekroj przewodu 1" w l/m - //wyj: jednostka dosyc dziwna, ale wszystkie obliczenia - //i pojemnosci sa podane w litrach (rozsadne wielkosci) - //zas dlugosc pojazdow jest podana w metrach - //a predkosc przeplywu w m/s //3.5 - //7//1.5 - // BPT: array[-2..6] of array [0..1] of real= ((0, 5.0), (14, 5.4), (9, 5.0), (6, 4.6), (9, 4.5), (9, 4.0), (9, 3.5), (9, 2.8), (34, 2.8)); - // BPT: array[-2..6] of array [0..1] of real= ((0, 5.0), (7, 5.0), (2.0, 5.0), (4.5, 4.6), (4.5, 4.2), (4.5, 3.8), (4.5, 3.4), (4.5, 2.8), (8, 2.8)); - static double BPT[9][2] = { {0 , 5.0} , {7 , 5.0} , {2.0 , 5.0} , {4.5 , 4.6} , {4.5 , 4.2} , {4.5 , 3.8} , {4.5 , 3.4} , {4.5 , 2.8} , {8 , 2.8} }; - static double BPT_394[7][2] = { {13 , 10.0} , {5 , 5.0} , {0 , -1} , {5 , -1} , {5 , 0.0} , {5 , 0.0} , {18 , 0.0} }; - //double *BPT = zero_based_BPT[2]; //tablica pozycji hamulca dla zakresu -2..6 - //double *BPT_394 = zero_based_BPT_394[1]; //tablica pozycji hamulca dla zakresu -1..5 - // BPT: array[-2..6] of array [0..1] of real= ((0, 5.0), (12, 5.4), (9, 5.0), (9, 4.6), (9, 4.2), (9, 3.8), (9, 3.4), (9, 2.8), (34, 2.8)); - // BPT: array[-2..6] of array [0..1] of real= ((0, 0),(0, 0),(0, 0),(0, 0),(0, 0),(0, 0),(0, 0),(0, 0),(0, 0)); - static int const i_bcpno = 6; - // static double const pi = 3.141592653589793; //definicja w mctools - - //klasa obejmujaca pojedyncze zbiorniki - - - class TReservoir - { - protected: - double Cap; - double Vol; - double dVol; - - public: - TReservoir(); - void CreateCap(double Capacity); - void CreatePress(double Press); - virtual double pa(); - virtual double P(); - void Flow(double dv); - void Act(); - - }; - - - typedef TReservoir *PReservoir; - - - class TBrakeCyl : public TReservoir - - { - public: - virtual double pa()/*override*/; - virtual double P()/*override*/; - TBrakeCyl() : TReservoir() {}; - }; - - - //klasa obejmujaca uklad hamulca zespolonego pojazdu - - - class TBrake - { - protected: - TReservoir *BrakeCyl; //silownik - TReservoir *BrakeRes; //ZP - TReservoir *ValveRes; //komora wstepna - int BCN; //ilosc silownikow - double BCM; //przekladnia hamulcowa - double BCA; //laczny przekroj silownikow - int BrakeDelays; //dostepne opoznienia - int BrakeDelayFlag; //aktualna nastawa - TFricMat *FM; //material cierny - double MaxBP; //najwyzsze cisnienie - int BA; //osie hamowane - int NBpA; //klocki na os - double SizeBR; //rozmiar^2 ZP (w stosunku do 14") - double SizeBC; //rozmiar^2 CH (w stosunku do 14") - bool DCV; //podwojny zawor zwrotny - double ASBP; //cisnienie hamulca pp - - int BrakeStatus; //flaga stanu - int SoundFlag; - - - public: - TBrake(double i_mbp, double i_bcr, double i_bcd, double i_brc, - int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa); - //maksymalne cisnienie, promien, skok roboczy, pojemnosc ZP; - //ilosc cylindrow, opoznienia hamulca, material klockow, osie hamowane, klocki na os; - virtual void Init(double PP, double HPP, double LPP, double BP, int BDF); //inicjalizacja hamulca - - double GetFC(double Vel, double N); //wspolczynnik tarcia - hamulec wie lepiej - virtual double GetPF(double PP, double dt, double Vel); //przeplyw miedzy komora wstepna i PG - double GetBCF(); //sila tlokowa z tloka - virtual double GetHPFlow(double HP, double dt); //przeplyw - 8 bar - double GetBCP(); //cisnienie cylindrow hamulcowych - virtual double GetEDBCP(); //cisnienie tylko z hamulca zasadniczego, uzywane do hamulca ED w EP09 - double GetBRP(); //cisnienie zbiornika pomocniczego - double GetVRP(); //cisnienie komory wstepnej rozdzielacza - virtual double GetCRP(); //cisnienie zbiornika sterujacego - bool SetBDF(int nBDF); //nastawiacz GPRM - void Releaser(int state); //odluzniacz - virtual void SetEPS(double nEPS); //hamulec EP - virtual void SetRM(double RMR) {}; //ustalenie przelozenia rapida - virtual void SetLP(double TM, double LM, double TBP) {}; //parametry przystawki wazacej - virtual void SetLBP(double P) {}; //cisnienie z hamulca pomocniczego - virtual void PLC(double mass) {}; //wspolczynnik cisnienia przystawki wazacej - void ASB(int state); //hamulec przeciwposlizgowy - int GetStatus(); //flaga statusu, moze sie przydac do odglosow - void SetASBP(double Press); //ustalenie cisnienia pp - virtual void ForceEmptiness(); - int GetSoundFlag(); - virtual void SetED(double EDstate) {}; //stan hamulca ED do luzowania - - // procedure - - }; - - - - class TWest : public TBrake - - { - private: - double LBP; //cisnienie hamulca pomocniczego - double dVP; //pobor powietrza wysokiego cisnienia - double EPS; //stan elektropneumatyka - double TareM; double LoadM; //masa proznego i pelnego - double TareBP; //cisnienie dla proznego - double LoadC; //wspolczynnik przystawki wazacej - - public: - void Init(double PP, double HPP, double LPP, double BP, int BDF)/*override*/; - void SetLBP(double P); //cisnienie z hamulca pomocniczego - double GetPF(double PP, double dt, double Vel)/*override*/; //przeplyw miedzy komora wstepna i PG - double GetHPFlow(double HP, double dt)/*override*/; - void PLC(double mass); //wspolczynnik cisnienia przystawki wazacej - void SetEPS(double nEPS)/*override*/; //stan hamulca EP - void SetLP(double TM, double LM, double TBP); //parametry przystawki wazacej - - inline TWest(double i_mbp, double i_bcr, double i_bcd, double i_brc, - int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) : TBrake(i_mbp, i_bcr, i_bcd, i_brc, i_bcn - , i_BD, i_mat, i_ba, i_nbpa) - { - LBP, dVP, EPS, TareM, TareBP, LoadM, LoadC = 0.0; - } - }; - - - - class TESt : public TBrake - - { - private: - - protected: - TReservoir *CntrlRes; //zbiornik sterujący - double BVM; //przelozenie PG-CH - - public: - void Init(double PP, double HPP, double LPP, double BP, int BDF)/*override*/; - double GetPF(double PP, double dt, double Vel)/*override*/; //przeplyw miedzy komora wstepna i PG - void EStParams(double i_crc); //parametry charakterystyczne dla ESt - double GetCRP()/*override*/; - void CheckState(double BCP, double & dV1); //glowny przyrzad rozrzadczy - void CheckReleaser(double dt); //odluzniacz - double CVs(double BP); //napelniacz sterujacego - double BVs(double BCP); //napelniacz pomocniczego - - inline TESt(double i_mbp, double i_bcr, double i_bcd, double i_brc, - int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) : TBrake(i_mbp, i_bcr, i_bcd, i_brc, i_bcn - , i_BD, i_mat, i_ba, i_nbpa) - { - CntrlRes = new TReservoir(); - } - }; - - - - class TESt3 : public TESt - - { - private: - //double CylFlowSpeed[2][2]; //zmienna nie uzywana - - public: - double GetPF(double PP, double dt, double Vel)/*override*/; //przeplyw miedzy komora wstepna i PG - - inline TESt3(double i_mbp, double i_bcr, double i_bcd, double i_brc, - int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) : TESt(i_mbp, i_bcr, i_bcd, i_brc, i_bcn - , i_BD, i_mat, i_ba, i_nbpa) { } - }; - - - - class TESt3AL2 : public TESt3 - - { - private: - double TareM; double LoadM; //masa proznego i pelnego - double TareBP; //cisnienie dla proznego - double LoadC; - - - public: - TReservoir *ImplsRes; //komora impulsowa - void Init(double PP, double HPP, double LPP, double BP, int BDF)/*override*/; - double GetPF(double PP, double dt, double Vel)/*override*/; //przeplyw miedzy komora wstepna i PG - void PLC(double mass); //wspolczynnik cisnienia przystawki wazacej - void SetLP(double TM, double LM, double TBP); //parametry przystawki wazacej - - inline TESt3AL2(double i_mbp, double i_bcr, double i_bcd, double i_brc - , int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) : TESt3(i_mbp, i_bcr, i_bcd, i_brc, i_bcn - , i_BD, i_mat, i_ba, i_nbpa) - { - TareM, TareBP, LoadM, LoadC = 0.0; - } - }; - - - - class TESt4R : public TESt - - { - private: - bool RapidStatus; - - protected: - TReservoir *ImplsRes; //komora impulsowa - double RapidTemp; //aktualne, zmienne przelozenie - - public: - void Init(double PP, double HPP, double LPP, double BP, int BDF)/*override*/; - double GetPF(double PP, double dt, double Vel)/*override*/; //przeplyw miedzy komora wstepna i PG - - inline TESt4R(double i_mbp, double i_bcr, double i_bcd, double i_brc - , int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) : TESt(i_mbp, i_bcr, i_bcd, i_brc, i_bcn - , i_BD, i_mat, i_ba, i_nbpa) - { - RapidTemp = 0.0; - ImplsRes = new TReservoir(); - } - }; - - - - class TLSt : public TESt4R - - { - private: - // double CylFlowSpeed[2][2]; // zmienna nie używana - - protected: - double LBP; //cisnienie hamulca pomocniczego - double RM; //przelozenie rapida - double EDFlag; //luzowanie hamulca z powodu zalaczonego ED - - public: - void Init(double PP, double HPP, double LPP, double BP, int BDF)/*override*/; - void SetLBP(double P); //cisnienie z hamulca pomocniczego - void SetRM(double RMR); //ustalenie przelozenia rapida - double GetPF(double PP, double dt, double Vel)/*override*/; //przeplyw miedzy komora wstepna i PG - double GetHPFlow(double HP, double dt)/*override*/; //przeplyw - 8 bar - virtual double GetEDBCP(); //cisnienie tylko z hamulca zasadniczego, uzywane do hamulca ED w EP09 - virtual void SetED(double EDstate); //stan hamulca ED do luzowania - - inline TLSt(double i_mbp, double i_bcr, double i_bcd, double i_brc, - int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) : TESt4R(i_mbp, i_bcr, i_bcd, i_brc, i_bcn - , i_BD, i_mat, i_ba, i_nbpa) - { - } - }; - - - - class TEStED : public TLSt //zawor z EP09 - Est4 z oddzielnym przekladnikiem, kontrola rapidu i takie tam - - { - private: - double Nozzles[11]; //dysze - bool Zamykajacy; //pamiec zaworka zamykajacego - bool Przys_blok; //blokada przyspieszacza - TReservoir *Miedzypoj; //pojemnosc posrednia (urojona) do napelniania ZP i ZS - double TareM; double LoadM; //masa proznego i pelnego - double TareBP; //cisnienie dla proznego - double LoadC; - - - public: - void Init(double PP, double HPP, double LPP, double BP, int BDF)/*override*/; - double GetPF(double PP, double dt, double Vel)/*override*/; //przeplyw miedzy komora wstepna i PG - double GetEDBCP()/*override*/; //cisnienie tylko z hamulca zasadniczego, uzywane do hamulca ED - void PLC(double mass); //wspolczynnik cisnienia przystawki wazacej - void SetLP(double TM, double LM, double TBP); //parametry przystawki wazacej - - inline TEStED(double i_mbp, double i_bcr, double i_bcd, double i_brc - , int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) : TLSt(i_mbp, i_bcr, i_bcd, i_brc, i_bcn - , i_BD, i_mat, i_ba, i_nbpa) - { - Przys_blok = false; - TareM, TareBP, LoadM, LoadC = 0.0; - Miedzypoj = new TReservoir(); - } - }; - - - - class TEStEP2 : public TLSt - - { - private: - double TareM; double LoadM; //masa proznego i pelnego - double TareBP; //cisnienie dla proznego - double LoadC; - double EPS; - - - public: - void Init(double PP, double HPP, double LPP, double BP, int BDF)/*override*/; //inicjalizacja - double GetPF(double PP, double dt, double Vel)/*override*/; //przeplyw miedzy komora wstepna i PG - void PLC(double mass); //wspolczynnik cisnienia przystawki wazacej - void SetEPS(double nEPS)/*override*/; //stan hamulca EP - void SetLP(double TM, double LM, double TBP); //parametry przystawki wazacej - - inline TEStEP2(double i_mbp, double i_bcr, double i_bcd, double i_brc - , int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) : TLSt(i_mbp, i_bcr, i_bcd, i_brc, i_bcn - , i_BD, i_mat, i_ba, i_nbpa) - { - TareM, TareBP, LoadM, LoadC, EPS = 0.0; - } - }; - - - - class TCV1 : public TBrake - - { - private: - double BVM; //przelozenie PG-CH - - - protected: - TReservoir *CntrlRes; //zbiornik sterujący - - public: - void Init(double PP, double HPP, double LPP, double BP, int BDF)/*override*/; - double GetPF(double PP, double dt, double Vel)/*override*/; //przeplyw miedzy komora wstepna i PG - double GetCRP()/*override*/; - void CheckState(double BCP, double & dV1); - double CVs(double BP); - double BVs(double BCP); - - inline TCV1(double i_mbp, double i_bcr, double i_bcd, double i_brc, - int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) : TBrake(i_mbp, i_bcr, i_bcd, i_brc, i_bcn - , i_BD, i_mat, i_ba, i_nbpa) - { - CntrlRes = new TReservoir(); - } - }; - - - - //class TCV1R : public TCV1 - - //{ - //private: - // TReservoir *ImplsRes; //komora impulsowa - // bool RapidStatus; - - //public: - // // function GetPF(PP, dt, Vel: real): real; override; //przeplyw miedzy komora wstepna i PG - // // procedure Init(PP, HPP, LPP, BP: real; BDF: int); override; - - // inline TCV1R(double i_mbp, double i_bcr, double i_bcd, double i_brc, - // int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa, - // double PP, double HPP, double LPP, double BP, int BDF) : TCV1(i_mbp, i_bcr, i_bcd, i_brc, i_bcn - // , i_BD, i_mat, i_ba, i_nbpa, PP, HPP, LPP, BP, BDF) { } - //}; - - - - class TCV1L_TR : public TCV1 - - { - private: - TReservoir *ImplsRes; //komora impulsowa - double LBP; //cisnienie hamulca pomocniczego - - - public: - void Init(double PP, double HPP, double LPP, double BP, int BDF)/*override*/; - double GetPF(double PP, double dt, double Vel)/*override*/; //przeplyw miedzy komora wstepna i PG - void SetLBP(double P); //cisnienie z hamulca pomocniczego - double GetHPFlow(double HP, double dt)/*override*/; //przeplyw - 8 bar - - inline TCV1L_TR(double i_mbp, double i_bcr, double i_bcd, double i_brc - , int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) : TCV1(i_mbp, i_bcr, i_bcd, i_brc, i_bcn - , i_BD, i_mat, i_ba, i_nbpa) - { - LBP = 0.0; - ImplsRes = new TReservoir(); - } - }; - - - - class TKE : public TBrake //Knorr Einheitsbauart — jeden do wszystkiego - - { - private: - bool RapidStatus; - TReservoir *ImplsRes; //komora impulsowa - TReservoir *CntrlRes; //zbiornik sterujący - TReservoir *Brak2Res; //zbiornik pomocniczy 2 - double BVM; //przelozenie PG-CH - double TareM; double LoadM; //masa proznego i pelnego - double TareBP; //cisnienie dla proznego - double LoadC; //wspolczynnik zaladowania - double RM; //przelozenie rapida - double LBP; //cisnienie hamulca pomocniczego - - - public: - void Init(double PP, double HPP, double LPP, double BP, int BDF)/*override*/; - void SetRM(double RMR); //ustalenie przelozenia rapida - double GetPF(double PP, double dt, double Vel)/*override*/; //przeplyw miedzy komora wstepna i PG - double GetHPFlow(double HP, double dt)/*override*/; //przeplyw - 8 bar - double GetCRP()/*override*/; - void CheckState(double BCP, double & dV1); - void CheckReleaser(double dt); //odluzniacz - double CVs(double BP); //napelniacz sterujacego - double BVs(double BCP); //napelniacz pomocniczego - void PLC(double mass); //wspolczynnik cisnienia przystawki wazacej - void SetLP(double TM, double LM, double TBP); //parametry przystawki wazacej - void SetLBP(double P); //cisnienie z hamulca pomocniczego - - inline TKE(double i_mbp, double i_bcr, double i_bcd, double i_brc, int - i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) : TBrake(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, - i_BD, i_mat, i_ba, i_nbpa) - { - RapidStatus = false; - TareM, TareBP, LoadM, LoadC, RM, LBP = 0.0; - ImplsRes = new TReservoir(); - CntrlRes = new TReservoir(); - Brak2Res = new TReservoir(); - } - }; - - - - - - //klasa obejmujaca krany - - - class TDriverHandle - { - private: - // BCP: integer; - - public: - bool Time; - bool TimeEP; - double Sounds[5]; //wielkosci przeplywow dla dzwiekow - virtual double GetPF(double i_bcp, double PP, double HP, double dt, double ep); - virtual void Init(double Press); - virtual double GetCP(); - virtual void SetReductor(double nAdj); - virtual double GetSound(int i); - virtual double GetPos(int i); - virtual double GetEP(double pos); - - }; - - - - class TFV4a : public TDriverHandle - - { - private: - double CP; double TP; double RP; //zbiornik sterujący, czasowy, redukcyjny - - public: - double GetPF(double i_bcp, double PP, double HP, double dt, double ep)/*override*/; - void Init(double Press)/*override*/; - - inline TFV4a(void) : TDriverHandle() { } - - }; - - - - class TFV4aM : public TDriverHandle - - { - private: - double CP; double TP; double RP; //zbiornik sterujący, czasowy, redukcyjny - double XP; //komora powietrzna w reduktorze — jest potrzebna do odwzorowania fali - double RedAdj; //dostosowanie reduktora cisnienia (krecenie kapturkiem) +static int const LocalBrakePosNo = 10; /*ilosc nastaw hamulca recznego lub pomocniczego*/ +static int const MainBrakeMaxPos = 10; /*max. ilosc nastaw hamulca zasadniczego*/ + +/*nastawy hamulca*/ +static int const bdelay_G = 1; // G +static int const bdelay_P = 2; // P +static int const bdelay_R = 4; // R +static int const bdelay_M = 8; // Mg +static int const bdelay_GR = 128; // G-R + +/*stan hamulca*/ +static int const b_off = 0; // luzowanie +static int const b_hld = 1; // trzymanie +static int const b_on = 2; // napelnianie +static int const b_rfl = 4; // uzupelnianie +static int const b_rls = 8; // odluzniacz +static int const b_ep = 16; // elektropneumatyczny +static int const b_asb = 32; // elektropneumatyczny +static int const b_dmg = 128; // wylaczony z dzialania + +/*uszkodzenia hamulca*/ +static int const df_on = 1; // napelnianie +static int const df_off = 2; // luzowanie +static int const df_br = 4; // wyplyw z ZP +static int const df_vv = 8; // wyplyw z komory wstepnej +static int const df_bc = 16; // wyplyw z silownika +static int const df_cv = 32; // wyplyw z ZS +static int const df_PP = 64; // zawsze niski stopien +static int const df_RR = 128; // zawsze wysoki stopien + +/*indeksy dzwiekow FV4a*/ +static int const s_fv4a_b = 0; // hamowanie +static int const s_fv4a_u = 1; // luzowanie +static int const s_fv4a_e = 2; // hamowanie nagle +static int const s_fv4a_x = 3; // wyplyw sterujacego fala +static int const s_fv4a_t = 4; // wyplyw z czasowego + +/*pary cierne*/ +static int const bp_P10 = 0; +static int const bp_P10Bg = 2; //żeliwo fosforowe P10 +static int const bp_P10Bgu = 1; +static int const bp_LLBg = 4; // komp. b.n.t. +static int const bp_LLBgu = 3; +static int const bp_LBg = 6; // komp. n.t. +static int const bp_LBgu = 5; +static int const bp_KBg = 8; // komp. w.t. +static int const bp_KBgu = 7; +static int const bp_D1 = 9; // tarcze +static int const bp_D2 = 10; +static int const bp_FR513 = 11; // Frenoplast FR513 +static int const bp_Cosid = 12; // jakistam kompozyt :D +static int const bp_PKPBg = 13; //żeliwo PKP +static int const bp_PKPBgu = 14; +static int const bp_MHS = 128; // magnetyczny hamulec szynowy +static int const bp_P10yBg = 15; //żeliwo fosforowe P10 +static int const bp_P10yBgu = 16; +static int const bp_FR510 = 17; // Frenoplast FR510 + +static int const sf_Acc = 1; // przyspieszacz +static int const sf_BR = 2; // przekladnia +static int const sf_CylB = 4; // cylinder - napelnianie +static int const sf_CylU = 8; // cylinder - oproznianie +static int const sf_rel = 16; // odluzniacz +static int const sf_ep = 32; // zawory ep + +static int const bh_MIN = 0; // minimalna pozycja +static int const bh_MAX = 1; // maksymalna pozycja +static int const bh_FS = 2; // napelnianie uderzeniowe //jesli nie ma, to jazda +static int const bh_RP = 3; // jazda +static int const bh_NP = 4; // odciecie - podwojna trakcja +static int const bh_MB = 5; // odciecie - utrzymanie stopnia hamowania/pierwszy 1 stopien hamowania +static int const bh_FB = 6; // pelne +static int const bh_EB = 7; // nagle +static int const bh_EPR = 8; // ep - luzowanie //pelny luz dla ep kątowego +static int const bh_EPN = 9; // ep - utrzymanie //jesli rowne luzowaniu, wtedy sterowanie + // przyciskiem +static int const bh_EPB = 10; // ep - hamowanie //pelne hamowanie dla ep kątowego + +static double const SpgD = 0.7917; +static double const SpO = 0.5067; // przekroj przewodu 1" w l/m +// wyj: jednostka dosyc dziwna, ale wszystkie obliczenia +// i pojemnosci sa podane w litrach (rozsadne wielkosci) +// zas dlugosc pojazdow jest podana w metrach +// a predkosc przeplywu w m/s //3.5 +// 7//1.5 +// BPT: array[-2..6] of array [0..1] of real= ((0, 5.0), (14, 5.4), (9, 5.0), (6, 4.6), (9, 4.5), +// (9, 4.0), (9, 3.5), (9, 2.8), (34, 2.8)); +// BPT: array[-2..6] of array [0..1] of real= ((0, 5.0), (7, 5.0), (2.0, 5.0), (4.5, 4.6), (4.5, +// 4.2), (4.5, 3.8), (4.5, 3.4), (4.5, 2.8), (8, 2.8)); +static double BPT[9][2] = {{0, 5.0}, {7, 5.0}, {2.0, 5.0}, {4.5, 4.6}, {4.5, 4.2}, + {4.5, 3.8}, {4.5, 3.4}, {4.5, 2.8}, {8, 2.8}}; +static double BPT_394[7][2] = {{13, 10.0}, {5, 5.0}, {0, -1}, {5, -1}, + {5, 0.0}, {5, 0.0}, {18, 0.0}}; +// double *BPT = zero_based_BPT[2]; //tablica pozycji hamulca dla zakresu -2..6 +// double *BPT_394 = zero_based_BPT_394[1]; //tablica pozycji hamulca dla zakresu -1..5 +// BPT: array[-2..6] of array [0..1] of real= ((0, 5.0), (12, 5.4), (9, 5.0), (9, 4.6), (9, 4.2), +// (9, 3.8), (9, 3.4), (9, 2.8), (34, 2.8)); +// BPT: array[-2..6] of array [0..1] of real= ((0, 0),(0, 0),(0, 0),(0, 0),(0, 0),(0, 0),(0, +// 0),(0, 0),(0, 0)); +static int const i_bcpno = 6; +// static double const pi = 3.141592653589793; //definicja w mctools + +// klasa obejmujaca pojedyncze zbiorniki + +class TReservoir +{ + protected: + double Cap; + double Vol; + double dVol; + + public: + TReservoir(); + void CreateCap(double Capacity); + void CreatePress(double Press); + virtual double pa(); + virtual double P(); + void Flow(double dv); + void Act(); +}; + +typedef TReservoir *PReservoir; + +class TBrakeCyl : public TReservoir + +{ + public: + virtual double pa() /*override*/; + virtual double P() /*override*/; + TBrakeCyl() : TReservoir(){}; +}; + +// klasa obejmujaca uklad hamulca zespolonego pojazdu + +class TBrake +{ + protected: + TReservoir *BrakeCyl; // silownik + TReservoir *BrakeRes; // ZP + TReservoir *ValveRes; // komora wstepna + int BCN; // ilosc silownikow + double BCM; // przekladnia hamulcowa + double BCA; // laczny przekroj silownikow + int BrakeDelays; // dostepne opoznienia + int BrakeDelayFlag; // aktualna nastawa + TFricMat *FM; // material cierny + double MaxBP; // najwyzsze cisnienie + int BA; // osie hamowane + int NBpA; // klocki na os + double SizeBR; // rozmiar^2 ZP (w stosunku do 14") + double SizeBC; // rozmiar^2 CH (w stosunku do 14") + bool DCV; // podwojny zawor zwrotny + double ASBP; // cisnienie hamulca pp + + int BrakeStatus; // flaga stanu + int SoundFlag; + + public: + TBrake(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, int i_mat, + int i_ba, int i_nbpa); + // maksymalne cisnienie, promien, skok roboczy, pojemnosc ZP; + // ilosc cylindrow, opoznienia hamulca, material klockow, osie hamowane, klocki na os; + virtual void Init(double PP, double HPP, double LPP, double BP, + int BDF); // inicjalizacja hamulca + + double GetFC(double Vel, double N); // wspolczynnik tarcia - hamulec wie lepiej + virtual double GetPF(double PP, double dt, double Vel); // przeplyw miedzy komora wstepna i PG + double GetBCF(); // sila tlokowa z tloka + virtual double GetHPFlow(double HP, double dt); // przeplyw - 8 bar + double GetBCP(); // cisnienie cylindrow hamulcowych + virtual double + GetEDBCP(); // cisnienie tylko z hamulca zasadniczego, uzywane do hamulca ED w EP09 + double GetBRP(); // cisnienie zbiornika pomocniczego + double GetVRP(); // cisnienie komory wstepnej rozdzielacza + virtual double GetCRP(); // cisnienie zbiornika sterujacego + bool SetBDF(int nBDF); // nastawiacz GPRM + void Releaser(int state); // odluzniacz + virtual void SetEPS(double nEPS); // hamulec EP + virtual void SetRM(double RMR){}; // ustalenie przelozenia rapida + virtual void SetLP(double TM, double LM, double TBP){}; // parametry przystawki wazacej + virtual void SetLBP(double P){}; // cisnienie z hamulca pomocniczego + virtual void PLC(double mass){}; // wspolczynnik cisnienia przystawki wazacej + void ASB(int state); // hamulec przeciwposlizgowy + int GetStatus(); // flaga statusu, moze sie przydac do odglosow + void SetASBP(double Press); // ustalenie cisnienia pp + virtual void ForceEmptiness(); + int GetSoundFlag(); + virtual void SetED(double EDstate){}; // stan hamulca ED do luzowania + + // procedure +}; + +class TWest : public TBrake + +{ + private: + double LBP; // cisnienie hamulca pomocniczego + double dVP; // pobor powietrza wysokiego cisnienia + double EPS; // stan elektropneumatyka + double TareM; + double LoadM; // masa proznego i pelnego + double TareBP; // cisnienie dla proznego + double LoadC; // wspolczynnik przystawki wazacej + + public: + void Init(double PP, double HPP, double LPP, double BP, int BDF) /*override*/; + void SetLBP(double P); // cisnienie z hamulca pomocniczego + double GetPF(double PP, double dt, + double Vel) /*override*/; // przeplyw miedzy komora wstepna i PG + double GetHPFlow(double HP, double dt) /*override*/; + void PLC(double mass); // wspolczynnik cisnienia przystawki wazacej + void SetEPS(double nEPS) /*override*/; // stan hamulca EP + void SetLP(double TM, double LM, double TBP); // parametry przystawki wazacej + + inline TWest(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, + int i_mat, int i_ba, int i_nbpa) + : TBrake(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa) + { + LBP, dVP, EPS, TareM, TareBP, LoadM, LoadC = 0.0; + } +}; + +class TESt : public TBrake + +{ + private: + protected: + TReservoir *CntrlRes; // zbiornik sterujący + double BVM; // przelozenie PG-CH + + public: + void Init(double PP, double HPP, double LPP, double BP, int BDF) /*override*/; + double GetPF(double PP, double dt, + double Vel) /*override*/; // przeplyw miedzy komora wstepna i PG + void EStParams(double i_crc); // parametry charakterystyczne dla ESt + double GetCRP() /*override*/; + void CheckState(double BCP, double &dV1); // glowny przyrzad rozrzadczy + void CheckReleaser(double dt); // odluzniacz + double CVs(double BP); // napelniacz sterujacego + double BVs(double BCP); // napelniacz pomocniczego + + inline TESt(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, + int i_mat, int i_ba, int i_nbpa) + : TBrake(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa) + { + CntrlRes = new TReservoir(); + } +}; + +class TESt3 : public TESt + +{ + private: + // double CylFlowSpeed[2][2]; //zmienna nie uzywana + + public: + double GetPF(double PP, double dt, + double Vel) /*override*/; // przeplyw miedzy komora wstepna i PG + + inline TESt3(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, + int i_mat, int i_ba, int i_nbpa) + : TESt(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa) + { + } +}; + +class TESt3AL2 : public TESt3 + +{ + private: + double TareM; + double LoadM; // masa proznego i pelnego + double TareBP; // cisnienie dla proznego + double LoadC; + + public: + TReservoir *ImplsRes; // komora impulsowa + void Init(double PP, double HPP, double LPP, double BP, int BDF) /*override*/; + double GetPF(double PP, double dt, + double Vel) /*override*/; // przeplyw miedzy komora wstepna i PG + void PLC(double mass); // wspolczynnik cisnienia przystawki wazacej + void SetLP(double TM, double LM, double TBP); // parametry przystawki wazacej + + inline TESt3AL2(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, + int i_mat, int i_ba, int i_nbpa) + : TESt3(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa) + { + TareM, TareBP, LoadM, LoadC = 0.0; + } +}; + +class TESt4R : public TESt + +{ + private: + bool RapidStatus; + + protected: + TReservoir *ImplsRes; // komora impulsowa + double RapidTemp; // aktualne, zmienne przelozenie + + public: + void Init(double PP, double HPP, double LPP, double BP, int BDF) /*override*/; + double GetPF(double PP, double dt, + double Vel) /*override*/; // przeplyw miedzy komora wstepna i PG + + inline TESt4R(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, + int i_mat, int i_ba, int i_nbpa) + : TESt(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa) + { + RapidTemp = 0.0; + ImplsRes = new TReservoir(); + } +}; + +class TLSt : public TESt4R + +{ + private: + // double CylFlowSpeed[2][2]; // zmienna nie używana + + protected: + double LBP; // cisnienie hamulca pomocniczego + double RM; // przelozenie rapida + double EDFlag; // luzowanie hamulca z powodu zalaczonego ED + + public: + void Init(double PP, double HPP, double LPP, double BP, int BDF) /*override*/; + void SetLBP(double P); // cisnienie z hamulca pomocniczego + void SetRM(double RMR); // ustalenie przelozenia rapida + double GetPF(double PP, double dt, + double Vel) /*override*/; // przeplyw miedzy komora wstepna i PG + double GetHPFlow(double HP, double dt) /*override*/; // przeplyw - 8 bar + virtual double + GetEDBCP(); // cisnienie tylko z hamulca zasadniczego, uzywane do hamulca ED w EP09 + virtual void SetED(double EDstate); // stan hamulca ED do luzowania + + inline TLSt(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, + int i_mat, int i_ba, int i_nbpa) + : TESt4R(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa) + { + } +}; + +class TEStED + : public TLSt // zawor z EP09 - Est4 z oddzielnym przekladnikiem, kontrola rapidu i takie tam + +{ + private: + double Nozzles[11]; // dysze + bool Zamykajacy; // pamiec zaworka zamykajacego + bool Przys_blok; // blokada przyspieszacza + TReservoir *Miedzypoj; // pojemnosc posrednia (urojona) do napelniania ZP i ZS + double TareM; + double LoadM; // masa proznego i pelnego + double TareBP; // cisnienie dla proznego + double LoadC; + + public: + void Init(double PP, double HPP, double LPP, double BP, int BDF) /*override*/; + double GetPF(double PP, double dt, + double Vel) /*override*/; // przeplyw miedzy komora wstepna i PG + double GetEDBCP() /*override*/; // cisnienie tylko z hamulca zasadniczego, uzywane do hamulca ED + void PLC(double mass); // wspolczynnik cisnienia przystawki wazacej + void SetLP(double TM, double LM, double TBP); // parametry przystawki wazacej + + inline TEStED(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, + int i_mat, int i_ba, int i_nbpa) + : TLSt(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa) + { + Przys_blok = false; + TareM, TareBP, LoadM, LoadC = 0.0; + Miedzypoj = new TReservoir(); + } +}; + +class TEStEP2 : public TLSt + +{ + private: + double TareM; + double LoadM; // masa proznego i pelnego + double TareBP; // cisnienie dla proznego + double LoadC; + double EPS; + + public: + void Init(double PP, double HPP, double LPP, double BP, int BDF) /*override*/; // inicjalizacja + double GetPF(double PP, double dt, + double Vel) /*override*/; // przeplyw miedzy komora wstepna i PG + void PLC(double mass); // wspolczynnik cisnienia przystawki wazacej + void SetEPS(double nEPS) /*override*/; // stan hamulca EP + void SetLP(double TM, double LM, double TBP); // parametry przystawki wazacej + + inline TEStEP2(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, + int i_mat, int i_ba, int i_nbpa) + : TLSt(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa) + { + TareM, TareBP, LoadM, LoadC, EPS = 0.0; + } +}; + +class TCV1 : public TBrake + +{ + private: + double BVM; // przelozenie PG-CH + + protected: + TReservoir *CntrlRes; // zbiornik sterujący + + public: + void Init(double PP, double HPP, double LPP, double BP, int BDF) /*override*/; + double GetPF(double PP, double dt, + double Vel) /*override*/; // przeplyw miedzy komora wstepna i PG + double GetCRP() /*override*/; + void CheckState(double BCP, double &dV1); + double CVs(double BP); + double BVs(double BCP); + + inline TCV1(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, + int i_mat, int i_ba, int i_nbpa) + : TBrake(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa) + { + CntrlRes = new TReservoir(); + } +}; + +// class TCV1R : public TCV1 + +//{ +// private: +// TReservoir *ImplsRes; //komora impulsowa +// bool RapidStatus; + +// public: +// // function GetPF(PP, dt, Vel: real): real; override; //przeplyw miedzy komora +//wstepna i PG +// // procedure Init(PP, HPP, LPP, BP: real; BDF: int); override; + +// inline TCV1R(double i_mbp, double i_bcr, double i_bcd, double i_brc, +// int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa, +// double PP, double HPP, double LPP, double BP, int BDF) : TCV1(i_mbp, i_bcr, i_bcd, +//i_brc, i_bcn +// , i_BD, i_mat, i_ba, i_nbpa, PP, HPP, LPP, BP, BDF) { } +//}; + +class TCV1L_TR : public TCV1 + +{ + private: + TReservoir *ImplsRes; // komora impulsowa + double LBP; // cisnienie hamulca pomocniczego + + public: + void Init(double PP, double HPP, double LPP, double BP, int BDF) /*override*/; + double GetPF(double PP, double dt, + double Vel) /*override*/; // przeplyw miedzy komora wstepna i PG + void SetLBP(double P); // cisnienie z hamulca pomocniczego + double GetHPFlow(double HP, double dt) /*override*/; // przeplyw - 8 bar + + inline TCV1L_TR(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, + int i_mat, int i_ba, int i_nbpa) + : TCV1(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa) + { + LBP = 0.0; + ImplsRes = new TReservoir(); + } +}; + +class TKE : public TBrake // Knorr Einheitsbauart — jeden do wszystkiego + +{ + private: + bool RapidStatus; + TReservoir *ImplsRes; // komora impulsowa + TReservoir *CntrlRes; // zbiornik sterujący + TReservoir *Brak2Res; // zbiornik pomocniczy 2 + double BVM; // przelozenie PG-CH + double TareM; + double LoadM; // masa proznego i pelnego + double TareBP; // cisnienie dla proznego + double LoadC; // wspolczynnik zaladowania + double RM; // przelozenie rapida + double LBP; // cisnienie hamulca pomocniczego + + public: + void Init(double PP, double HPP, double LPP, double BP, int BDF) /*override*/; + void SetRM(double RMR); // ustalenie przelozenia rapida + double GetPF(double PP, double dt, + double Vel) /*override*/; // przeplyw miedzy komora wstepna i PG + double GetHPFlow(double HP, double dt) /*override*/; // przeplyw - 8 bar + double GetCRP() /*override*/; + void CheckState(double BCP, double &dV1); + void CheckReleaser(double dt); // odluzniacz + double CVs(double BP); // napelniacz sterujacego + double BVs(double BCP); // napelniacz pomocniczego + void PLC(double mass); // wspolczynnik cisnienia przystawki wazacej + void SetLP(double TM, double LM, double TBP); // parametry przystawki wazacej + void SetLBP(double P); // cisnienie z hamulca pomocniczego + + inline TKE(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, + int i_mat, int i_ba, int i_nbpa) + : TBrake(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa) + { + RapidStatus = false; + TareM, TareBP, LoadM, LoadC, RM, LBP = 0.0; + ImplsRes = new TReservoir(); + CntrlRes = new TReservoir(); + Brak2Res = new TReservoir(); + } +}; + +// klasa obejmujaca krany + +class TDriverHandle +{ + private: + // BCP: integer; + + public: + bool Time; + bool TimeEP; + double Sounds[5]; // wielkosci przeplywow dla dzwiekow + virtual double GetPF(double i_bcp, double PP, double HP, double dt, double ep); + virtual void Init(double Press); + virtual double GetCP(); + virtual void SetReductor(double nAdj); + virtual double GetSound(int i); + virtual double GetPos(int i); + virtual double GetEP(double pos); +}; + +class TFV4a : public TDriverHandle + +{ + private: + double CP; + double TP; + double RP; // zbiornik sterujący, czasowy, redukcyjny + + public: + double GetPF(double i_bcp, double PP, double HP, double dt, double ep) /*override*/; + void Init(double Press) /*override*/; + + inline TFV4a(void) : TDriverHandle() + { + } +}; + +class TFV4aM : public TDriverHandle + +{ + private: + double CP; + double TP; + double RP; // zbiornik sterujący, czasowy, redukcyjny + double XP; // komora powietrzna w reduktorze — jest potrzebna do odwzorowania fali + double RedAdj; // dostosowanie reduktora cisnienia (krecenie kapturkiem) + // Sounds: array[0..4] of real; //wielkosci przeplywow dla dzwiekow + bool Fala; + // double pos_table[]; + // double *pos_table; // = { -2, 6, -1, 0, -2, 1, 4, 6, 0, 0, 0 }; + static double pos_table[11]; + double LPP_RP(double pos); + bool EQ(double pos, double i_pos); + + public: + double GetPF(double i_bcp, double PP, double HP, double dt, double ep) /*override*/; + void Init(double Press) /*override*/; + void SetReductor(double nAdj) /*override*/; + double GetSound(int i) /*override*/; + double GetPos(int i) /*override*/; + + inline TFV4aM(void) : TDriverHandle() + { + } +}; + +class TMHZ_EN57 : public TDriverHandle + +{ + private: + double CP; + double TP; + double RP; // zbiornik sterujący, czasowy, redukcyjny + double RedAdj; // dostosowanie reduktora cisnienia (krecenie kapturkiem) + bool Fala; + // const double pos_table[11] = { -2, 10, -1, 0, 0, 2, 9, 10, 0, 0, 0 }; + static double pos_table[11]; //= { 0, 12, 1, 2, 2, 4, 11, 12, 2, 2, 2 }; + double LPP_RP(double pos); + bool EQ(double pos, double i_pos); + + public: + double GetPF(double i_bcp, double PP, double HP, double dt, double ep) /*override*/; + void Init(double Press) /*override*/; + void SetReductor(double nAdj) /*override*/; + double GetSound(int i) /*override*/; + double GetPos(int i) /*override*/; + double GetCP() /*override*/; + double GetEP(double pos); + + inline TMHZ_EN57(void) : TDriverHandle() + { + } +}; + +/* FBS2= class(TTDriverHandle) + private + CP, TP, RP: real; //zbiornik sterujący, czasowy, redukcyjny + XP: real; //komora powietrzna w reduktorze — jest potrzebna do +odwzorowania fali + RedAdj: real; //dostosowanie reduktora cisnienia (krecenie kapturkiem) // Sounds: array[0..4] of real; //wielkosci przeplywow dla dzwiekow - bool Fala; - //double pos_table[]; - // double *pos_table; // = { -2, 6, -1, 0, -2, 1, 4, 6, 0, 0, 0 }; - static double pos_table[11]; - double LPP_RP(double pos); - bool EQ(double pos, double i_pos); - public: - double GetPF(double i_bcp, double PP, double HP, double dt, double ep)/*override*/; - void Init(double Press)/*override*/; - void SetReductor(double nAdj)/*override*/; - double GetSound(int i)/*override*/; - double GetPos(int i)/*override*/; + Fala: boolean; + public + function GetPF(i_bcp:real; pp, hp, dt, ep: real): real; override; + procedure Init(press: real); override; + procedure SetReductor(nAdj: real); override; + function GetSound(i: int): real; override; + function GetPos(i: int): real; override; + end; */ - inline TFV4aM(void) : TDriverHandle() { } - }; +/* TD2= class(TTDriverHandle) + private + CP, TP, RP: real; //zbiornik sterujący, czasowy, redukcyjny + XP: real; //komora powietrzna w reduktorze — jest potrzebna do +odwzorowania fali + RedAdj: real; //dostosowanie reduktora cisnienia (krecenie kapturkiem) +// Sounds: array[0..4] of real; //wielkosci przeplywow dla dzwiekow + Fala: boolean; + public + function GetPF(i_bcp:real; pp, hp, dt, ep: real): real; override; + procedure Init(press: real); override; + procedure SetReductor(nAdj: real); override; + function GetSound(i: int): real; override; + function GetPos(i: int): real; override; + end;*/ +class TM394 : public TDriverHandle +{ + private: + double CP; // zbiornik sterujący, czasowy, redukcyjny + double RedAdj; // dostosowanie reduktora cisnienia (krecenie kapturkiem) + // double const pos_table[11] = { -1, 5, -1, 0, 1, 2, 4, 5, 0, 0, 0 }; + static double pos_table[11]; // = { 0, 6, 0, 1, 2, 3, 5, 6, 1, 1, 1 }; - class TMHZ_EN57 : public TDriverHandle + public: + double GetPF(double i_bcp, double PP, double HP, double dt, double ep) /*override*/; + void Init(double Press) /*override*/; + void SetReductor(double nAdj) /*override*/; + double GetCP() /*override*/; + double GetPos(int i) /*override*/; - { - private: - double CP; double TP; double RP; //zbiornik sterujący, czasowy, redukcyjny - double RedAdj; //dostosowanie reduktora cisnienia (krecenie kapturkiem) - bool Fala; - // const double pos_table[11] = { -2, 10, -1, 0, 0, 2, 9, 10, 0, 0, 0 }; - static double pos_table[11]; //= { 0, 12, 1, 2, 2, 4, 11, 12, 2, 2, 2 }; - double LPP_RP(double pos); - bool EQ(double pos, double i_pos); + inline TM394(void) : TDriverHandle() + { + } +}; - public: - double GetPF(double i_bcp, double PP, double HP, double dt, double ep)/*override*/; - void Init(double Press)/*override*/; - void SetReductor(double nAdj)/*override*/; - double GetSound(int i)/*override*/; - double GetPos(int i)/*override*/; - double GetCP()/*override*/; - double GetEP(double pos); +class TH14K1 : public TDriverHandle - inline TMHZ_EN57(void) : TDriverHandle() { } - }; +{ + private: + double static BPT_K[/*?*/ /*-1..4*/ (4) - (-1) + 1][2]; + // double const table[11] = { -1, 4, -1, 0, 1, 2, 3, 4, 0, 0, 0 }; + double static pos_table[11]; // = { 0, 5, 0, 1, 2, 3, 4, 5, 1, 1, 1 }; + protected: + double CP; // zbiornik sterujący, czasowy, redukcyjny + double RedAdj; // dostosowanie reduktora cisnienia (krecenie kapturkiem) + public: + double GetPF(double i_bcp, double PP, double HP, double dt, double ep) /*override*/; + void Init(double Press) /*override*/; + void SetReductor(double nAdj) /*override*/; + double GetCP() /*override*/; + double GetPos(int i) /*override*/; + inline TH14K1(void) : TDriverHandle() + { + } +}; - /* FBS2= class(TTDriverHandle) - private - CP, TP, RP: real; //zbiornik sterujący, czasowy, redukcyjny - XP: real; //komora powietrzna w reduktorze — jest potrzebna do odwzorowania fali - RedAdj: real; //dostosowanie reduktora cisnienia (krecenie kapturkiem) - // Sounds: array[0..4] of real; //wielkosci przeplywow dla dzwiekow - Fala: boolean; - public - function GetPF(i_bcp:real; pp, hp, dt, ep: real): real; override; - procedure Init(press: real); override; - procedure SetReductor(nAdj: real); override; - function GetSound(i: int): real; override; - function GetPos(i: int): real; override; - end; */ +class TSt113 : public TH14K1 - /* TD2= class(TTDriverHandle) - private - CP, TP, RP: real; //zbiornik sterujący, czasowy, redukcyjny - XP: real; //komora powietrzna w reduktorze — jest potrzebna do odwzorowania fali - RedAdj: real; //dostosowanie reduktora cisnienia (krecenie kapturkiem) - // Sounds: array[0..4] of real; //wielkosci przeplywow dla dzwiekow - Fala: boolean; - public - function GetPF(i_bcp:real; pp, hp, dt, ep: real): real; override; - procedure Init(press: real); override; - procedure SetReductor(nAdj: real); override; - function GetSound(i: int): real; override; - function GetPos(i: int): real; override; - end;*/ +{ + private: + double EPS; + double static BPT_K[/*?*/ /*-1..4*/ (4) - (-1) + 1][2]; + double static BEP_K[/*?*/ /*-1..5*/ (5) - (-1) + 1]; + // double const pos_table[11] = { -1, 5, -1, 0, 2, 3, 4, 5, 0, 0, 1 }; + double static pos_table[11]; // = { 0, 6, 0, 1, 3, 4, 5, 6, 1, 1, 2 }; + public: + double GetPF(double i_bcp, double PP, double HP, double dt, double ep) /*override*/; + double GetCP() /*override*/; + double GetPos(int i) /*override*/; + void Init(double Press) /*override*/; - class TM394 : public TDriverHandle + inline TSt113(void) : TH14K1() + { + } +}; - { - private: - double CP; //zbiornik sterujący, czasowy, redukcyjny - double RedAdj; //dostosowanie reduktora cisnienia (krecenie kapturkiem) -// double const pos_table[11] = { -1, 5, -1, 0, 1, 2, 4, 5, 0, 0, 0 }; - static double pos_table[11]; // = { 0, 6, 0, 1, 2, 3, 5, 6, 1, 1, 1 }; +class Ttest : public TDriverHandle - public: - double GetPF(double i_bcp, double PP, double HP, double dt, double ep)/*override*/; - void Init(double Press)/*override*/; - void SetReductor(double nAdj)/*override*/; - double GetCP()/*override*/; - double GetPos(int i)/*override*/; +{ + private: + double CP; - inline TM394(void) : TDriverHandle() { } - }; + public: + double GetPF(double i_bcp, double PP, double HP, double dt, double ep) /*override*/; + void Init(double Press) /*override*/; + inline Ttest(void) : TDriverHandle() + { + } +}; +class TFD1 : public TDriverHandle - class TH14K1 : public TDriverHandle +{ + private: + double MaxBP; // najwyzsze cisnienie + double BP; // aktualne cisnienie - { - private: - double static BPT_K[/*?*/ /*-1..4*/ (4) - (-1) + 1][2]; -// double const table[11] = { -1, 4, -1, 0, 1, 2, 3, 4, 0, 0, 0 }; - double static pos_table[11]; // = { 0, 5, 0, 1, 2, 3, 4, 5, 1, 1, 1 }; - protected: - double CP; //zbiornik sterujący, czasowy, redukcyjny - double RedAdj; //dostosowanie reduktora cisnienia (krecenie kapturkiem) + public: + double Speed; // szybkosc dzialania + double GetPF(double i_bcp, double PP, double HP, double dt, double ep) /*override*/; + void Init(double Press) /*override*/; + double GetCP() /*override*/; + void SetSpeed(double nSpeed); + // procedure Init(press: real; MaxBP: real); overload; - public: - double GetPF(double i_bcp, double PP, double HP, double dt, double ep)/*override*/; - void Init(double Press)/*override*/; - void SetReductor(double nAdj)/*override*/; - double GetCP()/*override*/; - double GetPos(int i)/*override*/; + inline TFD1(void) : TDriverHandle() + { + } +}; - inline TH14K1(void) : TDriverHandle() { } - }; +class TH1405 : public TDriverHandle +{ + private: + double MaxBP; // najwyzsze cisnienie + double BP; // aktualne cisnienie + public: + double GetPF(double i_bcp, double PP, double HP, double dt, double ep) /*override*/; + void Init(double Press) /*override*/; + double GetCP() /*override*/; + // procedure Init(press: real; MaxBP: real); overload; - class TSt113 : public TH14K1 + inline TH1405(void) : TDriverHandle() + { + } +}; - { - private: - double EPS; - double static BPT_K[/*?*/ /*-1..4*/ (4) - (-1) + 1][2]; - double static BEP_K[/*?*/ /*-1..5*/ (5) - (-1) + 1]; -// double const pos_table[11] = { -1, 5, -1, 0, 2, 3, 4, 5, 0, 0, 1 }; - double static pos_table[11]; // = { 0, 6, 0, 1, 3, 4, 5, 6, 1, 1, 2 }; +class TFVel6 : public TDriverHandle - public: - double GetPF(double i_bcp, double PP, double HP, double dt, double ep)/*override*/; - double GetCP()/*override*/; - double GetPos(int i)/*override*/; - void Init(double Press)/*override*/; +{ + private: + double EPS; + // double const table[11] = { -1, 6, -1, 0, 6, 4, 4.7, 5, -1, 0, 1 }; + double static pos_table[11]; // = { -1, 6, -1, 0, 6, 4, 4.7, 5, -1, 0, 1 }; - inline TSt113(void) : TH14K1() { } - }; + public: + double GetPF(double i_bcp, double PP, double HP, double dt, double ep) /*override*/; + double GetCP() /*override*/; + double GetPos(int i) /*override*/; + double GetSound(int i) /*override*/; + void Init(double Press) /*override*/; + inline TFVel6(void) : TDriverHandle() + { + } +}; +extern double PF(double P1, double P2, double S, double DP = 0.25); +extern double PF1(double P1, double P2, double S); - class Ttest : public TDriverHandle +extern double PFVa(double PH, double PL, double S, double LIM, + double DP = 0.1); // zawor napelniajacy z PH do PL, PL do LIM +extern double PFVd(double PH, double PL, double S, double LIM, + double DP = 0.1); // zawor wypuszczajacy z PH do PL, PH do LIM - { - private: - double CP; - - public: - double GetPF(double i_bcp, double PP, double HP, double dt, double ep)/*override*/; - void Init(double Press)/*override*/; - - inline Ttest(void) : TDriverHandle() { } - }; - - - - class TFD1 : public TDriverHandle - - { - private: - double MaxBP; //najwyzsze cisnienie - double BP; //aktualne cisnienie - - public: - double Speed; //szybkosc dzialania - double GetPF(double i_bcp, double PP, double HP, double dt, double ep)/*override*/; - void Init(double Press)/*override*/; - double GetCP()/*override*/; - void SetSpeed(double nSpeed); - // procedure Init(press: real; MaxBP: real); overload; - - inline TFD1(void) : TDriverHandle() { } - }; - - - - class TH1405 : public TDriverHandle - - { - private: - double MaxBP; //najwyzsze cisnienie - double BP; //aktualne cisnienie - - public: - double GetPF(double i_bcp, double PP, double HP, double dt, double ep)/*override*/; - void Init(double Press)/*override*/; - double GetCP()/*override*/; - // procedure Init(press: real; MaxBP: real); overload; - - inline TH1405(void) : TDriverHandle() { } - }; - - - - - class TFVel6 : public TDriverHandle - - { - private: - double EPS; -// double const table[11] = { -1, 6, -1, 0, 6, 4, 4.7, 5, -1, 0, 1 }; - double static pos_table[11]; // = { -1, 6, -1, 0, 6, 4, 4.7, 5, -1, 0, 1 }; - - public: - double GetPF(double i_bcp, double PP, double HP, double dt, double ep)/*override*/; - double GetCP()/*override*/; - double GetPos(int i)/*override*/; - double GetSound(int i)/*override*/; - void Init(double Press)/*override*/; - - inline TFVel6(void) : TDriverHandle() { } - }; - - - extern double PF(double P1, double P2, double S, double DP = 0.25); - extern double PF1(double P1, double P2, double S); - - extern double PFVa(double PH, double PL, double S, double LIM, double DP = 0.1); //zawor napelniajacy z PH do PL, PL do LIM - extern double PFVd(double PH, double PL, double S, double LIM, double DP = 0.1); //zawor wypuszczajacy z PH do PL, PH do LIM - - extern long lround(double value); //zastepuje funkcje nieobecna w C++99 +extern long lround(double value); // zastepuje funkcje nieobecna w C++99 #if !defined(NO_IMPLICIT_NAMESPACE_USE) #endif -#endif//INCLUDED_HAMULCE_H -//END +#endif // INCLUDED_HAMULCE_H +// END diff --git a/mtable.cpp b/mtable.cpp index b5ce2492..a2cfa729 100644 --- a/mtable.cpp +++ b/mtable.cpp @@ -1,5 +1,5 @@ -/** @file - @brief +/** @file + @brief */ /* @@ -14,7 +14,7 @@ http://mozilla.org/MPL/2.0/. #include "mtable.h" #include -//using namespace Mtable; +// using namespace Mtable; TMTableTime *Mtable::GlobalTime; double CompareTime(double t1h, double t1m, double t2h, double t2m) /*roznica czasu w minutach*/ @@ -39,14 +39,14 @@ double CompareTime(double t1h, double t1m, double t2h, double t2m) /*roznica cza double TTrainParameters::CheckTrainLatency() { - if ((LastStationLatency > 1.0) || (LastStationLatency < 0)) - return LastStationLatency; /*spoznienie + lub do przodu - z tolerancja 1 min*/ + if ((LastStationLatency > 1.0) || (LastStationLatency < 0)) + return LastStationLatency; /*spoznienie + lub do przodu - z tolerancja 1 min*/ else return 0; } double TTrainParameters::WatchMTable(double DistCounter) -{ //zwraca odleglość do najblizszej stacji z zatrzymaniem +{ // zwraca odleglość do najblizszej stacji z zatrzymaniem double dist; if (Direction == 1) @@ -81,7 +81,8 @@ bool TTrainParameters::UpdateMTable(double hh, double mm, std::string NewName) { if (NewName == NextStationName) // jeśli dojechane do następnego { // Ra: wywołanie może być powtarzane, jak stoi na W4 - if (TimeTable[StationIndex + 1].km - TimeTable[StationIndex].km < 0) // to jest bez sensu + if (TimeTable[StationIndex + 1].km - TimeTable[StationIndex].km < + 0) // to jest bez sensu Direction = -1; else Direction = 1; // prowizorka bo moze byc zmiana kilometrazu @@ -187,7 +188,7 @@ void TTrainParameters::UpdateVelocity(int StationCount, double vActual) } } -//bool TTrainParameters::LoadTTfile(std::string scnpath, int iPlus, double vmax) +// bool TTrainParameters::LoadTTfile(std::string scnpath, int iPlus, double vmax) //{ // return false; //} @@ -216,10 +217,10 @@ bool TTrainParameters::LoadTTfile(std::string scnpath, int iPlus, double vmax) s = scnpath + TrainName + ".txt"; // Ra 2014-09: ustalić zasady wyznaczenia pierwotnego pliku przy przesuniętych rozkładach // (kolejny pociąg dostaje numer +2) - fin.open(s.c_str()); //otwieranie pliku - - if (!fin.is_open()) - { //jeśli nie ma pliku + fin.open(s.c_str()); // otwieranie pliku + + if (!fin.is_open()) + { // jeśli nie ma pliku vmax = atoi(TrainName.c_str()); // nie ma pliku ale jest liczba if ((vmax > 10) && (vmax < 200)) { @@ -235,91 +236,91 @@ bool TTrainParameters::LoadTTfile(std::string scnpath, int iPlus, double vmax) ConversionError = 0; while (fin.good() && !((ConversionError != 0) || EndTable)) { - std::getline(fin,lines); /*wczytanie linii*/ - if (lines.find("___________________") != std::string::npos) /*linia pozioma górna*/ - { - fin >> s; - if (s == "[") /*lewy pion*/ - { - fin >> s; - if (s == "Rodzaj") /*"Rodzaj i numer pociagu"*/ - do - { - fin >> s; - } while (!(s == "|") || (fin.eof())); /*środkowy pion*/ - } - } - else if (lines == "") - { - fin.close(); - break; - } - fin >> s; /*nazwa pociągu*/ + std::getline(fin, lines); /*wczytanie linii*/ + if (lines.find("___________________") != std::string::npos) /*linia pozioma górna*/ + { + fin >> s; + if (s == "[") /*lewy pion*/ + { + fin >> s; + if (s == "Rodzaj") /*"Rodzaj i numer pociagu"*/ + do + { + fin >> s; + } while (!(s == "|") || (fin.eof())); /*środkowy pion*/ + } + } + else if (lines == "") + { + fin.close(); + break; + } + fin >> s; /*nazwa pociągu*/ // if LowerCase(s)<>ExtractFileName(TrainName) then {musi być taka sama, jak nazwa // pliku} // ConversionError:=-7 {błąd niezgodności} TrainName = s; // nadanie nazwy z pliku TXT (bez ścieżki do pliku) // else { /*czytaj naglowek*/ - while(fin >> s || !fin.bad()) + while (fin >> s || !fin.bad()) { - if (s.find("_______|") != std::string::npos) - break; - //fin >> s; - } //while (!(s.find("_______|") != std::string::npos) || fin.eof()); - while (fin >> s || !fin.bad()) + if (s.find("_______|") != std::string::npos) + break; + // fin >> s; + } // while (!(s.find("_______|") != std::string::npos) || fin.eof()); + while (fin >> s || !fin.bad()) { - if (s == "[") - break; - } //while (!() || (fin.eof())); /*pierwsza linia z relacją*/ - while(fin >> s || !fin.bad()) + if (s == "[") + break; + } // while (!() || (fin.eof())); /*pierwsza linia z relacją*/ + while (fin >> s || !fin.bad()) { - if (s != "|") - break; - } //while (!(() || fin.eof())); + if (s != "|") + break; + } // while (!(() || fin.eof())); if (s != "|") Relation1 = s; else ConversionError = -5; - while(fin >> s || !fin.bad()) - { - if (s == "Relacja") - break; - } //while ( - // !( || (fin.eof()))); /*druga linia z relacją*/ while (fin >> s || !fin.bad()) { - if (s == "|") - break; - } //while (!( || (fin.eof()))); + if (s == "Relacja") + break; + } // while ( + // !( || (fin.eof()))); /*druga linia z relacją*/ + while (fin >> s || !fin.bad()) + { + if (s == "|") + break; + } // while (!( || (fin.eof()))); fin >> Relation2; while (fin >> s || !fin.bad()) { - if (s == "Wymagany") - break; - }// while (!(); + if (s == "Wymagany") + break; + } // while (!(); while (fin >> s || !fin.bad()) { - if ((s == "|") || (s == "\n")) - break; - } //while (!()); + if ((s == "|") || (s == "\n")) + break; + } // while (!()); fin >> s; s = s.substr(0, s.find("%")); BrakeRatio = atof(s.c_str()); while (fin >> s || fin.bad()) { - if (s == "Seria") - break; - } //while (!(s == "Seria")); + if (s == "Seria") + break; + } // while (!(s == "Seria")); do { - fin >> s; + fin >> s; } while (!((s == "|") || (fin.bad()))); fin >> LocSeries; - fin >> LocLoad;// = s2rE(ReadWord(fin)); + fin >> LocLoad; // = s2rE(ReadWord(fin)); do { - fin >> s; + fin >> s; } while (!(s.find("[______________") != std::string::npos || fin.bad())); while (!fin.bad() && !EndTable) { @@ -328,7 +329,7 @@ bool TTrainParameters::LoadTTfile(std::string scnpath, int iPlus, double vmax) { fin >> s; } while (!((s == "[") || (fin.bad()))); - TMTableLine *record = &TimeTable[StationCount]; + TMTableLine *record = &TimeTable[StationCount]; { if (s == "[") fin >> s; @@ -336,10 +337,11 @@ bool TTrainParameters::LoadTTfile(std::string scnpath, int iPlus, double vmax) ConversionError = -4; if (s.find("|") == std::string::npos) { - record->km = atof(s.c_str()); + record->km = atof(s.c_str()); fin >> s; } - if (s.find("|_____|") != std::string::npos) /*zmiana predkosci szlakowej*/ + if (s.find("|_____|") != + std::string::npos) /*zmiana predkosci szlakowej*/ UpdateVelocity(StationCount, vActual); else { @@ -360,14 +362,15 @@ bool TTrainParameters::LoadTTfile(std::string scnpath, int iPlus, double vmax) { if (s.find(hrsd) != std::string::npos) { - record->Ah = atoi(s.substr(0, s.find(hrsd)).c_str()); // godzina przyjazdu - record->Am = atoi( - s.substr(s.find(hrsd) + 1, s.length()).c_str()); // minuta przyjazdu + record->Ah = atoi( + s.substr(0, s.find(hrsd)).c_str()); // godzina przyjazdu + record->Am = atoi(s.substr(s.find(hrsd) + 1, s.length()) + .c_str()); // minuta przyjazdu } else { record->Ah = TimeTable[StationCount - 1] - .Ah; // godzina z poprzedniej pozycji + .Ah; // godzina z poprzedniej pozycji record->Am = atoi(s.c_str()); // bo tylko minuty podane } } @@ -387,7 +390,8 @@ bool TTrainParameters::LoadTTfile(std::string scnpath, int iPlus, double vmax) /*tu s moze byc miejscem zmiany predkosci szlakowej*/ fin >> s; } - if (s.find("|_____|") != std::string::npos) /*zmiana predkosci szlakowej*/ + if (s.find("|_____|") != + std::string::npos) /*zmiana predkosci szlakowej*/ UpdateVelocity(StationCount, vActual); else { @@ -408,24 +412,29 @@ bool TTrainParameters::LoadTTfile(std::string scnpath, int iPlus, double vmax) { if (s.find(hrsd) != std::string::npos) { - record->Dh = atoi(s.substr(0, s.find(hrsd)).c_str()); // godzina odjazdu - record->Dm = atoi( - s.substr(s.find(hrsd) + 1, s.length()).c_str()); // minuta odjazdu + record->Dh = + atoi(s.substr(0, s.find(hrsd)).c_str()); // godzina odjazdu + record->Dm = atoi(s.substr(s.find(hrsd) + 1, s.length()) + .c_str()); // minuta odjazdu } else { record->Dh = TimeTable[StationCount - 1] - .Dh; // godzina z poprzedniej pozycji + .Dh; // godzina z poprzedniej pozycji record->Dm = atoi(s.c_str()); // bo tylko minuty podane } } else { - record->Dh = record->Ah; // odjazd o tej samej, co przyjazd (dla ostatniego też) - record->Dm = record->Am; // bo są używane do wyliczenia opóźnienia po dojechaniu + record->Dh = record->Ah; // odjazd o tej samej, co przyjazd (dla + // ostatniego też) + record->Dm = record->Am; // bo są używane do wyliczenia opóźnienia + // po dojechaniu } if ((record->Ah >= 0)) - record->WaitTime = (int)(CompareTime(record->Ah, record->Am, record->Dh, record->Dm) + 0.1); + record->WaitTime = (int)(CompareTime(record->Ah, record->Am, + record->Dh, record->Dm) + + 0.1); do { fin >> s; @@ -443,7 +452,8 @@ bool TTrainParameters::LoadTTfile(std::string scnpath, int iPlus, double vmax) /*tu s moze byc miejscem zmiany predkosci szlakowej*/ fin >> s; } - if (s.find("|_____|") != std::string::npos) /*zmiana predkosci szlakowej*/ + if (s.find("|_____|") != + std::string::npos) /*zmiana predkosci szlakowej*/ UpdateVelocity(StationCount, vActual); else { @@ -536,12 +546,7 @@ bool TTrainParameters::DirectionChange() // sprawdzenie, czy po zatrzymaniu wykonać kolejne komendy { if ((StationIndex > 0) && (StationIndex < StationCount)) // dla ostatniej stacji nie - if (TimeTable[StationIndex].StationWare.find("@") != std::string::npos) + if (TimeTable[StationIndex].StationWare.find("@") != std::string::npos) return true; return false; } - - - - - diff --git a/mtable.h b/mtable.h index a6e4dec8..cb3ef157 100644 --- a/mtable.h +++ b/mtable.h @@ -18,92 +18,92 @@ http://mozilla.org/MPL/2.0/. namespace Mtable { - static int const MaxTTableSize = 100; // można by to robić dynamicznie - static char const *hrsd = "."; +static int const MaxTTableSize = 100; // można by to robić dynamicznie +static char const *hrsd = "."; - // Ra: pozycja zerowa rozkładu chyba nie ma sensu - // Ra: numeracja przystanków jest 1..StationCount +// Ra: pozycja zerowa rozkładu chyba nie ma sensu +// Ra: numeracja przystanków jest 1..StationCount - struct TMTableLine - { - double km; // kilometraz linii - double vmax; // predkosc rozkladowa przed przystankiem - // StationName:string[32]; //nazwa stacji ('_' zamiast spacji) - // StationWare:string[32]; //typ i wyposazenie stacji, oddz. przecinkami} - std::string StationName; // nazwa stacji ('_' zamiast spacji) - std::string StationWare; // typ i wyposazenie stacji, oddz. przecinkami} - int TrackNo; // ilosc torow szlakowych - int Ah; - int Am; // godz. i min. przyjazdu, -1 gdy bez postoju - int Dh; - int Dm; // godz. i min. odjazdu - double tm; // czas jazdy do tej stacji w min. (z kolumny) - int WaitTime; // czas postoju (liczony plus 6 sekund) - TMTableLine() - { - km = 0; - vmax = -1; - StationName = "nowhere", StationWare = ""; - TrackNo = 1; - Ah, Am, Dh, Dm = -1; - WaitTime, tm = 0; - } - }; +struct TMTableLine +{ + double km; // kilometraz linii + double vmax; // predkosc rozkladowa przed przystankiem + // StationName:string[32]; //nazwa stacji ('_' zamiast spacji) + // StationWare:string[32]; //typ i wyposazenie stacji, oddz. przecinkami} + std::string StationName; // nazwa stacji ('_' zamiast spacji) + std::string StationWare; // typ i wyposazenie stacji, oddz. przecinkami} + int TrackNo; // ilosc torow szlakowych + int Ah; + int Am; // godz. i min. przyjazdu, -1 gdy bez postoju + int Dh; + int Dm; // godz. i min. odjazdu + double tm; // czas jazdy do tej stacji w min. (z kolumny) + int WaitTime; // czas postoju (liczony plus 6 sekund) + TMTableLine() + { + km = 0; + vmax = -1; + StationName = "nowhere", StationWare = ""; + TrackNo = 1; + Ah, Am, Dh, Dm = -1; + WaitTime, tm = 0; + } +}; - typedef TMTableLine TMTable[MaxTTableSize + 1]; +typedef TMTableLine TMTable[MaxTTableSize + 1]; - //typedef TTrainParameters *PTrainParameters; +// typedef TTrainParameters *PTrainParameters; - class TTrainParameters - { - public: - std::string TrainName; - double TTVmax; - std::string Relation1; - std::string Relation2; // nazwy stacji danego odcinka - double BrakeRatio; - std::string LocSeries; // seria (typ) pojazdu - double LocLoad; - TMTable TimeTable; - int StationCount; // ilość przystanków (0-techniczny) - int StationIndex; // numer najbliższego (aktualnego) przystanku - std::string NextStationName; - double LastStationLatency; - int Direction; /*kierunek jazdy w/g kilometrazu*/ - double CheckTrainLatency(); - /*todo: str hh:mm to int i z powrotem*/ - std::string ShowRelation(); - double WatchMTable(double DistCounter); - std::string NextStop(); - bool IsStop(); - bool IsTimeToGo(double hh, double mm); - bool UpdateMTable(double hh, double mm, std::string NewName); - TTrainParameters(std::string NewTrainName); - void NewName(std::string NewTrainName); - void UpdateVelocity(int StationCount, double vActual); - bool LoadTTfile(std::string scnpath, int iPlus, double vmax); - bool DirectionChange(); - void StationIndexInc(); - }; +class TTrainParameters +{ + public: + std::string TrainName; + double TTVmax; + std::string Relation1; + std::string Relation2; // nazwy stacji danego odcinka + double BrakeRatio; + std::string LocSeries; // seria (typ) pojazdu + double LocLoad; + TMTable TimeTable; + int StationCount; // ilość przystanków (0-techniczny) + int StationIndex; // numer najbliższego (aktualnego) przystanku + std::string NextStationName; + double LastStationLatency; + int Direction; /*kierunek jazdy w/g kilometrazu*/ + double CheckTrainLatency(); + /*todo: str hh:mm to int i z powrotem*/ + std::string ShowRelation(); + double WatchMTable(double DistCounter); + std::string NextStop(); + bool IsStop(); + bool IsTimeToGo(double hh, double mm); + bool UpdateMTable(double hh, double mm, std::string NewName); + TTrainParameters(std::string NewTrainName); + void NewName(std::string NewTrainName); + void UpdateVelocity(int StationCount, double vActual); + bool LoadTTfile(std::string scnpath, int iPlus, double vmax); + bool DirectionChange(); + void StationIndexInc(); +}; - class TMTableTime +class TMTableTime - { - public: - double GameTime; - int dd; - int hh; - int mm; - int srh; - int srm; /*wschod slonca*/ - int ssh; - int ssm; /*zachod slonca*/ - double mr; - void UpdateMTableTime(double deltaT); - TMTableTime(int InitH, int InitM, int InitSRH, int InitSRM, int InitSSH, int InitSSM); - }; +{ + public: + double GameTime; + int dd; + int hh; + int mm; + int srh; + int srm; /*wschod slonca*/ + int ssh; + int ssm; /*zachod slonca*/ + double mr; + void UpdateMTableTime(double deltaT); + TMTableTime(int InitH, int InitM, int InitSRH, int InitSRM, int InitSSH, int InitSSM); +}; - extern TMTableTime *GlobalTime; +extern TMTableTime *GlobalTime; } #if !defined(NO_IMPLICIT_NAMESPACE_USE)